Elixir SDK

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

:ok = Client.add_data(client, visitor_code, CustomData.new!(42, ["new_visitor_code"]))

# In this example, 91 represents the Custom Data's index configured as a unique identifier in Kameleoon.
alias Kameleoon.Client
alias Kameleoon.Data.CustomData
alias Kameleoon.Data.UniqueIdentifier

mapping_index = 91
feature_key = "ff123"

anonymous_visitor_code = "anonymous-visitor"
user_id = "authenticated-user"

# 1. Before the visitor is authenticated

# Retrieve the variation for an unauthenticated visitor.
# Assume anonymousVisitorCode is the randomly generated ID for that visitor.
{:ok, anonymous_variation} = Client.get_variation(client, anonymous_visitor_code, feature_key)

# 2. After the visitor is authenticated

# Assume `userId` is the visitor code of the authenticated visitor.
:ok = Client.add_data(client, anonymous_visitor_code, CustomData.new!(mapping_index, [user_id]))
:ok = Client.flush_instant(client, anonymous_visitor_code)

# Indicate that `userId` is a unique identifier.
:ok = Client.add_data(client, user_id, UniqueIdentifier.new!(true))

# 3. After the visitor was authorized

# Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
{:ok, user_variation} = Client.get_variation(client, user_id, feature_key)
is_same_variation = user_variation.key == anonymous_variation.key # true

# `userId` and `anonymousVisitorCode` are now linked and can be tracked as a single visitor.
:ok = Client.track_conversion(client, user_id, 123)

# Additionally, the linked visitors share all fetched previously tracked remote data.
:ok = Client.get_remote_visitor_data(client, user_id)

alias Kameleoon.Logger

# The `:none` log level does not allow logging.
:ok = Logger.set_log_level(:none)

# The `:error` log level only allows logging issues that may affect the SDK's primary behaviour.
:ok = Logger.set_log_level(:error)

# The `:warning` log level allows logging issues which may require attention.
# It extends the `:error` log level.
# The `:warning` log level is the default log level.
:ok = Logger.set_log_level(:warning)

# The `:info` log level allows logging general information on the SDK's internal processes.
# It extends the `:warning` log level.
:ok = Logger.set_log_level(:info)

# The `:debug` level logs additional details about the SDK's internal processes.
:ok = Logger.set_log_level(:debug)

defmodule MyKameleoonLogger do
  @behaviour Kameleoon.Logger
  require Logger

  @impl true
  def log(level, message) do
    Logger.log(level, message)
  end
end

# Log level filtering is applied separately from log handling logic.
# The custom logger will only accept logs that meet or exceed the specified log level.
:ok = Kameleoon.Logger.set_log_level(:debug)
:ok = Kameleoon.Logger.set_logger(MyKameleoonLogger)

alias Kameleoon.Client

# Initializes the client using the configured default timeout
:ok = Client.initialize(client)

# Initializes the client with a custom timeout of 5 seconds
:ok = Client.initialize(client, timeout: 5_000)

{:ok, ready?} = Kameleoon.Client.is_ready?(client)

if ready? do
  # The client is ready
end

alias Kameleoon.ClientFactory

# Removes the cached client for the given site code
:ok = ClientFactory.forget("a8st4f59bj")

# Removes the cached client for the given site code and environment
:ok = ClientFactory.forget("a8st4f59bj", environment: "production")

alias Kameleoon.Client

feature_key = "new_checkout"

# Evaluates the feature flag and sends tracking data (default behavior)
{:ok, active?} = Client.is_feature_active?(client, visitor_code, feature_key)

# Evaluates the feature flag without sending tracking data
{:ok, active_without_tracking?} =
  Client.is_feature_active?(client, visitor_code, feature_key, track: false)

alias Kameleoon.Client

feature_key = "new_checkout"

# Retrieves the variation assigned to the visitor (with tracking enabled by default)
{:ok, variation} = Client.get_variation(client, visitor_code, feature_key)

# Retrieves the variation without sending tracking data
{:ok, variation_without_tracking} =
  Client.get_variation(client, visitor_code, feature_key, track: false)

alias Kameleoon.Client

# Retrieves all variations assigned to the visitor (with default options)
{:ok, variations} = Client.get_variations(client, visitor_code)

# Retrieves only active variations for the visitor
{:ok, only_active_variations} = Client.get_variations(client, visitor_code, only_active: true)

# Retrieves variations without sending tracking data
{:ok, variations_without_tracking} = Client.get_variations(client, visitor_code, track: false)

