import com.optimizely.ab.Optimizely;

// Initialize an Optimizely client
optimizelyClient = Optimizely.builder(datafile, myEventHandler).build();

// Activate user in an experiment
Variation variation = optimizelyClient.activate("my_experiment", userId);

if (variation != null) {
  if (variation.is("control")) {
    // Execute code for variation A
  } else if (variation.is("treatment")) {
    // Execute code for variation B
  }
} else {
  // Execute default code
}

// Track conversion event
optimizelyClient.track("my_conversion", userId);

using OptimizelySDK;

// Initialize an Optimizely client
Optimizely OptimizelyClient = new Optimizely(datafile);

// Activate user in an experiment
var variation = OptimizelyClient.Activate("my_experiment", userId);

if (variation != null)
{
    if (variation == "control")
    {
        // Execute code for variation A
    }
    else if (variation == "treatment")
    {
        // Execute code for variation B
    }
}
else
{
    // Execute default code
}

// Track conversion event
OptimizelyClient.Track("my_conversion", userId);

import com.optimizely.ab.Optimizely;

// Get an Optimizely client
OptimizelyClient optimizelyClient = optimizelyManager.getOptimizely();

// Activate user in an experiment
Variation variation = optimizelyClient.activate("my_experiment", "user_id");

if (variation != null) {
  if (variation.is("control")) {
    // Execute code for variation A
  } else if (variation.is("treatment")) {
    // Execute code for variation B
  }
} else {
  // Execute default code
}

// Track conversion event
optimizelyClient.track("my_conversion", user_id);

require "optimizely"

# Initialize an Optimizely client
optimizely_client = Optimizely::Project.new(datafile)

# Activate user in an experiment
variation = optimizely_client.activate("my_experiment", user_id)

if variation == 'control'
  # Execute code for variation A
elsif variation == 'treatment'
  # Execute code for variation B
else
  # Execute default code
end

# Track conversion event
optimizely_client.track("my_conversion", user_id)

var optimizely = require('optimizely-server-sdk');

// Initialize an Optimizely client
var optimizelyClient = optimizely.createInstance({ datafile: datafile });

// Activate user in an experiment
var variation = optimizelyClient.activate("my_experiment", userId);

if (variation === 'control') {
  // Execute code for variation A
} else if (variation === 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
optimizelyClient.track("my_conversion", userId);

var optimizely = require('optimizely-client-sdk');

// Initialize an Optimizely client
var optimizelyClientInstance = optimizely.createInstance({ datafile: datafile });

// Alternatively, if you don't use CommonJS or npm, you can install the minified snippet and use the globally exported varible as follows
var optimizelyClientInstance = window.optimizelyClient.createInstance({ datafile: datafile });

// Activate user in an experiment
var variation = optimizelyClientInstance.activate("my_experiment", userId);

if (variation === 'control') {
  // Execute code for variation A
} else if (variation === 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
optimizelyClientInstance.track("my_conversion", userId);

use Optimizely\Optimizely;

// Initialize an Optimizely client
$optimizelyClient = new Optimizely($datafile);

// Activate user in an experiment
$variation = $optimizelyClient->activate('my_experiment', $userId);

if ($variation == 'control') {
  // Execute code for variation A
} elseif ($variation == 'treatment') {
  // Execute code for variation B
} else {
  // Execute default code
}

// Track conversion event
$optimizelyClient->track('my_conversion', $userId);

// Initialize an Optimizely manager
OPTLYManager *optlyManager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
    builder.projectId = @"projectId";
}];

// Initialize an Optimizely client by asynchronously downloading the datafile
[optlyManager initializeWithCallback:^(NSError * _Nullable error, OPTLYClient * _Nullable client) {
    // Activate user in an experiment
    OPTLYVariation *variation = [client activate:@"my_experiment" userId:@"userId"];

    if ([variation.variationKey isEqualToString:@"control"]) {
        // Execute code for the control
    } else if ([variation.variationKey isEqualToString:@"treatment"]) {
        // Execute code for the treatment
    } else {
        // Execute default code
    }

    // Track conversion event
    [client track:@"my_conversion" userId:@"userId"];
}];

// Initialize an Optimizely manager
let optimizelyManager : OPTLYManager? = OPTLYManager.init {(builder) in
    builder!.projectId = "projectId"
}

// Initialize an Optimizely client by asynchronously downloading the datafile
optimizelyManager?.initialize(callback: { [weak self] (error, optimizelyClient) in

    // Activate user in an experiment
    if let variation = optimizelyClient?.activate("my_experiment", userId: "userId")
    {
        if (variation.variationKey == "control") {
            // Execute code for the control
        }
        else if (variation.variationKey == "treatment") {
            // Execute code for the treatment
        }
    } else {
        // execute default code
    }

    // Track conversion event
    optimizelyClient?.track("my_conversion", userId: "userId")
})

public class MyApplication extends Application {

  private OptimizelyManager optimizelyManager;

  public OptimizelyManager getOptimizelyManager() {
    return optimizelyManager;
  }

  @Override public void onCreate() {
    super.onCreate();

    optimizelyManager = OptimizelyManager.builder()
      .withEventHandlerDispatchInterval(1, TimeUnit.DAYS)
      .withDataFileDownloadInterval(1, TimeUnit.DAYS)
      .build();
  }
}

