Integrate with Segment.com

# Flagship campaign activation
  fsVisitor.ActivateModification("my_flag")

# Get Flagship campaign information and send it to Segment 
  modifInfos, _ := fsVisitor.GetModificationInfo("my_flag")

  data := analytics.Track{
    UserId: fsVisitor.ID,
    Event:  "Flagship_Source_Go",
    Properties: analytics.NewProperties().
      Set("cid", modifInfos.CampaignID).
      Set("vgid", modifInfos.VariationGroupID).
      Set("vid", modifInfos.VariationID).
      Set("isref", modifInfos.IsReference).
      Set("val", modifInfos.Value),
  }
  segmentClient.Enqueue(data)

// Flagship campaign user exposition
    
    Flag<String> myFlag = flagshipVisitor.getFlag("myFlag", "defaultValue");
    myFlag.userExposed();

// Get Flagship campaign information, map it, and send it to Segment

    JSONObject json = myFlag.metadata().toJSON();
    if (json != null) {
        Iterator<String> iterator = json.keys();
        HashMap<String, Object> values = new HashMap<>();
        while (iterator.hasNext()) {
            String name = iterator.next();
            values.put(name, json.opt(name));
        }
        Properties properties = new Properties();
        properties.putAll(values);
        Analytics.with(appContext).track("Flagship_Source_Java", properties);
    }

// ... some other codes

Flagship.start("<ENV_ID>", "<API_KEY>", {
  onVisitorExposed: ({ exposedVisitor, fromFlag }) => {
    analytics.track(exposedVisitor.id, 'Flagship_Source_JS', fromFlag.metadata)
  }
})

//... do some stuff

// Then Calling flag.getValue() or flag.visitorExposed() anywhere will trigger onVisitorExposed callback

Flagship.start(
	getApplication(),
  _ENV_ID_,
  _API_KEY_,
  FlagshipConfig.DecisionApi()
    .withOnVisitorExposed { visitorExposed : VisitorExposed, exposedFlag: ExposedFlag<*> ->
      
    // Get Flagship campaign information, map it, and send it to Segment
  	val campaignMetadata = myFlag.metadata().toJson()
    campaignMetadata.keys().asSequence().associateWith { campaignMetadata[it]}.let { map ->
       val properties = Properties()
       properties.putAll(map)
       Analytics.with(appContext).track("Flagship_Source_Android", properties)
    }
  }

//Later in your app, trigger a visitor flag exposition:
val myFlag = visitor.getFlag("myFlag", "defaultValue")
myFlag.visitorExposed()

// We assume you created visitor and fetched flags

// Retrieve the current visitor
FSVisitor * currentVisitor = [[Flagship sharedInstance] sharedVisitor];

// Get Flag object
FSFlag * myFlagObject = [currentVisitor getFlagWithKey:@"my_flag" defaultValue:@"defaultValue"];

// Expose the campaign
[myFlagObject userExposed];

//Get Flagship campaign information and send it to Segment
NSDictionary * campaign_metadata =  [[myFlagObject metadata] toJson];
[[SEGAnalytics sharedAnalytics] track:@"Flagship_Source_Objc" properties: campaign_metadata];

# Flagship campaign activation

    flagship_visitor.activate_modification("my_flag")

# Get Flagship campaign information and send it to Segment 

    campaign_info = flagship_visitor.get_modification_info("my_flag")
    analytics.track("#User123", "Flagship_Source_Python", campaign_info)

//... some other codes

<FlagshipProvider 
   onVisitorExposed={({ exposedVisitor, fromFlag }) => {
    analytics.track(exposedVisitor.id, 'Flagship_Source_JS', fromFlag.metadata)
  }} >
 //... do some stuff

// Then Calling flag.getValue() or flag.visitorExposed() anywhere will trigger onVisitorExposed callback
</FlagshipProvider>

// We assume you created visitor and fetched flags

// Retrieve the current visitor
if let currentVisitor = Flagship.sharedInstance.sharedVisitor{
    
    // Get the flag object
    let myFlagObject = currentVisitor.getFlag(key: "my_flag", defaultValue:"defaultValue")
    
    // Expose the campaign
    myFlagObject.userExposed()
    
    // Get Flagship campaign information and send it to Segment
    let campaign_metadata =  myFlagObject.metadata().toJson()
    Analytics.shared().track("Flagship_Source_ios", properties: campaign_metadata)
}

<?php

require_once __DIR__.'/vendor/autoload.php';

use Flagship\Config\DecisionApiConfig;
use Flagship\Enum\CacheStrategy;
use Flagship\Flagship;
use Flagship\Model\ExposedFlagInterface;
use Flagship\Model\ExposedVisitorInterface;
use Segment\Segment;

// callback
function onVisitorExposed(ExposedVisitorInterface $visitorExposed, ExposedFlagInterface $fromFlag)
{
    // Forward the information to your third party
    // This block is excuted each time the visitorExposed is called and sucess

    //Get metadata of exposed flag
    $trackProperties = json_decode(json_encode($fromFlag->getMetadata()), true);
    
    Segment::init("YOUR_WRITE_KEY");

    // Send information to Segment
    Segment::track([
        "userId" => $visitorExposed->getId(),
        "event" => "flagship_event",
        "properties" => $trackProperties
    ]);
}

// Start SDK
Flagship::start("your_env_id", "your_api_key", DecisionApiConfig::decisionApi()
        ->setCacheStrategy(CacheStrategy::BATCHING_AND_CACHING_ON_FAILURE)
        ->setOnVisitorExposed('onVisitorExposed')); // set the callback

// Create visitor
$visitor = Flagship::newVisitor('visitorId')->build();

//Fetch flags
$visitor->fetchFlags();

// Ex: get flag for vip feature
$flag = $visitor->getFlag("displayVipFeature", false);

// Use this flag value to enable displaying the vip feature.
$flag->getValue();

// You should keep in mind by default on getting the flag value ,the SDK expose the visitor.

// batch and send all hits in the pool 
Flagship::close();

// when the expose sucess ==>  the callback defined in the "setOnVisitorExposed" config will be triggered

// ... some other codes

//Define the function that should be called when the OnVisitorExposed event is triggered
void Config_OnVisitorExposed(Flagship.FsVisitor.IExposedVisitor exposedVisitor, Flagship.FsFlag.IExposedFlag exposedFlag)
{
    Analytics.Client.Track(exposedVisitor.Id, "Flagship_Source_DotNet", new Properties() {
    { "CampaignId", exposedFlag.Metadata.CampaignId },
    { "VariationGroupId", exposedFlag.Metadata.VariationGroupId },
    { "VariationId", exposedFlag.Metadata.VariationId },
});
}

//Create sdk config object
var config = new Flagship.Config.DecisionApiConfig();

//Add OnVisitorExposed event
config.OnVisitorExposed += Config_OnVisitorExposed;

// Start the SDK
Flagship.Main.Fs.Start("your_env_id", "your_api_key", config);

//... do some stuff

// Then Calling flag.GetValue() or flag.VisitorExposed() anywhere will trigger onVisitorExposed event