alias Kameleoon.Client

experiment_id = 202_387

# Forces the visitor into "variation_2" for the given experiment
:ok = Client.set_forced_variation(client, visitor_code, experiment_id, "variation_2")

# Removes any previously forced variation for the visitor in this experiment
:ok = Client.set_forced_variation(client, visitor_code, experiment_id, nil)

# Forces the visitor into "variation_2" with custom options.
# In this case, targeting rules are respected (force_targeting = false).
:ok =
  Client.set_forced_variation(
    client,
    visitor_code,
    experiment_id,
    "variation_2",
    force_targeting: false
  )

:ok = Kameleoon.Client.evaluate_audiences(client, visitor_code)

{:ok, datafile} = Kameleoon.Client.get_datafile(client)

alias Kameleoon.Client
alias Kameleoon.Data.Browser
alias Kameleoon.Data.PageView
alias Kameleoon.Data.UserAgent

:ok = Client.add_data(client, visitor_code, Browser.new!(:chrome, version: 123.0))

:ok =
  Client.add_data(client, visitor_code, [
    PageView.new!("https://example.com/pricing", title: "Pricing", referrers: [3]),
    UserAgent.new!("Mozilla/5.0")
  ])

:ok =
  Client.add_data(
    client,
    visitor_code,
    PageView.new!("https://example.com/checkout", title: "Checkout"),
    track: false
  )

# Queues a flush operation for the given visitor_code.
# Data will be sent according to the configured tracking interval.
:ok = Kameleoon.Client.flush(client, visitor_code)

# Immediately sends all pending tracking data for the given visitor_code.
:ok = Kameleoon.Client.flush_instant(client, visitor_code)

{:ok, data} = Kameleoon.Client.get_remote_data(client, "test-key")

alias Kameleoon.Client
alias Kameleoon.Types.RemoteVisitorDataFilter

# Fetch remote visitor data without any filter.
# This will return all available data for the given visitor.
:ok = Client.get_remote_visitor_data(client, visitor_code)

# Create a filter to limit the returned data.
filter = %RemoteVisitorDataFilter{
  previous_visit_amount: 5,
  conversions: true,
  page_views: true
}

# Fetch remote visitor data using the specified filter.
# This will return only the data matching the filter criteria.
:ok = Client.get_remote_visitor_data(client, visitor_code, filter: filter)

alias Kameleoon.Client

# Fetch audience data for a visitor using only the visitor_code.
:ok = Client.get_visitor_warehouse_audience(client, visitor_code, 98)

# Fetch audience data for a visitor using both visitor_code and warehouse_key.
# Useful when your warehouse uses a different identifier than visitor_code.
:ok = Client.get_visitor_warehouse_audience(client, visitor_code, 98, warehouse_key: "internal-user-id")

cookies = {PlugConnCookies, conn}

# Set consent and update cookies.
{:ok, conn} = Kameleoon.Client.set_legal_consent(client, visitor_code, true, cookies)

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

# Track a goal.
:ok = Client.track_conversion(client, visitor_code, goal_id)

# Track a goal with revenue.
:ok = Client.track_conversion(client, visitor_code, goal_id, revenue: 100.0)

# Track a goal with negative revenue.
:ok = Client.track_conversion(client, visitor_code, goal_id, revenue: 100.0, negative: true)

# Track a goal with custom metadata.
:ok =
  Client.track_conversion(
    client,
    visitor_code,
    goal_id,
    metadata: [CustomData.new!(4, ["true"])]
  )

{:ok, tracking_code} = Kameleoon.Client.get_engine_tracking_code(client, visitor_code)

:ok =
  Kameleoon.Client.on_datafile_update(client, fn ->
    IO.puts("Kameleoon datafile updated")
  end)

:ok = Kameleoon.Client.on_datafile_update(client, nil)

alias Kameleoon.Client
alias Kameleoon.Data.ApplicationVersion

# major
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10"))
# major.minor
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10.20"))
# major.minor.patch
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10.20.30"))

alias Kameleoon.Client
alias Kameleoon.Data.Browser

# Browser data with a version
:ok = Client.add_data(client, visitor_code, Browser.new!(:safari, version: 26.4))
# Browser data without a version
:ok = Client.add_data(client, visitor_code, Browser.new!(:chrome))

alias Kameleoon.Client
alias Kameleoon.Data.Conversion
alias Kameleoon.Data.CustomData