OPTLYDatafileManagerDefault *datafileManager = [OPTLYDatafileManagerDefault initWithBuilderBlock:^(OPTLYDatafileManagerBuilder * _Nullable builder) {
  builder.projectId = @"1234";
  builder.datafileFetchInterval = 120; // seconds
}];

OPTLYManager *optlyManager = [OPTLYManager initWithBuilderBlock:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = @"1234";
  builder.datafileManager = datafileManager;
}];

let datafileManager: OPTLYDatafileManagerDefault? = OPTLYDatafileManagerDefault.initWithBuilderBlock({ (builder) in
  builder!.projectId = "1234"
  builder!.datafileFetchInterval = 120 // seconds
})

let optimizelyManager: OPTLYManager? = OPTLYManager.initWithBuilderBlock({ (builder) in
  builder!.projectId = "1234"
  builder!.datafileManager = datafileManager
})

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

{
    "project_id": 1234,
    "timestamp": 1468447113,
    "event": "project.datafile_updated",
    "data": {
        "revision": 1,
        "origin_url": "https://optimizely.s3.amazonaws.com/json/1234.json",
        "cdn_url": "https://cdn.optimizely.com/json/1234.json"
    }
}

public class FirstActivity extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_first);

    OptimizelyManager optimizelyManager =
        ((MyApplication) getApplication()).getOptimizelyManager();

    optimizelyManager.initialize(this, new OptimizelyStartListener()  {
      @Override public void onStart(OptimizelyClient optimizely) {
          assert optimizely == optimizelyManager.getOptimizely();
          Intent intent = new Intent(FirstActivity.this, SubsequentActivity.class);
          startActivity(intent);
      }
    });
  }
}

public class FirstActivitySynchronousStart extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_first);

    OptimizelyManager optimizelyManager =
        ((MyApplication) getApplication()).getOptimizelyManager();
    assert optimizelyManager.getOptimizely() == null;

    OptimizelyClient optimizely = optimizelyManager.initialize(MyActivity.this, R.raw.data_file);
    assert optimizely != null;
  }
}

public class SubsequentActivity extends Activity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_subsequent);

    final OptimizelyManager optimizelyManager =
        ((MyApplication) getApplication()).getOptimizelyManager();

    OptimizelyClient optimizely = optimizelyManager.getOptimizely();
    assert optimizely != null;
  }
}

String experimentKey = "my_experiment";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "iPhone");
attributes.put("AD_SOURCE", "my_campaign");

// Conditionally activate an experiment for the provided user
Variation variation = optimizelyClient.activate(experimentKey, userId, attributes);

using OptimizelySDK.Entity;

var experimentKey = "my_experiment";
var userId = "user123";

UserAttributes attributes = new UserAttributes
{
    { "DEVICE", "iPhone" },
    { "AD_SOURCE", "my_campaign" }
};

// Conditionally activate an experiment for the provided user
var variation = OptimizelyClient.Activate(experimentKey, userId, attributes);

OptimizelyClient optimizely = optimizelyManager.getOptimizely();

String experimentKey = "my_experiment";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "Nexus 6P");
attributes.put("AD_SOURCE", "my_campaign");

// Conditionally activate a experiment for the provided user
Variation variation = optimizely.activate(experimentKey, userId, attributes);

experiment_key = 'my_experiment'
user_id = 'user123'
attributes = {'DEVICE' => 'iPhone', 'AD_SOURCE' => 'my_campaign'}

# Conditionally activate an experiment for the provided user
variation = optimizely_client.activate(experiment_key, user_id, attributes)

var experimentKey = 'my_experiment';
var userId = 'user123';
var attributes = { 'device': 'iphone', 'ad_source': 'my_campaign' };

// Conditionally activate an experiment for the provided user
var variation = optimizely.activate(experimentKey, userId, attributes);

var experimentKey = 'my_experiment';
var userId = 'user123';
var attributes = { 'device': 'iphone', 'ad_source': 'my_campaign' };

// Conditionally activate an experiment for the provided user
var variation = optimizelyClientInstance.activate(experimentKey, userId, attributes);

$experimentKey = 'my_experiment';
$userId = 'user123';
$attributes = [
    'device' => 'iphone',
    'ad_source' => 'my_campaign'
];

// Conditionally activate an experiment for the provided user
$variation = $optimizelyClient->activate($experimentKey, $userId, $attributes);

NSDictionary *attributes = @{@"device" : @"iPhone", @"ad_source" : @"my_campaign"};

OPTLYVariation *variation = [optimizely activate:@"my_experiment"
                                          userId:@"user123"
                                      attributes:attributes];

let attributes = ["device" : "iPhone", "ad_source" : "my_campaign"]

let variation: OPTLYVariation? = optimizely?.activate("my_experiment", userId:"user123", attributes:attributes)

String experimentKey = "my_experiment";
String userId = "user123";

// Get the active variation for the provided user
Variation variation = optimizelyClient.getVariation(experimentKey, userId);

var experimentKey = "my_experiment";
var userId = "user123";

// Get the active variation for the provided user
var variation = OptimizelyClient.GetVariation(experimentKey, userId);

String experimentKey = "my_experiment";
String userId = "user123";

Optimizely optimizelyClient = optimizelyManager.getOptimizely();

// Get the active variation for the provided user
Variation variation = optimizelyClient.getVariation(experimentKey, userId);

