SDK Rust

use kameleoon_client::data::CustomData;

client.add_data(visitor_code, [CustomData::new(42, vec!["new_visitor_code".to_owned()])])?;

// In this example, 91 represents the Custom Data's index configured as a unique identifier in Kameleoon.
use kameleoon_client::data::{CustomData, UniqueIdentifier};

const MAPPING_INDEX: u32 = 91;
const FEATURE_KEY: &str = "ff123";

let anonymous_visitor_code = "anonymous-visitor";
let 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.
let anonymous_variation = client.get_variation(anonymous_visitor_code, FEATURE_KEY)?;

// 2. After the visitor is authenticated

// Assume `userId` is the visitor code of the authenticated visitor.
client.add_data(anonymous_visitor_code, [CustomData::new(MAPPING_INDEX, vec![user_id.to_owned()])])?;
client.flush_instant(anonymous_visitor_code).await?;

// Indicate that `userId` is a unique identifier.
client.add_data(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.
let user_variation = client.get_variation(user_id, FEATURE_KEY)?;
let is_same_variation = user_variation.key == anonymous_variation.key; // True

// `userId` and `anonymousVisitorCode` are now linked and can be tracked as a single visitor.
client.track_conversion(user_id, 123)?;

// Additionally, the linked visitors share all fetched previously tracked remote data.
client.get_remote_visitor_data(user_id, None).await?;

use kameleoon_client::logging::{KameleoonLogger, LogLevel};

// The `None` log level does not allow logging.
KameleoonLogger::set_log_level(LogLevel::None);

// The `Error` log level only allows logging issues that may affect the SDK's primary behaviour.
KameleoonLogger::set_log_level(LogLevel::Error);

// The `Warning` log level allows logging issues which may require an attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
KameleoonLogger::set_log_level(LogLevel::Warning);

// The `Info` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
KameleoonLogger::set_log_level(LogLevel::Info);

// The `Debug` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
KameleoonLogger::set_log_level(LogLevel::Debug);

use kameleoon_client::logging::{KameleoonLogger, LogLevel, Logger};
use log::{error, warn, info, debug};

pub struct CustomLogger;

impl Logger for CustomLogger {
    // `log` method accepts logs from the SDK
    fn log(&self, log_level: LogLevel, message: &str) {
        // Custom log handling logic here. For example:
        match log_level {
            LogLevel::Error   => error!("{}", message),
            LogLevel::Warning => warn!("{}", message),
            LogLevel::Info    => info!("{}", message),
            LogLevel::Debug   => debug!("{}", message),
        }
    }
}
// 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.
// Ensure the log level is set correctly.
KameleoonLogger::set_log_level(LogLevel::Debug); // Optional; defaults to `LogLevel.WARNING`.
KameleoonLogger::set_logger(Box::new(CustomLogger));

use std::time::Duration;

// Initializes the client using the configured default timeout
client.initialize().await?;

// Initializes the client with a custom timeout of 5 seconds
client.initialize_with_timeout(Duration::from_secs(5)).await?;

if client.is_ready() {
    // The client is ready
}

use kameleoon_client::factory::KameleoonClientFactory;

// Removes the cached client for the given site code
KameleoonClientFactory::forget("a8st4f59bj")?;

// Removes the cached client for the given site code and environment
KameleoonClientFactory::forget_with_environment("a8st4f59bj", "production")?;

use kameleoon_client::client::IsFeatureActiveOpts;

let feature_key = "new_checkout";

// Evaluates the feature flag and sends tracking data (default behavior)
let active = client.is_feature_active(visitor_code, feature_key)?;

// Evaluates the feature flag without sending tracking data
let active_without_tracking = client.is_feature_active_with_opts(
    visitor_code,
    feature_key,
    IsFeatureActiveOpts::new().track(false),
)?;

use kameleoon_client::client::GetVariationOpts;

let feature_key = "new_checkout";

// Retrieves the variation assigned to the visitor (with tracking enabled by default)
let variation = client.get_variation(visitor_code, feature_key)?;

// Retrieves the variation without sending tracking data
let variation_without_tracking = client.get_variation_with_opts(
    visitor_code,
    feature_key,
    GetVariationOpts::new().track(false),
)?;

use kameleoon_client::client::GetVariationsOpts;

// Retrieves all variations assigned to the visitor (with default options)
let variations = client.get_variations(visitor_code)?;

// Retrieves only active variations for the visitor
let only_active_variations = client.get_variations_with_opts(
    visitor_code,
    GetVariationsOpts::new().only_active(true),
)?;

// Retrieves variations without sending tracking data
let variations_without_tracking = client.get_variations_with_opts(
    visitor_code,
    GetVariationsOpts::new().track(false),
)?;

use kameleoon_client::client::SetForcedVariationOpts;

let experiment_id = 202387;

// Forces the visitor into "variation_2" for the given experiment
client.set_forced_variation(visitor_code, experiment_id, Some("variation_2"))?;

// Removes any previously forced variation for the visitor in this experiment
client.set_forced_variation(visitor_code, experiment_id, None)?;

// Forces the visitor into "variation_2" with custom options
// In this case, targeting rules are respected (force_targeting = false)
client.set_forced_variation_with_opts(
    visitor_code,
    experiment_id,
    Some("variation_2"),
    SetForcedVariationOpts::new().force_targeting(false),
)?;

client.evaluate_audiences(visitor_code)?;

let datafile = client.get_datafile()?;

use kameleoon_client::data::{Browser, BrowserKind, PageView, UserAgent};

client.add_data(visitor_code, [Browser::new(BrowserKind::Chrome, Some(123.0))])?;

client.add_data(
    visitor_code,
    [
        PageView::new("https://example.com/pricing".to_owned(), Some("Pricing".to_owned()), vec![3]).into(),
        UserAgent::new("Mozilla/5.0".to_owned()).into(),
    ],
)?;

client.add_data_with_track(
    visitor_code,
    vec![PageView::new("https://example.com/checkout".to_owned(), Some("Checkout".to_owned()), vec![])],
    false,
)?;

// Queues a flush operation for the given visitor_code.
// Data will be sent according to the configured tracking interval (non-blocking).
client.flush(visitor_code)?;

// Immediately sends all pending tracking data for the given visitor_code.
// This is an async operation and must be awaited.
client.flush_instant(visitor_code).await?;

let data = client.get_remote_data("test-key").await?;

use kameleoon_client::types::RemoteVisitorDataFilter;

// Fetch remote visitor data without any filter
// This will return all available data for the given visitor
client.get_remote_visitor_data(visitor_code, None).await?;

// Create a filter to limit the returned data
let filter = RemoteVisitorDataFilter {
    // Include data from the last 5 visits
    previous_visit_amount: 5,
    // Include conversion events (e.g., goals, transactions)
    conversions: true,
    // Include page view history
    page_views: true,
    // Use default values for all other fields
    ..Default::default()
};

// Fetch remote visitor data using the specified filter
// This will return only the data matching the filter criteria
client.get_remote_visitor_data(visitor_code, Some(filter)).await?;

// Fetch audience data for a visitor using only the visitor_code.
client.get_visitor_warehouse_audience(visitor_code, None, 98).await?;

// Fetch audience data for a visitor using both visitor_code and warehouse_key.
// Useful when your warehouse uses a different identifier than visitor_code.
client.get_visitor_warehouse_audience(visitor_code, Some("internal-user-id"), 98).await?;

// Set consent and update cookies
client.set_legal_consent(visitor_code, true, Some(&mut cookies))?;

// Set consent without updating cookies
client.set_legal_consent(visitor_code, true, None)?;

use kameleoon_client::client::TrackConversionOpts;
use kameleoon_client::data::CustomData;

// Track a goal
client.track_conversion(visitor_code, goal_id)?;

// Track a goal with revenue
client.track_conversion_with_opts(visitor_code, goal_id, TrackConversionOpts::new().revenue(100.0))?;

// Track a goal with negative revenue
client.track_conversion_with_opts(
    visitor_code,
    goal_id,
    TrackConversionOpts::new().revenue(100.0).negative(true)
)?;

// Track a goal with custom metadata
client.track_conversion_with_opts(
    visitor_code,
    goal_id,
    TrackConversionOpts::new().metadata(vec![CustomData::new(4, vec!["true".to_owned()])]),
)?;

let tracking_code = client.get_engine_tracking_code(visitor_code)?;

// Register a callback that is invoked whenever the configuration
// is updated through a polling or streaming datafile update event.
client.on_datafile_update(Some(Box::new(|| {
    // Custom logic to execute after the datafile has been updated.
    println!("Kameleoon datafile updated");
})));

// Unregister the datafile update callback.
// No callback will be invoked for future datafile updates.
client.on_datafile_update(None);

use kameleoon_client::data::ApplicationVersion;

// major
client.add_data(visitor_code, [ApplicationVersion::new("10")])?;
// major.minor
client.add_data(visitor_code, [ApplicationVersion::new("10.20")])?;
// major.minor.patch
client.add_data(visitor_code, [ApplicationVersion::new("10.20.30")])?;

use kameleoon_client::data::{Browser, BrowserKind};

// Browser data with a version
client.add_data(visitor_code, [Browser::new(BrowserKind::Safari, 26.4)])?;
// Browser data without a version
client.add_data(visitor_code, [Browser::new(BrowserKind::Chrome, None)])?;

use kameleoon_client::data::{Conversion, ConversionOpts, CustomData};

// Add a simple conversion with ID 32
client.add_data(visitor_code, [Conversion::new(32)])?;

// Add conversion with ID 33 including revenue and marked as negative
client.add_data(visitor_code, [Conversion::new_with_opts(33, ConversionOpts::new().revenue(10.0).negative(true))])?;

// Add conversion with ID 34 including revenue, negative flag, and custom metadata
client.add_data(
    visitor_code,
    [
        Conversion::new_with_opts(
            34,
            ConversionOpts::new().revenue(10.0).negative(true).metadata(vec![
                CustomData::new(3, vec!["metadata1".to_owned(), "md2".to_owned()]),
                CustomData::new(5, vec!["md3".to_owned()]),
            ]),
        )
    ],
)?;

use std::collections::HashMap;
use kameleoon_client::data::Cookie;

client.add_data(visitor_code, [Cookie::new(HashMap::from([("segment".to_owned(), "vip".to_owned())]))])?;

use kameleoon_client::data::{CustomData, CustomDataOpts};

client.add_data(visitor_code, [CustomData::new_with_index(1, vec!["value".to_owned()])])?;

// With several values
client.add_data(
    visitor_code,
    [CustomData::new_with_index(
        1,
        vec!["value1".to_owned(), "value2".to_owned()],
    )],
)?;

// To set the `overwrite` flag to false
client.add_data(
    visitor_code,
    [CustomData::new_with_index_opts(
        1,
        vec!["value".to_owned()],
        CustomDataOpts::new().overwrite(false),
    )],
)?;

// To use a name instead of the index
client.add_data(
    visitor_code,
    [CustomData::new_with_name(
        "my-custom-data".to_owned(),
        vec!["value".to_owned()],
    )],
)?;

// To use a name instead of the index and set the `overwrite` flag to false
client.add_data(
    visitor_code,
    [CustomData::new_with_name_opts(
        "my-custom-data",
        vec!["value".to_owned()],
        CustomDataOpts::new().overwrite(false),
    )],
)?;

use kameleoon_client::data::{Device, DeviceKind};

client.add_data(visitor_code, [Device::new(DeviceKind::Desktop)])?;

use kameleoon_client::data::GeolocationBuilder;

let geolocation = GeolocationBuilder::default()
    .country("France")
    .region("Ile-de-France".to_owned())
    .city("Paris".to_owned())
    .postal_code("75009".to_owned())
    .latitude(48.8720171)
    .longitude(2.3338352)
    .build()
    .unwrap();

client.add_data(visitor_code, [geolocation])?;

use kameleoon_client::data::{OperatingSystem, OperatingSystemKind};

client.add_data(visitor_code, [OperatingSystem::new(OperatingSystemKind::Windows)])?;

use kameleoon_client::data::{PageView, PageViewOpts};

// new() - full constructor with url, optional title, and referrers
client.add_data(visitor_code, [PageView::new("https://example.com", Some("Homepage"), vec![3])])?;

// new_with_url() - minimal constructor, only requires a URL
client.add_data(visitor_code, [PageView::new_with_url("https://example.com")])?;

// new_with_opts() - constructor using PageViewOpts builder for optional fields
let opts = PageViewOpts::builder().title("Homepage").referrers(vec![3]).build();
client.add_data(visitor_code, [PageView::new_with_opts("https://example.com", opts)])?;

use kameleoon_client::data::UniqueIdentifier;

client.add_data(visitor_code, [UniqueIdentifier::new(true)])?;

use kameleoon_client::data::UserAgent;

client.add_data(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 object.
let feature_flags: &HashMap<String, FeatureFlag> = &datafile.feature_flags;

// Retrieves the last modification timestamp of the DataFile.
// The value is an i64 representing milliseconds since the Unix epoch.
let date_modified: i64 = datafile.date_modified;

// Check whether the feature flag is enabled in the current environment.
let environment_enabled: bool = feature_flag.environment_enabled;

// Retrieve the key of the default variation.
let default_variation_key: &String = &feature_flag.default_variation_key;

// Retrieve the default variation object.
let default_variation: &Variation = feature_flag.default_variation();

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object).
let variations: &HashMap<String, Variation> = &feature_flag.variations;

// Retrieve all targeting rules associated with the feature flag.
let rules: &Vec<Rule> = &feature_flag.rules;

// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
let variations = &rule.variations;

// Retrieving the variation name
let variation_name = &variation.name;

// Retrieving the variation key
let variation_key = &variation.key;

// Retrieving the variation id
let variation_id = variation.id;

// Retrieving the experiment id
let experiment_id = variation.experiment_id;

// Retrieving the variables `Vec`
let variables = &variation.variables;

// Checking if the variation is active (i.e., currently being served to visitors)
let is_active = variation.is_active();

// Retrieving a variable by its key, returning `None` if not found
let variable = variation.get_variable("title")?;