# Add a simple conversion with ID 32
:ok = Client.add_data(client, visitor_code, Conversion.new!(32))

# Add conversion with ID 33 including revenue and marked as negative
:ok = Client.add_data(client, visitor_code, Conversion.new!(33, revenue: 10.0, negative: true))

# Add conversion with ID 34 including revenue, negative flag, and custom metadata
:ok =
  Client.add_data(
    client,
    visitor_code,
    Conversion.new!(34,
      revenue: 10.0,
      negative: true,
      metadata: [
        CustomData.new!(3, ["metadata1", "md2"]),
        CustomData.new!(5, ["md3"])
      ]
    )
  )

alias Kameleoon.Client
alias Kameleoon.Data.Cookie

:ok = Client.add_data(client, visitor_code, Cookie.new!(%{"segment" => "vip"}))

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value"]))

# With several values
:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value1", "value2"]))

# To set the `overwrite` flag to false
:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value"], overwrite: false))

# To use a name instead of the index
:ok = Client.add_data(client, visitor_code, CustomData.new_with_name!("my-custom-data", ["value"]))

# To use a name instead of the index and set the `overwrite` flag to false
:ok =
  Client.add_data(
    client,
    visitor_code,
    CustomData.new_with_name!("my-custom-data", ["value"], overwrite: false)
  )

alias Kameleoon.Client
alias Kameleoon.Data.Device

:ok = Client.add_data(client, visitor_code, Device.new!(:desktop))

alias Kameleoon.Client
alias Kameleoon.Data.Geolocation

geolocation =
  Geolocation.new!("France",
    region: "Ile-de-France",
    city: "Paris",
    postal_code: "75009",
    latitude: 48.8720171,
    longitude: 2.3338352
  )

:ok = Client.add_data(client, visitor_code, geolocation)

alias Kameleoon.Client
alias Kameleoon.Data.OperatingSystem

:ok = Client.add_data(client, visitor_code, OperatingSystem.new!(:windows))

alias Kameleoon.Client
alias Kameleoon.Data.PageView

# Full constructor with url, optional title, and referrers.
:ok = Client.add_data(client, visitor_code, PageView.new!("https://example.com", title: "Homepage", referrers: [3]))

# Minimal constructor, only requires a URL.
:ok = Client.add_data(client, visitor_code, PageView.new!("https://example.com"))

alias Kameleoon.Client
alias Kameleoon.Data.UniqueIdentifier

:ok = Client.add_data(client, visitor_code, UniqueIdentifier.new!(true))

alias Kameleoon.Client
alias Kameleoon.Data.UserAgent

:ok = Client.add_data(client, visitor_code, UserAgent.new!("Mozilla/5.0"))

# Retrieves the map of feature flags from the DataFile.
# The map is keyed by feature flag identifiers, with each value being a FeatureFlag struct.
feature_flags = datafile.feature_flags

# Retrieves the last modification timestamp of the DataFile.
# The value is an integer representing milliseconds since the Unix epoch.
date_modified = datafile.date_modified

# Check whether the feature flag is enabled in the current environment.
environment_enabled = feature_flag.environment_enabled

# Retrieve the key of the default variation.
default_variation_key = feature_flag.default_variation_key

# Retrieve the default variation struct.
default_variation = Kameleoon.Types.FeatureFlag.default_variation(feature_flag)

# Retrieve all variations of the feature flag as a map (key = variation key, value = Variation struct).
variations = feature_flag.variations

# Retrieve all targeting rules associated with the feature flag.
rules = feature_flag.rules

# Retrieve all variations of the rule as a map (key = variation key, value = Variation struct).
variations = rule.variations

# Retrieving the variation name.
variation_name = variation.name

# Retrieving the variation key.
variation_key = variation.key

# Retrieving the variation id.
variation_id = variation.id

# Retrieving the experiment id.
experiment_id = variation.experiment_id

# Retrieving the variables list.
variables = variation.variables

# Checking if the variation is active (i.e., currently being served to visitors).
active? = Kameleoon.Types.Variation.active?(variation)

# Retrieving a variable by its key, returning nil if not found.
variable = Enum.find(variation.variables, &(&1.key == "title"))

# Retrieve the list of variables associated with the variation.
variables = variation.variables

# Access the variable type (kind) for conditional handling.
kind = variable.kind

# Extract the value as a number.
number = variable.value

# Extract the value as a boolean.
apply_discount? = variable.value

# Extract the value as a string.
title = variable.value