experiment_key = 'my_experiment'
user_id = 'user123'

# Get the active variation for the provided user
variation = optimizely_client.get_variation(experiment_key, user_id)

$experimentKey = 'my_experiment';
$userId = 'user123';

# Get the active variation for the provided user
$variation = $optimizelyClient->getVariation($experimentKey, $userId);

var experimentKey = 'my_experiment';
var userId = 'user123';

// Get the active variation for the provided user
var variation = optimizelyClientInstance.getVariation(experimentKey, userId);

var experimentKey = 'my_experiment';
var userId = 'user123';

// Get the active variation for the provided user
var variation = optimizelyClient.getVariation(experimentKey, userId);

// Get the active variation for an experiment for the provided user
OPTLYVariation *variation = [optimizely variation:@"my_experiment"
                                           userId:@"user123"];

// Get the active variation for an experiment for the provided user
let variation: OPTLYVariation? = optimizely?.variation("my_experiment", userId:"user123")

String eventKey = "my_conversion";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "iPhone");
attributes.put("AD_SOURCE", "my_campaign");

Map<String, Object> eventTags = new HashMap<String, Object>();
eventTags.put("purchasePrice", 64.32f);
eventTags.put("category", "shoes");

// reserved "revenue" tag,
eventTags.put("revenue", 6432);

// Track event with user attributes and event tags
optimizely.track(eventKey, userId, attributes, eventTags);

using OptimizelySDK.Entity;

var eventKey = "my_conversion";
var userId = "user123";

UserAttributes attributes = new UserAttributes
{
    { "DEVICE", "iPhone" },
    { "AD_SOURCE", "my_campaign" }
};

EventTags tags = new EventTags
{
    { "purchasePrice", 64.32 },
    { "category", "shoes" },
    { "revenue", 6432 }  // reserved "revenue" tag
};

// Track event with user attributes and event tags
OptimizelyClient.Track(eventKey, userId, attributes, tags);

event_key = 'my_conversion'
user_id = 'user123'

attributes = {
  'device' => 'iPhone',
  'adSource' => 'my_campaign'
}

event_tags = {
  'category' => 'shoes',
  'purchasePrice' => 64.32,
  'revenue' => 6432  # reserved "revenue" tag
}

# Track event with user attributes and event tags
optimizely_client.track(event_key, user_id, attributes, event_tags)

# Track event with event tags and without user attributes
optimizely_client.track(event_key, user_id, nil, event_tags)

$eventKey = 'my_conversion';
$userId = 'user123';

$attributes = [
    'device' => 'iphone',
    'ad_source' => 'my_campaign'
];

$eventTags = [
    'category' => 'shoes',
    'purchasePrice' => 64.32,
    'revenue' => 6432 # reserved "revenue" tag
];

# Track event with user attributes and event tags
$optimizelyClient->track($eventKey, $userId, $attributes, $eventTags);

# Track event with event tags and without user attributes
$optimizelyClient->track($eventKey, $userId, null, $eventTags);

var eventKey = "my_conversion";
var userId = "user123";

var attributes = {
  DEVICE: 'iPhone',
  AD_SOURCE: 'my_campaign'
};

var eventTags = {
  category: 'shoes',
  purchasePrice: 64.32,
  revenue: 6432  // reserved "revenue" tag
};

// Track event with user attributes and event tags
optimizely.track(eventKey, userId, attributes, eventTags);

var eventKey = "my_conversion";
var userId = "user123";

var attributes = {
  DEVICE: 'iPhone',
  AD_SOURCE: 'my_campaign'
};

var eventTags = {
  category: 'shoes',
  purchasePrice: 64.32,
  revenue: 6432  // reserved "revenue" tag
};

// Track event with user attributes and event tags
optimizely.track(eventKey, userId, attributes, eventTags);

NSDictionary *attributes = @{@"device" : @"iPhone", @"ad_source" : @"my_campaign"};

NSDictionary *eventTags = @{
  @"purchasePrice" : @64.32,
  @"category" : @"shoes",
  @"revenue": @6432  // reserved "revenue" tag
};

// Track event with user attributes and event tags
[optimizely track:@"my_conversion"
           userId:@"user123"
       attributes:attributes
       eventTags:eventTags];

let attributes = ["device" : "iPhone", "ad_source" : "my_campaign"]

var eventTags = Dictionary<String, Any>()
eventTags["purchasePrice"] = 64.32
eventTags["category"] = "shoes"
eventTags["revenue"] = 6432  // reserved "revenue" tag

// Track event with user attributes and event tags
optimizely?.track("my_conversion",
                  userId:"user123",
                  attributes:attributes,
                  eventTags:eventTags)

String eventKey = "my_conversion";
String userId = "user123";

Map<String, String> attributes = new HashMap<String, String>();
attributes.put("DEVICE", "iPhone");
attributes.put("AD_SOURCE", "my_campaign");

Map<String, Object> eventTags = new HashMap<String, Object>();
eventTags.put("purchasePrice", 64.32f);
eventTags.put("category", "shoes");

// reserved "revenue" tag,
eventTags.put("revenue", 6432);

Optimizely optimizelyClient = optimizelyManager.getOptimizely();

// Track event with user attributes and event tags
optimizelyClient.track(eventKey, userId, attributes, eventTags);

import com.optimizely.ab.Optimizely;
import com.optimizely.ab.config.parser.ConfigParseException;
import com.optimizely.ab.event.AsyncEventHandler;
import com.optimizely.ab.event.EventHandler;

// Creates an async event handler with a max buffer of
// 20,000 events and a single dispatcher thread
EventHandler eventHandler = new AsyncEventHandler(20000, 1);

Optimizely optimizelyClient;
try {
    // Create an Optimizely client with the default event dispatcher
    optimizelyClient = Optimizely.builder(datafile,
                                          eventHandler).build();
} catch (ConfigParseException e) {
    // Handle exception gracefully
    return;
}

using OptimizelySDK.Event.Dispatcher;

// Create an Optimizely client with the default event dispatcher
Optimizely OptimizelyClient = new Optimizely(
    datafile: config.ProjectConfigJson,
    eventDispatcher: new Event.Dispatcher.DefaultEventDispatcher());

EventHandler eventHandler = YourEventHandler.getInstance();

// Create an Optimizely client with your own event handler
Optimizely optimizelyClient = Optimizely.builder(datafile,
                                                 eventHandler).build();

# Create an Optimizely client with the default event dispatcher
optimizely_client = Optimizely::Project.new(datafile,
                                            Optimizely::EventDispatcher.new)

var defaultEventDispatcher = require('optimizely-server-sdk/lib/plugins/event_dispatcher');

// Create an Optimizely client with the default event dispatcher
var optimizelyClient = optimizely.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

var defaultEventDispatcher = require('optimizely-client-sdk/lib/plugins/event_dispatcher');

// Create an Optimizely client with the default event dispatcher
var optimizelyClientInstance = optimizely.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher
});

use Optimizely\Event\Dispatcher\DefaultEventDispatcher;

// Create an Optimizely client with the default event dispatcher
$optimizelyClient = new Optimizely($datafile, new DefaultEventDispatcher());

CustomEventDispatcher<OPTLYEventDispatcher> *customEventDispatcher = [[CustomEventDispatcher alloc] init];

// initialize your Manager (settings will propagate to OPTLYClient and Optimizely)
OPTLYManager *manager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.eventDispatcher = eventDispatcher;
}];

let customEventDispatcher: CustomEventDispatcher = CustomEventDispatcher.init()

// initialize your Manager (settings will propagate to OPTLYClient and Optimizely)
let manager: OPTLYManager? =  OPTLYManager.init({ (builder) in
  builder!.datafile = datafile
  builder!.eventDispatcher = customEventDispatcher
})

optimizely_client = Optimizely::Project.new(datafile,
                                            Optimizely::EventDispatcher.new,
                                            Optimizely::NoOpLogger.new)

using OptimizelySDK.Logger;

ILogger Logger = new Log4NetLogger();
Optimizely OptimizelyClient = new Optimizely(
    datafile: config.ProjectConfigJson,
    logger: Logger);

var defaultLogger = require('optimizely-server-sdk/lib/plugins/logger');

var optimizelyClient = optimizely.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

var defaultLogger = {
  log: function(message) {
    console.log(message);
  },
};

// custom logger
var optimizelyClientInstance = optimizely.createInstance({
  datafile: datafile,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger,
});

// custom logLevel (2, DEBUG) with default logger
var optimizelyClientInstance = optimizely.createInstance({
  datafile: datafile,
  logLevel: 2,
});

use Optimizely\Logger\DefaultLogger;

$optimizelyClient = new Optimizely($datafile, null, new DefaultLogger());

CustomLogger *customLogger = [[CustomLogger alloc] init];

OPTLYManager *manager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.logger = customLogger;
}];

OPTLYLoggerDefault *optlyLogger = [[OPTLYLoggerDefault alloc] initWithLogLevel:OptimizelyLogLevelAll];
OPTLYManager *manager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.logger = optlyLogger;
}];

let customLogger: CustomLogger? = CustomLogger()

let manager: OPTLYManager? =  OPTLYManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.logger = customLogger
})

let optlyLogger: OPTLYLoggerDefault? = OPTLYLoggerDefault.init(logLevel: OptimizelyLogLevel.All)
let manager: OPTLYManager? =  OPTLYManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.logger = optlyLogger
})

# android-logger.properties example

# Core
logger.com.optimizely.ab.Optimizely=DEBUG:Optly.core
logger.com.optimizely.ab.annotations=DEBUG:Optly.annotations
logger.com.optimizely.ab.bucketing=DEBUG:Optly.bucketing
logger.com.optimizely.ab.config=DEBUG:Optly.config
logger.com.optimizely.ab.error=DEBUG:Optly.error
logger.com.optimizely.ab.event=DEBUG:Optly.event
logger.com.optimizely.ab.internal=DEBUG:Optly.internal

# Android
logger.com.optimizely.ab.android.sdk=DEBUG:Optly.androidSdk
logger.com.optimizely.ab.android.event_handler=DEBUG:Optly.eventHandler
logger.com.optimizely.ab.android.shared=DEBUG:Optly.shared
logger.com.optimizely.ab.android.user_profile=DEBUG:Optly.userProfile

# Disable most SDK logs by commenting all other lines and uncommenting below
#logger.com.optimizely.ab=ASSERT:Optly

import com.optimizely.ab.Optimizely;
import com.optimizely.ab.error.ErrorHandler;
import com.optimizely.ab.error.RaiseExceptionErrorHandler;
import com.optimizely.ab.event.AsyncEventHandler;
import com.optimizely.ab.event.EventHandler;

EventHandler eventHandler = new AsyncEventHandler(20000, 1);

// Default handler that raises exceptions
ErrorHandler errorHandler = new RaiseExceptionErrorHandler();

Optimizely optimizelyClient;
try {
    // Create an Optimizely client with the default event dispatcher
    optimizelyClient = Optimizely.builder(datafile, eventHandler).
                           .withErrorHandler(errorHandler)
                           .build();
} catch (ConfigParseException e) {
    // Handle exception gracefully
    return;
}

using OptimizelySDK.ErrorHandler;

Optimizely OptimizelyClient = new Optimizely(
    datafile: config.ProjectConfigJson,
    errorHandler: new DefaultErrorHandler());

// Event handler is required to make Optimizely
EventHandler eventHandler = YourEventHandler.getInstance();

// You can optionally provide an error handler
ErrorHandler errorHandler = YourErrorHandler.getInstance();

Optimizely optimizelyClient = Optimizely.builder(datafile, eventHandler)
    .withErrorHandler(errorHandler)
    .build();

optimizely_client = Optimizely::Project.new(datafile,
                                            Optimizely::EventDispatcher.new,
                                            Optimizely::NoOpLogger.new,
                                            Optimizely::NoOpErrorHandler.new)

var defaultErrorHandler = require('optimizely-server-sdk/lib/plugins/error_handler');

optimizelyClient = optimizely.createInstance({
  datafile: datafile,
  errorHandler: defaultErrorHandler,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

var defaultErrorHandler = require('optimizely-server-sdk/lib/plugins/error_handler');

var optimizelyClientInstance = optimizely.createInstance({
  datafile: datafile,
  errorHandler: defaultErrorHandler,
  eventDispatcher: defaultEventDispatcher,
  logger: defaultLogger.createLogger(),
});

use Optimizely\ErrorHandler\DefaultErrorHandler;

$optimizelyClient = new Optimizely($datafile, null, null, new DefaultErrorHandler());

CustomErrorHandler *customErrorHandler = [[CustomErrorHandler alloc] init];

OPTLYManager *manager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.errorHandler = customErrorHandler;
}];

let customErrorHandler: CustomErrorHandler? = CustomErrorHandler()

let manager: OPTLYManager? =  OPTLYManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.errorHandler = customErrorHandler
})

// Event handler is required to make Optimizely
EventHandler eventHandler = YourEventHandler.getInstance();

// You can optionally provide a user profile
UserProfile userProfile = UserProfile.getInstance();

Optimizely optimizelyClient = Optimizely.builder(datafile, eventHandler)
    .withUserProfile(userProfile)
    .build();

var optimizely = require('optimizely-client-sdk');

// Sample user profile service implementation
var userProfileService = {
  lookup: function(userId) {
    // perform user profile lookup
  },
  save: function(userProfileMap) {
    // persist user profile
  }
};

var datafile; // your project's datafile
var optimizelyClient = optimizely.createInstance({
  datafile: datafile,
  userProfileService: userProfileService,
});

var optimizely = require('optimizely-server-sdk');

// Sample user profile service implementation
var userProfileService = {
  lookup: function(userId) {
    // perform user profile lookup
  },
  save: function(userProfileMap) {
    // persist user profile
  }
};

var datafile; // your project's datafile
var optimizelyClient = optimizely.createInstance({
  datafile: datafile,
  userProfileService: userProfileService,
});

CustomUserProfile<OPTLYUserProfile> *customUserProfile = [[CustomUserProfile alloc] init];

// initialize your Manager (settings will propagate to OPTLYClient and Optimizely)
OPTLYManager *manager = [OPTLYManager init:^(OPTLYManagerBuilder * _Nullable builder) {
  builder.projectId = kProjectId;
  builder.userProfile = userProfile;
}];

use Optimizely\Logger\DefaultLogger;
use Optimizely\UserProfile\UserProfileServiceInterface;
use Optimizely\Optimizely;

class UserProfileService implements UserProfileServiceInterface
{
  public function lookup($userId)
  {
    // perform user profile lookup
  }

  public function save($userProfileMap) {
    // persist user profile
  }
}

$datafile = {}; // your project's datafile
$optimizelyClient = new Optimizely(
  $datafile,
  null,
  new DefaultLogger(),
  null,
  false,
  new UserProfileService()
);

# Sample user profile service implementation
class UserProfileService
  def lookup(user_id)
    # retrieve user profile
  end

  def save(user_profile)
    # save user profile
  end
end

optimizely_client = Optimizely::Project.new(datafile,
                                            Optimizely::EventDispatcher.new,
                                            Optimizely::NoOpLogger.new,
                                            nil,
                                            false,
                                            UserProfileService.new)

let customUserProfile: CustomUserProfile? = CustomUserProfile.init()

// initialize your Manager (settings will propagate to OPTLYClient and Optimizely)
let manager: OPTLYManager? =  OPTLYManager.init({ (builder) in
  builder!.projectId = projectId
  builder!.userProfile = customUserProfile
})

import com.optimizely.ab.notification.NotificationListener;

// Create a new listener and override a method
NotificationListener listener = new NotificationListener() {
  @Override
  public void onExperimentActivated(Experiment experiment, String userId, Map<String, String> attributes, Variation variation) {
    Log.i(TAG, "Optimizely experiment activated.");
  }
};

// Add a listener
Optimizely optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

// Remove a listener
optimizelyClient.removeNotificationListener(listener);

// Clear all listeners
optimizelyClient.clearNotificationListeners();

import com.optimizely.ab.notification.NotificationListener;

// Create a new listener and override methods
NotificationListener listener = new NotificationListener() {
  @Override
  public void onEventTracked(String eventKey,
                             String userId,
                             Map<String, String> attributes,
                             Long eventValue,
                             LogEvent logEvent) {
    Log.i(TAG, "Optimizely event tracked.");
  }

  @Override
  public void onExperimentActivated(Experiment experiment,
                                    String userId,
                                    Map<String, String> attributes,
                                    Variation variation) {
    Log.i(TAG, "Optimizely experiment activated.");
  }
};

// Add a listener
Optimizely optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

// Remove a listener
optimizelyClient.removeNotificationListener(listener);

// Clear all listeners
optimizelyClient.clearNotificationListeners();

#import "Amplitude.h"
#import "AMPIdentify.h"

[[NSNotificationCenter defaultCenter]
  addObserverForName:OptimizelyDidActivateExperimentNotification
              object:nil
               queue:nil
          usingBlock:^(NSNotification * _Nonnull note) {
            // Set "user property" for the user
            OPTLYExperiment *experiment
                = note.userInfo[OptimizelyNotificationsUserDictionaryExperimentKey];
            OPTLYVariation *variation
                = note.userInfo[OptimizelyNotificationsUserDictionaryVariationKey];
            NSString *propertyKey
                = [NSString stringWithFormat:@"[Optimizely] %@",
                    experiment.experimentKey];
            AMPIdentify *identify
                = [[AMPIdentify identify] set:propertyKey
                                        value:variation.variationKey];
            [[Amplitude instance] identify:identify];

            // Track impression event (optional)
            NSString *eventIdentifier
                = [NSString stringWithFormat:@"[Optimizely] %@ - %@",
                    experiment.experimentKey,
                    variation.variationKey];
            [[Amplitude instance] logEvent:eventIdentifier];
          }];

import Amplitude_iOS

let defaultNotificationCenter = NotificationCenter.default
defaultNotificationCenter.addObserver(
    forName: NSNotification.Name("OptimizelyExperimentActivated"),
     object: nil,
      queue: nil) { (note) in

  let userInfo : Dictionary<String, AnyObject>?
      = note.userInfo as! Dictionary<String, AnyObject>?
  if let experiment = userInfo?["experiment"] as! OPTLYExperiment? {
    if let variation = userInfo?["variation"] as! OPTLYVariation? {

      // Set "user property" for the user
      let propertyKey : String! = "[Optimizely] " + experiment.experimentKey
      let identify : AMPIdentify = AMPIdentify()
      identify.set(propertyKey, value:variation.variationKey as NSObject!)

      // Track impression event (optional)
      let eventIdentifier : String = "[Optimizely] "
          + experiment.experimentKey + " - " + variation.variationKey
      Amplitude.instance().logEvent(eventIdentifier)
    }
  }
}

import com.amplitude.api.Amplitude;
import com.amplitude.api.AmplitudeClient;
import com.amplitude.api.Identify;
import com.optimizely.ab.config.Experiment;
import com.optimizely.ab.config.Variation;
import com.optimizely.ab.notification.NotificationListener;

NotificationListener listener = new NotificationListener() {
  @Override
  public void onExperimentActivated(Experiment experiment,
                                    String userId,
                                    Map<String, String> attributes,
                                    Variation variation) {
    String experimentKey = experiment.getKey();
    String variationKey = variation.getKey();

    // Set "user property" for the user
    Identify identify = new Identify().set(
        "[Optimizely] " + experimentKey, variationKey);
    AmplitudeClient amplitudeClient = Amplitude.getInstance();
    amplitudeClient.identify(identify);

    // Track impression event (optional)
    amplitudeClient.logEvent(
        "[Optimizely] " + experimentKey + " - " + variationKey);
  }
};

// Add listener
OptimizelyClient optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

#import <Google/Analytics.h>

[[NSNotificationCenter defaultCenter]
  addObserverForName:OptimizelyDidActivateExperimentNotification
              object:nil
               queue:nil
          usingBlock:^(NSNotification * _Nonnull note) {
            // Google Analytics tracker
            id<GAITracker> tracker = [GAI sharedInstance].defaultTracker;

            // Build and send an Event
            OPTLYExperiment *experiment
                = note.userInfo[OptimizelyNotificationsUserDictionaryExperimentKey];
            OPTLYVariation *variation
                = note.userInfo[OptimizelyNotificationsUserDictionaryVariationKey];
            NSString *action
                = [NSString stringWithFormat:@"Experiment - %@",
                    experiment.experimentKey];
            NSString *label
                = [NSString stringWithFormat:@"Variation - %@",
                    variation.variationKey];
            [tracker send:[[GAIDictionaryBuilder
                createEventWithCategory:@"Optimizely"
                                 action:action
                                  label:label
                                  value:nil] build]];
          }];

let defaultNotificationCenter = NotificationCenter.default
defaultNotificationCenter.addObserver(
    forName: NSNotification.Name("OptimizelyExperimentActivated"),
     object: nil,
      queue: nil) { (note) in

  let userInfo : Dictionary<String, AnyObject>?
      = note.userInfo as! Dictionary<String, AnyObject>?
  if let experiment = userInfo?["experiment"] as! OPTLYExperiment? {
    if let variation = userInfo?["variation"] as! OPTLYVariation? {
      // Google Analytics tracker
      let tracker : GAITracker? = GAI.sharedInstance().defaultTracker

      let action : String = "Experiment - " + experiment.experimentKey
      let label : String = "Variation - " + variation.variationKey

      // Build and send an Event
      let builder = GAIDictionaryBuilder.createEvent(
          withCategory: "Optimizely",
          action: action,
          label: label,
          value: nil).build()
      tracker?.send(builder as [NSObject : AnyObject]!)
    }
  }
}

import com.google.android.gms.analytics.GoogleAnalytics;
import com.google.android.gms.analytics.HitBuilders;
import com.google.android.gms.analytics.Tracker;
import com.optimizely.ab.config.Experiment;
import com.optimizely.ab.config.Variation;
import com.optimizely.ab.notification.NotificationListener;

NotificationListener listener = new NotificationListener() {
  @Override
  public void onExperimentActivated(Experiment experiment,
                                    String userId,
                                    Map<String, String> attributes,
                                    Variation variation) {
    String experimentKey = experiment.getKey();
    String variationKey = variation.getKey();

    // Google Analytics tracker
    SampleApp application = (SampleApp) getApplication();
    mTracker = application.getDefaultTracker();

    // Build and send a non-interaction Event
    mTracker.send(new HitBuilders.EventBuilder()
        .setCategory("Optimizely")
        .setAction("Experiment - " + experimentKey)
        .setLabel("Variation - " + variationKey)
        .setNonInteraction(true)
        .build());
  }
};

// Add listener
OptimizelyClient optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

@import Localytics;

[[NSNotificationCenter defaultCenter]
  addObserverForName:OptimizelyDidTrackEventNotification
              object:nil
               queue:nil
          usingBlock:^(NSNotification * _Nonnull note) {
              // Set event attributes
              NSMutableDictionary *attributes = [NSMutableDictionary new];
              id userDictionary
                  = note.userInfo[OptimizelyNotificationsUserDictionaryAttributesKey];
              if (!!userDictionary) {
                [attributes addEntriesFromDictionary:userDictionary];
              }
              [note.userInfo[OptimizelyNotificationsUserDictionaryExperimentVariationMappingKey]
                enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key,
                                                    id  _Nonnull obj,
                                                    BOOL * _Nonnull stop) {
                  [attributes setValue:((OPTLYExperiment *)key).experimentKey
                                forKey:((OPTLYVariation *) obj).variationKey];
                }];


              // Tag custom event with attributes
              NSString *eventIdentifier
                  = [NSString stringWithFormat:@"[Optimizely] %@",
                      note.userInfo[OptimizelyNotificationsUserDictionaryEventNameKey]];
              [Localytics tagEvent:eventIdentifier attributes:attributes];
          }];

// Track a conversion event for the provided user
[optimizely track:eventKey userId:userId];

import Localytics

let defaultNotificationCenter = NotificationCenter.default
defaultNotificationCenter.addObserver(
    forName: NSNotification.Name("OptimizelyEventTracked"),
     object: nil,
      queue: nil) { (note) in

  let userInfo : Dictionary<String, AnyObject>?
      = note.userInfo as! Dictionary<String, AnyObject>?
  let userAttributes : Dictionary<String, AnyObject>?
      = userInfo?["attributes"] as! Dictionary<String, AnyObject>?
  let attributes : NSMutableDictionary = [:]
  attributes.addEntries(from: userAttributes!)

  // Set event attributes
  if let userExperimentVariationMapping
      = userInfo?["ExperimentVariationMapping"] as! Dictionary<String, AnyObject>? {
        for (key,value) in userExperimentVariationMapping {
          let variation : OPTLYVariation = value as! OPTLYVariation
          attributes.setValue(key, forKey:variation.variationKey)
      }
  }

  // Tag custom event with attributes
  let event : String = userInfo!["eventKey"] as! String
  let localyticsEventIdentifier : String = "[Optimizely] " + event
  Localytics.tagEvent(localyticsEventIdentifier)
}

import com.localytics.android.Localytics;
import com.optimizely.ab.bucketing.UserProfile;
import com.optimizely.ab.notification.NotificationListener;
import java.util.Map;

NotificationListener listener = new NotificationListener() {
  @Override
  public void onEventTracked(String eventKey,
                             String userId,
                             Map<String, String> attributes,
                             Long eventValue,
                             LogEvent logEvent) {
    // Make a copy of attributes because it could be immutable
    attributes = new HashMap<>(attributes);

    // Retrieve mapping of experiments to variations
    UserProfile userProfile = optimizelyManager.getUserProfile();
    Map<String, Map<String, String>> allRecords =
        userProfile.getAllRecords();

    // Set event attributes
    if (allRecords.containsKey(userId)) {
        Map<String, String> userRecords = allRecords.get(userId);
        for (Map.Entry<String, String> entry : userRecords.entrySet()) {
            // Mapping of experiment key to variation key
            attributes.put(entry.getKey(), entry.getValue());
        }
    }

    // Tag custom event with attributes
    Localytics.tagEvent("[Optimizely] " + eventKey, attributes);
  }
};

// Add listener
OptimizelyClient optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

// Track a conversion event for the provided user
optimizelyClient.track(eventKey, userId);

#import "Mixpanel/Mixpanel.h"

[[NSNotificationCenter defaultCenter]
  addObserverForName:OptimizelyDidActivateExperimentNotification
              object:nil
               queue:nil
          usingBlock:^(NSNotification * _Nonnull note) {
              // Mixpanel instance
              Mixpanel *mixpanel = [Mixpanel sharedInstance];

              // "Super property" will be sent with all future track calls
              OPTLYExperiment *experiment
                  = note.userInfo[OptimizelyNotificationsUserDictionaryExperimentKey];
              OPTLYVariation *variation
                  = note.userInfo[OptimizelyNotificationsUserDictionaryVariationKey];
              NSString *propertyKey
                  = [NSString stringWithFormat:@"[Optimizely] %@",
                      experiment.experimentKey];
              [mixpanel
                registerSuperProperties:@{propertyKey: variation.variationKey}];

              // Set "People property" for the user
              [mixpanel.people set:@{propertyKey: variation.variationKey}];

              // Track impression event (optional)
              NSString *eventIdentifier
                  = [NSString stringWithFormat:@"[Optimizely] %@ - %@",
                      experiment.experimentKey,
                      variation.variationKey];
              [mixpanel track:eventIdentifier];
          }];

import Mixpanel

let defaultNotificationCenter = NotificationCenter.default
defaultNotificationCenter.addObserver(
    forName: NSNotification.Name("OptimizelyExperimentActivated"),
     object: nil,
      queue: nil) { (note) in

  let userInfo : Dictionary<String, AnyObject>?
      = note.userInfo as! Dictionary<String, AnyObject>?
  if let experiment = userInfo?["experiment"] as! OPTLYExperiment? {
    if let variation = userInfo?["variation"] as! OPTLYVariation? {
      // Mixpanel instance
      let mixpanel : MixpanelInstance = Mixpanel.mainInstance()

      // "Super property" will be sent with all future track calls
      let propertyKey : String! = "[Optimizely] " + experiment.experimentKey
      mixpanel.registerSuperProperties([propertyKey: variation.variationKey])

      // Set "People property" for the user
      mixpanel.people.set(property: propertyKey, to: variation.variationKey)

      // Track impression event (optional)
      let eventIdentifier : String = "[Optimizely] "
          + experiment.experimentKey + " - " + variation.variationKey
      mixpanel.track(event:eventIdentifier)
  }
}

import android.util.Log;
import com.mixpanel.android.mpmetrics.MixpanelAPI;
import com.optimizely.ab.config.Experiment;
import com.optimizely.ab.config.Variation;
import com.optimizely.ab.notification.NotificationListener;
import org.json.JSONException;
import org.json.JSONObject;

NotificationListener listener = new NotificationListener() {
  @Override
  public void onExperimentActivated(Experiment experiment,
                                    String userId,
                                    Map<String, String> attributes,
                                    Variation variation) {
    String experimentKey = experiment.getKey();
    String variationKey = variation.getKey();

    // Mixpanel instance
    String projectToken = YOUR_PROJECT_TOKEN;
    MixpanelAPI mixpanel = MixpanelAPI.getInstance(this, projectToken);

    try {
      // "Super property" will be sent with all future track calls
      JSONObject props = new JSONObject();
      props.put("[Optimizely] " + experimentKey, variationKey);
      mixpanel.registerSuperProperties(props);
    } catch (JSONException e) {
      Log.e("MYAPP", "Unable to add properties to JSONObject", e);
    }

    // Set "People property" for the user
    mixpanel.getPeople().set(
        "[Optimizely] " + experimentKey, variationKey);

    // Track impression event (optional)
    mixpanel.track(
        "[Optimizely] " + experimentKey + " - " + variationKey);
  }
};

// Add listener
OptimizelyClient optimizelyClient = optimizelyManager.getOptimizely();
optimizelyClient.addNotificationListener(listener);

<html>
  <head>
    <script type="text/javascript">
      var userId = 'user~1';

      // Load the Segment Lib

      // Initialize Segment
      analytics.load("YOUR_KEY_HERE");
      analytics.page();

      // Identify user + add user attributes/traits
      // These user traits are passed along to Optimizely as user attributes
      analytics.identify(userId, {
        age: 24,
        language: 'yes',
      });

      // Initialize Optimizely and make sure it is appended to the global variable that the Segment integration can use (window.optimizelyClientInstance)
      var datafile = {}; // YOUR DATAFILE HERE
      var optimizelyClientInstance = window.optimizelyClient.createInstance({ datafile: datafile });


      // Metadata associated with the event
      // These are passed along to Optimizely as eventTags
      var eventProperties = { 'category': 'shoes', 'purchasePrice': 42 };
      analytics.track("page_loaded", eventProperties);

      // If you wish to override the userId and user attributes set during the `.identify` call or you don't want to use the `.identify` call you can pass the userId and userAttributes as options to the track call.

      var options = { 'Optimizely': { 'userId': userId, 'attributes': userAttributes } }
      analytics.track("page_loaded", eventProperties, options);
    </script>
  </head>
</html>