Statsig Server Core

https://github.com/statsig-io/statsig-server-core
Admin
Statsig Server Core is a multi-language server-side SDK suite that helps developers move faster with...
Tokens:31,019
Snippets:388
Trust Score:10
License:ISC
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get Experiment with Options Usage

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Example demonstrating how to configure and pass ExperimentEvaluationOptions when fetching an experiment.

```rust
use statsig_rust::{ExperimentEvaluationOptions, UserPersistedValues};

let user = StatsigUser::with_user_id("user-123");
let opts = ExperimentEvaluationOptions {
    disable_exposure_logging: false,
    user_persisted_values: Some(UserPersistedValues {
        // ...
    }),
    enforce_overrides: true,
    enforce_targeting: true,
};
let exp = statsig.get_experiment_with_options(&user, "exp_name", Some(opts));
```

--------------------------------

### Get Layer Usage

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Example showing how to retrieve a layer and access its parameters.

```rust
let layer = statsig.get_layer(&user, "feature_layer_one");
if let Some(enabled) = layer.get_opt::<bool>("feature_enabled") {
    // Use layer parameters
}
```

--------------------------------

### Get Layer with Options Usage

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Example demonstrating how to configure LayerEvaluationOptions for layer retrieval.

```rust
let opts = LayerEvaluationOptions {
    disable_exposure_logging: false,
    user_persisted_values: None,
    enforce_overrides: true,
    enforce_targeting: false,
};
let layer = statsig.get_layer_with_options(&user, "layer_name", Some(opts));
```

--------------------------------

### get_client_init_response_with_options

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Gets client response with custom options.

```APIDOC
## get_client_init_response_with_options

### Description
Gets client response with custom options (format control, app IDs, etc.).

### Signature
`pub fn get_client_init_response_with_options(&self, user: &StatsigUser, options: Option<ClientInitResponseOptions>) -> InitializeResponse`
```

--------------------------------

### Access InitializeDetails

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example usage for retrieving and logging initialization details.

```rust
let details = statsig.initialize_with_details().await?;
println!("Success: {}", details.init_success);
println!("Duration: {} ms", details.duration_ms);
println!("Source: {:?}", details.source);
if let Some(failure) = details.failure_details {
    println!("Error: {}", failure.reason);
}
```

--------------------------------

### Get Client Init Response

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Returns a JSON-serializable response containing user evaluations for client SDK initialization.

```rust
pub fn get_client_init_response(&self, user: &StatsigUser) -> InitializeResponse
```

```rust
let response = statsig.get_client_init_response(&user);
let json = serde_json::to_string(&response)?;
// Send json to client SDK
```

--------------------------------

### Get Client Init Response with Options

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves client initialization response with custom options like format control or app IDs.

```rust
pub fn get_client_init_response_with_options(
    &self,
    user: &StatsigUser,
    options: Option<ClientInitResponseOptions>
) -> InitializeResponse
```

--------------------------------

### Access Experiment details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example of accessing experiment group information and parameters.

```rust
let exp = statsig.get_experiment(&user, "new_checkout");
if let Some(group) = &exp.group_name {
    println!("User in group: {}", group);
}
if let Some(flow) = exp.get_opt::<String>("checkout_flow") {
    println!("Flow variant: {}", flow);
}
```

--------------------------------

### Get Entity Lists

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Returns names of all loaded dynamic configs, experiments, and layers.

```rust
pub fn get_dynamic_config_list(&self) -> Vec<String>
pub fn get_experiment_list(&self) -> Vec<String>
pub fn get_layer_list(&self) -> Vec<String>
```

```rust
let configs = statsig.get_dynamic_config_list();
println!("Available configs: {:?}", configs);
```

--------------------------------

### Use Layer Parameters

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example of retrieving a parameter from a layer and manually logging exposure.

```rust
let layer = statsig.get_layer(&user, "feature_layer_one");
if let Some(enabled) = layer.get_opt::<bool>("feature_enabled") {
    if enabled {
        // Manually log when parameter is actually used
        layer.log_parameter_exposure("feature_enabled");
    }
}
```

--------------------------------

### Access DynamicConfig parameters

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example of retrieving typed and raw values from a DynamicConfig.

```rust
let config = statsig.get_dynamic_config(&user, "pricing_config");

// Typed access
if let Some(tier) = config.get_opt::<String>("tier") {
    println!("Tier: {}", tier);
}

// Raw value access
if let Some(Value::Number(price)) = config.value.get("base_price") {
    println!("Price: {}", price);
}
```

--------------------------------

### Initialize Statsig with Custom Options

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Configure initialization timeouts and logging levels using StatsigOptions before starting the SDK.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, StatsigUser};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Configure
    let options = Arc::new(
        StatsigOptions::builder()
            .init_timeout_ms(Some(5000))
            .output_log_level(Some(LogLevel::Debug))
            .build()
    );
    
    let statsig = Statsig::new("secret-api-key", Some(options));
    let details = statsig.initialize_with_details().await?;
    
    println!("Init success: {}", details.init_success);
    println!("Duration: {} ms", details.duration_ms);
    
    // Use SDK...
    
    statsig.shutdown().await?;
    Ok(())
}
```

--------------------------------

### Get Typed Parameters Methods

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieve typed parameters from a store.

```rust
pub fn get_string_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<String>

pub fn get_boolean_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<bool>

pub fn get_float_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<f64>

pub fn get_integer_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<i64>

pub fn get_array_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<Vec<Value>>

pub fn get_object_parameter_from_store(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<HashMap<String, Value>>
```

--------------------------------

### Get Experiment

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves the experiment assignment and value for a user.

```rust
pub fn get_experiment(
    &self,
    user: &StatsigUser,
    experiment_name: &str
) -> Experiment
```

```rust
let experiment = statsig.get_experiment(&user, "new_checkout_flow");
println!("Group: {:?}", experiment.group_name);
println!("Value: {:?}", experiment.value);
```

--------------------------------

### Get Store Parameters

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Retrieves parameters from a store, supporting both default and user-specific configurations.

```rust
// Default parameters (no user)
let store = statsig.get_parameter_store("app_defaults");
if let Some(max_batch_size) = store.get_opt::<u32>("max_batch_size") {
    set_batch_size(max_batch_size);
}

// User-specific parameters
let store = statsig.get_parameter_store_for_user(&user, "user_settings");
if let Some(theme) = store.get_opt::<String>("theme") {
    apply_theme(&theme);
}
```

--------------------------------

### Get Dynamic Config with Options

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves a dynamic configuration with custom evaluation options.

```rust
pub fn get_dynamic_config_with_options(
    &self,
    user: &StatsigUser,
    config_name: &str,
    options: Option<DynamicConfigEvaluationOptions>,
) -> DynamicConfig
```

```rust
let opts = DynamicConfigEvaluationOptions {
    disable_exposure_logging: false,
};
let config = statsig.get_dynamic_config_with_options(&user, "pricing_config", Some(opts));
```

--------------------------------

### Get Parameter Store for User Method

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Evaluates a parameter store for a specific user.

```rust
pub fn get_parameter_store_for_user(
    &self,
    user: &StatsigUser,
    parameter_store_name: &str
) -> ParameterStore<'_>
```

--------------------------------

### Build StatsigUser with Builder

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example usage of the StatsigUserBuilder to construct a user with various attributes.

```rust
use statsig_rust::StatsigUserBuilder;

let user = StatsigUserBuilder::new()
    .user_id("user-123")
    .email("user@example.com")
    .custom_id("org_id", "org-456")
    .custom_field("tier", "premium")
    .private_attribute("ssn", "***-**-1234")
    .build();
```

--------------------------------

### Initialize and modify StatsigUser

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Examples of creating users by ID or custom IDs and modifying their attributes.

```rust
use statsig_rust::StatsigUser;
use std::collections::HashMap;

// By user ID
let user = StatsigUser::with_user_id("user-123");

// By custom IDs
let mut custom_ids = HashMap::new();
custom_ids.insert("org_id", "org-456");
let user = StatsigUser::with_custom_ids(custom_ids);

// Modify user
let mut user = StatsigUser::with_user_id("user-123");
user.set_email("user@example.com");
user.set_country("US");
let mut custom_fields = HashMap::new();
custom_fields.insert("subscription_tier", "premium");
user.set_custom_fields(custom_fields);
```

--------------------------------

### Access Experiment Groups

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example of retrieving experiment groups and checking the active status.

```rust
let result = statsig.get_experiment_groups("exp_name");
if let Some(active) = result.is_experiment_active {
    println!("Experiment active: {}", active);
}
for group in result.groups {
    println!("Group: {}", group.group_name);
}
```

--------------------------------

### Implement Redis Sticky Values

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Example of loading sticky values from Redis and passing them into the experiment evaluation options.

```rust
use statsig_rust::UserPersistedValues;

async fn get_experiment_with_sticky(
    statsig: &Statsig,
    user: &StatsigUser,
    exp_name: &str,
    redis: &RedisClient,
) -> Experiment {
    let user_id = user.get_user_id().unwrap_or("unknown");
    let key = format!("statsig:sticky:{}", user_id);
    
    // Load sticky values from Redis
    let sticky_json = redis.get(&key).await.ok().flatten();
    let sticky_values = sticky_json
        .and_then(|j| serde_json::from_str::<UserPersistedValues>(&j).ok());
    
    let opts = ExperimentEvaluationOptions {
        user_persisted_values: sticky_values,
        enforce_overrides: true,
        enforce_targeting: true,
        disable_exposure_logging: false,
    };
    
    statsig.get_experiment_with_options(user, exp_name, Some(opts))
}
```

--------------------------------

### Get Parameter Store Method

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Returns a parameter store without user-specific evaluation.

```rust
pub fn get_parameter_store(
    &self,
    parameter_store_name: &str
) -> ParameterStore<'_>
```

--------------------------------

### Get Layer Method Definition

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Method signature for retrieving a layer for a specific user.

```rust
pub fn get_layer(
    &self,
    user: &StatsigUser,
    layer_name: &str
) -> Layer
```

--------------------------------

### Install Statsig Elixir dependency

Source: https://github.com/statsig-io/statsig-server-core/blob/main/statsig-elixir/README.md

Add the statsig_elixir package to your mix.exs file to include the SDK in your project.

```elixir
def deps do
  [
    {:statsig_elixir, "~> 0.0.6-beta.7"}
  ]
end
```

--------------------------------

### Get Experiment with Options Method Definition

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Method signature for retrieving an experiment with specific evaluation options.

```rust
pub fn get_experiment_with_options(
    &self,
    user: &StatsigUser,
    experiment_name: &str,
    options: Option<ExperimentEvaluationOptions>,
) -> Experiment
```

--------------------------------

### Access Evaluation Details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example of accessing evaluation metadata from a gate check result.

```rust
let gate = statsig.check_gate_with_options(&user, "my_gate", None);
println!("Reason: {}", gate.details.reason);
println!("LCUT: {:?}", gate.details.lcut);
```

--------------------------------

### Get Layer with Options Method Definition

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Method signature for retrieving a layer with custom evaluation options.

```rust
pub fn get_layer_with_options(
    &self,
    user: &StatsigUser,
    layer_name: &str,
    options: Option<LayerEvaluationOptions>,
) -> Layer
```

--------------------------------

### Initialize SDK with Details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Initialize the SDK and retrieve detailed metadata about the process.

```rust
match statsig.initialize_with_details().await {
    Ok(details) => {
        println!("Init success: {}", details.init_success);
        println!("Duration: {} ms", details.duration_ms);
        println!("Specs ready: {}", details.is_config_spec_ready);
        println!("Source: {:?}", details.source);
    }
    Err(e) => eprintln!("Failed: {}", e),
}
```

--------------------------------

### Statsig::initialize_with_details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Initializes the SDK and returns detailed information about the process.

```APIDOC
## Statsig::initialize_with_details

### Description
Initializes the SDK and returns an InitializeDetails object containing metadata about the initialization process.

### Returns
- **Result<InitializeDetails, StatsigErr>** - Returns detailed initialization information on success.
```

--------------------------------

### Initialize SDK

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Fetch initial specs and ID lists to prepare the SDK for use.

```rust
match statsig.initialize().await {
    Ok(()) => println!("Initialized successfully"),
    Err(e) => eprintln!("Initialization failed: {}", e),
}
```

--------------------------------

### Initialize Statsig SDK

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/09-quick-start.md

Initialize the SDK, create a user, and check a feature gate.

```rust
use statsig_rust::{Statsig, StatsigUser};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize
    let statsig = Statsig::new("your-secret-api-key", None);
    statsig.initialize().await?;
    
    // Create user
    let user = StatsigUser::with_user_id("user-123");
    
    // Evaluate feature
    if statsig.check_gate(&user, "new_dashboard") {
        println!("New dashboard enabled!");
    }
    
    // Cleanup
    statsig.shutdown().await?;
    Ok(())
}
```

--------------------------------

### Handle Initialization with Details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/09-quick-start.md

Use this pattern to inspect initialization success, duration, and specific failure reasons.

```rust
match statsig.initialize_with_details().await {
    Ok(details) => {
        if details.init_success {
            println!("Ready in {} ms", details.duration_ms);
        } else if let Some(failure) = details.failure_details {
            eprintln!("Failed: {}", failure.reason);
        }
    }
    Err(e) => eprintln!("Init error: {}", e),
}
```

--------------------------------

### Initialize Statsig with Minimal Configuration

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Basic initialization using only the SDK key.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let statsig = Statsig::new("your-sdk-key", None);
statsig.initialize().await?;
```

--------------------------------

### Get Generic Parameter Method

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieve a parameter as a custom serializable type.

```rust
pub fn get_parameter_from_store<T: DeserializeOwned>(
    &self,
    parameter_store_name: &str,
    parameter_name: &str
) -> Option<T>
```

```rust
#[derive(serde::Deserialize)]
struct Config {
    timeout_ms: u32,
    retry_count: u8,
}

let cfg: Option<Config> = statsig.get_parameter_from_store("app_config", "request_settings");
```

--------------------------------

### Get Dynamic Config

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves a dynamic configuration object for a specific user.

```rust
pub fn get_dynamic_config(
    &self,
    user: &StatsigUser,
    config_name: &str
) -> DynamicConfig
```

```rust
let config = statsig.get_dynamic_config(&user, "pricing_config");
if let Some(tier) = config.get_opt::<String>("tier") {
    println!("User tier: {}", tier);
}
```

--------------------------------

### Initialize StatsigGrpcSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Fetches configuration specifications from a gRPC server.

```rust
pub struct StatsigGrpcSpecsAdapter {
    url: String,
    sync_interval_secs: u32,
}

impl StatsigGrpcSpecsAdapter {
    pub fn new(url: String, sync_interval_secs: Option<u32>) -> Self
}
```

--------------------------------

### Statsig::get_initialize_details

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves the current initialization status.

```APIDOC
## Statsig::get_initialize_details

### Description
Retrieves the InitializeDetails from the last initialization attempt without blocking.

### Returns
- **InitializeDetails** - The current initialization status object.
```

--------------------------------

### statsig.get_client_init_response_with_options()

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Generates an initialization response with custom formatting options such as including evaluation reasons or secondary exposures.

```APIDOC
## statsig.get_client_init_response_with_options(user, options)

### Description
Generates an initialization response with specific configuration options for the returned data structure.

### Parameters
- **user** (StatsigUser) - Required - The user object for evaluation.
- **options** (ClientInitResponseOptions) - Optional - Configuration object to include additional fields like evaluation reasons or secondary exposures.
```

--------------------------------

### Initialize Statsig with Bootstrap Specs

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Initializes the SDK without a network call by providing a JSON string of specs.

```rust
let specs = include_str!("specs.json");
let adapter = StatsigBootstrapSpecsAdapter::new(specs)?;
let opts = StatsigOptions::builder()
    .specs_adapter(Some(Arc::new(adapter)))
    .build();
let statsig = Statsig::new("sdk-key", Some(Arc::new(opts)));
```

--------------------------------

### Configure GoogleTest and Test Executable

Source: https://github.com/statsig-io/statsig-server-core/blob/main/statsig-cpp/tests/CMakeLists.txt

Initializes the testing environment by fetching GoogleTest and defining the test executable with source files.

```cmake
cmake_minimum_required(VERSION 3.28)

FetchContent_Declare(googletest
  GIT_REPOSITORY    https://github.com/google/googletest.git
  GIT_TAG           v1.12.0
)
# For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

unset(CMAKE_MODULE_PATH CACHE)

include(GoogleTest)
enable_testing()

file(GLOB STATSIG_TEST_FILES "${PROJECT_SOURCE_DIR}/tests/*")

add_executable(google_tests
  ${STATSIG_SOURCE_FILES}
  ${STATSIG_TEST_FILES}
)
```

--------------------------------

### Get Experiment by Group Name Method

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves a specific experiment group by name.

```rust
pub fn get_experiment_by_group_name(
    &self,
    experiment_name: &str,
    group_name: &str
) -> ExperimentGroup
```

--------------------------------

### Get Experiment Groups Method

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves all groups for an experiment without user evaluation.

```rust
pub fn get_experiment_groups(&self, experiment_name: &str) -> ExperimentGroupsResult
```

```rust
let result = statsig.get_experiment_groups("exp_name");
println!("Is active: {:?}", result.is_experiment_active);
for group in result.groups {
    println!("Group: {}", group.group_name);
}
```

--------------------------------

### Initialize Statsig SDK

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/README.md

Standard lifecycle flow for initializing the SDK, evaluating a gate, and shutting down to flush events.

```rust
let statsig = Statsig::new("api-key", None);
statsig.initialize().await?;         // Fetch specs
let gate = statsig.check_gate(&user, "feature");  // Evaluate
statsig.shutdown().await?;           // Flush events
```

--------------------------------

### Initialization Methods

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Methods for initializing the Statsig client, checking status, and shutting down.

```APIDOC
## Initialization

### Methods
- `initialize(&self) -> Result<(), StatsigErr>`: Initializes the SDK.
- `initialize_with_details(&self) -> Result<InitializeDetails, StatsigErr>`: Initializes and returns initialization details.
- `is_initialized(&self) -> bool`: Checks if the SDK is initialized.
- `shutdown(&self) -> Result<(), StatsigErr>`: Shuts down the SDK.
```

--------------------------------

### Integrate with Axum Web Server

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/09-quick-start.md

Demonstrates initializing Statsig within an Axum application and using it in a route handler.

```rust
use axum::{routing::post, Json, Router, extract::State};
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigUser};

#[tokio::main]
async fn main() {
    let statsig = Arc::new(Statsig::new("sdk-key", None));
    statsig.initialize().await.expect("Init failed");
    
    let app = Router::new()
        .route("/check-feature", post(check_feature))
        .with_state(statsig);
    
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn check_feature(
    State(statsig): State<Arc<Statsig>>,
    Json(body): Json<serde_json::json!({"user_id": String, "feature": String})>,
) -> Json<bool> {
    let user = StatsigUser::with_user_id(&body.user_id);
    Json(statsig.check_gate(&user, &body.feature))
}
```

--------------------------------

### Get Layer Parameters

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Retrieves parameters from a layer and checks for allocated experiment information.

```rust
let layer = statsig.get_layer(&user, "pricing_layer");

if let Some(base_price) = layer.get_opt::<f64>("base_price") {
    if let Some(discount) = layer.get_opt::<f64>("discount_percent") {
        let final_price = base_price * (1.0 - discount / 100.0);
        println!("Price: ${}", final_price);
    }
}

// Get allocated experiment info
if let Some(exp_name) = &layer.allocated_experiment_name {
    println!("Running experiment: {}", exp_name);
}
```

--------------------------------

### Initialize StatsigOptions

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Use the constructor or builder pattern to instantiate the configuration object.

```rust
pub fn new() -> Self
pub fn builder() -> StatsigOptionsBuilder
```

--------------------------------

### Client SDK Integration

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Method to generate the initialization response for client-side SDKs.

```rust
pub fn get_client_init_response(&self, user: &StatsigUser) -> InitializeResponse
```

--------------------------------

### Get Experiment Assignment

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/README.md

Retrieves the experiment group assignment for a user to determine the variant.

```rust
let exp = statsig.get_experiment(&user, "checkout_test");
use_variant(exp.group_name); // "control" or "treatment"
```

--------------------------------

### Configure Custom Specs Adapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Bootstrap the SDK with local JSON specifications.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, StatsigBootstrapSpecsAdapter};

// Load specs from local JSON
let bootstrap_data = r#"{"feature_gates": {}, "dynamic_configs": [], ...}"#;
let adapter = StatsigBootstrapSpecsAdapter::new(bootstrap_data)?;
let options = Arc::new(
    StatsigOptions::builder()
        .specs_adapter(Some(Arc::new(adapter)))
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Initialize Statsig SDK

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Methods for managing the lifecycle of the Statsig client instance.

```rust
pub async fn initialize(&self) -> Result<(), StatsigErr>
pub async fn initialize_with_details(&self) -> Result<InitializeDetails, StatsigErr>
pub fn is_initialized(&self) -> bool
pub async fn shutdown(&self) -> Result<(), StatsigErr>
```

--------------------------------

### Statsig::initialize

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Initializes the Statsig SDK by fetching initial specs and ID lists.

```APIDOC
## Statsig::initialize

### Description
Initializes the Statsig SDK by fetching initial specs and ID lists from the server.

### Returns
- **Result<(), StatsigErr>** - Returns Ok(()) on success, or a StatsigErr on failure (e.g., InitializationError, NetworkError, JsonParseError, GrpcError).
```

--------------------------------

### Check FeatureGate status

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Example usage of checking a feature gate and accessing its properties.

```rust
let gate = statsig.check_gate_with_options(&user, "my_gate", None);
if gate.value {
    println!("Gate {} is ON", gate.name);
    println!("Rule ID: {}", gate.rule_id);
}
```

--------------------------------

### Get CMAB Ranked Groups

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves a ranked list of experiment groups from a specified CMAB.

```rust
pub fn get_cmab_ranked_groups(
    &self,
    user: &StatsigUser,
    cmab_name: &str
) -> Vec<String>
```

--------------------------------

### Generate checksum for release

Source: https://github.com/statsig-io/statsig-server-core/blob/main/statsig-elixir/README.md

Run this command to generate the necessary checksum file for the native bindings during the release process.

```bash
FORCE_STATSIG_NATIVE_BUILD="true" mix rustler_precompiled.download NativeBindings --all --print
```

--------------------------------

### Get Shared Instance

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Retrieves the globally shared Statsig instance. Panics if no instance has been initialized.

```rust
pub fn shared() -> Arc<Statsig>
```

```rust
let statsig = Statsig::shared();
```

--------------------------------

### Create StatsigUser instances

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Initialize users using either a user ID or custom ID mappings.

```rust
use statsig_rust::StatsigUser;

// By user ID
let user = StatsigUser::with_user_id("user-123");

// By custom IDs
let mut custom_ids = HashMap::new();
custom_ids.insert("org_id", "org-456");
let user = StatsigUser::with_custom_ids(custom_ids);
```

--------------------------------

### Initialize and Shutdown Statsig Instance

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Follow the standard lifecycle of creating an instance, initializing with specs, performing evaluations, and shutting down.

```rust
// 1. Create instance
let statsig = Statsig::new("api-key", options);

// 2. Initialize (fetch specs)
statsig.initialize().await?;

// 3. Use evaluation methods
let gate = statsig.check_gate(&user, "feature");

// 4. Shutdown
statsig.shutdown().await?;
```

--------------------------------

### Initialize StatsigBootstrapSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Use this adapter to load specs from a JSON string, typically for bundling specs at build time.

```rust
pub struct StatsigBootstrapSpecsAdapter;

impl StatsigBootstrapSpecsAdapter {
    pub fn new(specs_json: &str) -> Result<Self, StatsigErr>
}
```

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, StatsigBootstrapSpecsAdapter};

let specs_json = include_str!("specs.json");
let adapter = StatsigBootstrapSpecsAdapter::new(specs_json)?;
let options = Arc::new(
    StatsigOptions::builder()
        .specs_adapter(Some(Arc::new(adapter)))
        .build()
);
let statsig = Statsig::new("sdk-key", Some(options));
```

--------------------------------

### Initialize StatsigHttpSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

The default adapter for fetching specs from the Statsig API over HTTP.

```rust
pub struct StatsigHttpSpecsAdapter {
    // ...
}

impl StatsigHttpSpecsAdapter {
    pub fn new(url: String, network_client: Arc<NetworkClient>) -> Self
}
```

--------------------------------

### get_client_init_response

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Returns a JSON response suitable for client SDK initialization.

```APIDOC
## get_client_init_response

### Description
Returns a JSON response suitable for client SDK initialization. Contains user evaluations.

### Signature
`pub fn get_client_init_response(&self, user: &StatsigUser) -> InitializeResponse`

### Returns
`InitializeResponse` struct (serializable to JSON)
```

--------------------------------

### Configure Statsig with a local file adapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Initialize the local file adapter and inject it into the StatsigOptions builder.

```rust
let adapter = StatsigLocalFileEventLoggingAdapter::new(
    "/tmp/statsig_events.jsonl".to_string()
);
let options = Arc::new(
    StatsigOptions::builder()
        .event_logging_adapter(Some(Arc::new(adapter)))
        .build()
);
```

--------------------------------

### Configure Proxy Settings

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Route SDK traffic through a proxy server.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, ProxyConfig};

let proxy = ProxyConfig {
    url: "http://proxy.internal:8080".to_string(),
    username: Some("user".to_string()),
    password: Some("pass".to_string()),
};

let options = Arc::new(
    StatsigOptions::builder()
        .proxy_config(Some(proxy))
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Override Gates and Configs for Testing

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Use overrides during test setup to force specific gate and config values for a given user ID.

```rust
// During test setup
statsig.override_gate("test_feature", true, Some("test-user"));
statsig.override_dynamic_config(
    "test_config",
    HashMap::from([("key", Value::String("value"))]),
    Some("test-user"),
);

// Test code
let user = StatsigUser::with_user_id("test-user");
assert!(statsig.check_gate(&user, "test_feature"));

// Cleanup happens automatically
```

--------------------------------

### Implement Initialization with Exponential Backoff

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Retry the initialization process with increasing delays to handle transient network or service errors.

```rust
use std::time::Duration;
use tokio::time::sleep;

async fn init_with_retry(sdk_key: &str, max_attempts: u32) -> bool {
    let statsig = Statsig::new(sdk_key, None);
    let mut attempt = 0;
    let mut delay = Duration::from_millis(100);
    
    loop {
        attempt += 1;
        match statsig.initialize().await {
            Ok(()) => {
                println!("Initialized successfully");
                return true;
            }
            Err(e) if attempt < max_attempts => {
                eprintln!("Init attempt {} failed: {}", attempt, e);
                sleep(delay).await;
                delay = Duration::from_millis((delay.as_millis() * 2).min(5000));
            }
            Err(e) => {
                eprintln!("Init failed after {} attempts: {}", attempt, e);
                return false;
            }
        }
    }
}
```

--------------------------------

### Retrieve Detailed Initialization Information

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/05-errors.md

Access initialization success status and failure details using the initialize_with_details method.

```rust
match statsig.initialize_with_details().await {
    Ok(details) => {
        if details.init_success {
            println!("Initialized in {} ms", details.duration_ms);
        } else if let Some(failure) = details.failure_details {
            eprintln!("Initialization failed: {}", failure.reason);
            if let Some(err) = failure.error {
                eprintln!("Error: {}", err);
            }
        }
    }
    Err(e) => eprintln!("Init error: {}", e),
}
```

--------------------------------

### Initialize StatsigDataStoreSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Loads specs from an external data store, enabling shared specs across multiple server instances.

```rust
pub struct StatsigDataStoreSpecsAdapter {
    store: Arc<dyn DataStoreTrait>,
    sync_interval_secs: u32,
}

impl StatsigDataStoreSpecsAdapter {
    pub fn new(store: Arc<dyn DataStoreTrait>, sync_interval_secs: Option<u32>) -> Self
}
```

--------------------------------

### statsig.get_client_init_response()

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Generates an initialization response object for client-side SDKs based on the provided user context.

```APIDOC
## statsig.get_client_init_response(user)

### Description
Generates the initialization payload required by client SDKs to evaluate feature gates and dynamic configs.

### Parameters
- **user** (StatsigUser) - Required - The user object for which to generate the initialization response.

### Response
- **InitializeResponse** (Object) - Contains feature gates, dynamic configs, layer configs, and metadata required for client-side initialization.
```

--------------------------------

### Statsig::is_initialized

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Checks if the SDK is ready for use.

```APIDOC
## Statsig::is_initialized

### Description
Checks if the SDK has completed initialization and is ready to evaluate gates and configs.

### Returns
- **bool** - True if specs are loaded and ready.
```

--------------------------------

### Set Environment Tagging

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Tag the SDK instance with environment and service name metadata.

```rust
let options = Arc::new(
    StatsigOptions::builder()
        .environment(Some("production".to_string()))
        .service_name(Some("my-api-server".to_string()))
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Configure Client Initialization Response

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Customize the initialization response using ClientInitResponseOptions to include evaluation reasons or secondary exposures.

```rust
use statsig_rust::ClientInitResponseOptions;

let opts = ClientInitResponseOptions {
    include_reason: true,           // Include evaluation reason
    include_secondary_exposures: true,
    // ... other format options
};

let response = statsig.get_client_init_response_with_options(&user, Some(opts));
```

--------------------------------

### Configure Data Store Adapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Use StatsigDataStoreSpecsAdapter to share a specs cache across multiple server instances.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, StatsigDataStoreSpecsAdapter};

let redis_store = Arc::new(MyRedisDataStore::new("redis://..."?);
let specs_adapter = StatsigDataStoreSpecsAdapter::new(redis_store.clone(), Some(120));
let options = Arc::new(
    StatsigOptions::builder()
        .specs_adapter(Some(Arc::new(specs_adapter)))
        .build()
);
let statsig = Statsig::new("sdk-key", Some(options));
```

--------------------------------

### Statsig::new

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Creates a new instance of the Statsig SDK.

```APIDOC
## Statsig::new

### Description
Creates a new Statsig instance using the provided API key and optional configuration.

### Parameters
- **sdk_key** (&str) - Required - Your Statsig API key for server-side access
- **options** (Option<Arc<StatsigOptions>>) - Optional - Configuration options; defaults to minimal configuration if None

### Returns
- **Statsig** - A new instance of the Statsig SDK
```

--------------------------------

### Initialize Statsig Instance

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Create a new Statsig instance using an API key and optional configuration.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let statsig = Statsig::new("secret-api-key", None);
```

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let options = Arc::new(
    StatsigOptions::builder()
        .init_timeout_ms(Some(5000))
        .disable_all_logging(Some(false))
        .build()
);
let statsig = Statsig::new("secret-api-key", Some(options));
```

--------------------------------

### Check Initialization State

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Verify if the SDK has completed loading specs.

```rust
if statsig.is_initialized() {
    // Safe to evaluate gates/configs
}
```

--------------------------------

### Initialize StatsigLocalFileSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Loads specs from the local filesystem, useful for development or offline modes.

```rust
pub struct StatsigLocalFileSpecsAdapter {
    path: String,
    sync_interval_secs: u32,
}

impl StatsigLocalFileSpecsAdapter {
    pub fn new(path: String, sync_interval_secs: Option<u32>) -> Self
}
```

```rust
let adapter = StatsigLocalFileSpecsAdapter::new(
    "/etc/statsig/specs.json".to_string(),
    Some(120), // 2 minutes
);
let options = Arc::new(
    StatsigOptions::builder()
        .specs_adapter(Some(Arc::new(adapter)))
        .build()
);
```

--------------------------------

### Initialize and Use Shared Statsig Instance

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/09-quick-start.md

Demonstrates global initialization and subsequent retrieval of the Statsig instance for use across the application.

```rust
// Initialize globally
Statsig::new_shared("sdk-key", None);

// Use anywhere
let statsig = Statsig::shared();
let gate = statsig.check_gate(&user, "feature");
```

--------------------------------

### Initialize StatsigHttpIdListsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

The default adapter for fetching ID lists from the Statsig API.

```rust
pub struct StatsigHttpIdListsAdapter {
    // ...
}

impl StatsigHttpIdListsAdapter {
    pub fn new(
        url: String,
        file_download_api: String,
        network_client: Arc<NetworkClient>
    ) -> Self
}
```

--------------------------------

### Configure User Country and IP

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Set IP, country, and user agent information to influence targeting and analytics.

```rust
let mut user = StatsigUser::with_user_id("user-123");
user.set_ip("203.0.113.42");        // Country auto-detected from IP
user.set_country("US");              // Or set explicitly
user.set_user_agent("Mozilla/5.0..."); // Parsed for browser/OS info

let gate = statsig.check_gate(&user, "us_feature");
```

--------------------------------

### Configure Persistent Storage

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Provide a custom storage implementation for sticky experiments.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let storage = Arc::new(MyPersistentStorage::new());
let options = Arc::new(
    StatsigOptions::builder()
        .persistent_storage(Some(storage))
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Configure Adapter Priority

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Define the order in which the SDK attempts to load specs using different adapters.

```rust
let adapters = vec![
    SpecAdapterConfig::DataStore { /* ... */ },      // Try 1st
    SpecAdapterConfig::File { path: "...".to_string() },  // Try 2nd
    SpecAdapterConfig::Bootstrap { data: "...".to_string() }, // Try 3rd
    // Implicit: HTTP adapter
];

let options = Arc::new(
    StatsigOptions::builder()
        .spec_adapters_config(Some(adapters))
        .fallback_to_statsig_api(Some(true)) // Fall back to HTTP
        .build()
);
```

--------------------------------

### Configure Network Settings

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Manage network connectivity, custom API endpoints, and proxy settings for the SDK.

```rust
let options = Arc::new(
    StatsigOptions::builder()
        .disable_network(Some(true))
        .build()
);
let statsig = Statsig::new("sdk-key", Some(options));
// No outbound network: must use bootstrap or local adapters
```

```rust
let options = Arc::new(
    StatsigOptions::builder()
        .specs_url(Some("https://internal-api.corp.com/specs".to_string()))
        .log_event_url(Some("https://internal-api.corp.com/log".to_string()))
        .build()
);
```

```rust
use statsig_rust::ProxyConfig;

let proxy = ProxyConfig {
    url: "http://proxy.internal:8080".to_string(),
    username: Some("proxy_user".to_string()),
    password: Some("proxy_pass".to_string()),
};

let options = Arc::new(
    StatsigOptions::builder()
        .proxy_config(Some(proxy))
        .build()
);
```

--------------------------------

### Evaluate Basic Experiments

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/08-usage-examples.md

Retrieve experiment details and branch logic based on experiment parameters.

```rust
let exp = statsig.get_experiment(&user, "checkout_flow_test");

println!("Group: {:?}", exp.group_name);
println!("Active: {}", exp.is_experiment_active);

if let Some(flow) = exp.get_opt::<String>("flow_type") {
    match flow.as_str() {
        "one_click" => use_one_click_checkout(),
        "standard" => use_standard_checkout(),
        _ => use_default_checkout(),
    }
}
```

--------------------------------

### Initialize StatsigCustomizedSpecsAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

Combines multiple specs adapters to implement custom fallback logic.

```rust
pub struct StatsigCustomizedSpecsAdapter {
    adapters: Vec<Box<dyn SpecsAdapter>>,
}

impl StatsigCustomizedSpecsAdapter {
    pub fn new(adapters: Vec<Box<dyn SpecsAdapter>>) -> Self
}
```

--------------------------------

### Set Initialization Timeout

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Configure the maximum time allowed for SDK initialization.

```rust
let options = Arc::new(
    StatsigOptions::builder()
        .init_timeout_ms(Some(10000)) // 10 seconds
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Configure Multiple Spec Adapters

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/04-configuration.md

Define a priority-based list of spec adapters with fallback options.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions, SpecAdapterConfig};

let adapters = vec![
    SpecAdapterConfig::DataStore { /* ... */ },
    SpecAdapterConfig::File { path: "/etc/statsig/specs.json".to_string() },
    SpecAdapterConfig::Bootstrap { data: bootstrap_json },
    // HTTP adapter is implicit fallback
];

let options = Arc::new(
    StatsigOptions::builder()
        .spec_adapters_config(Some(adapters))
        .fallback_to_statsig_api(Some(true))
        .build()
);
let statsig = Statsig::new("your-sdk-key", Some(options));
```

--------------------------------

### Generate Client Initialization Response

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Create a JSON payload for client SDK initialization based on a specific user.

```rust
let user = StatsigUser::with_user_id("user-123");
let response = statsig.get_client_init_response(&user);
let json = serde_json::to_string(&response)?;
// Send json to client SDK
```

--------------------------------

### get_dynamic_config_list / get_experiment_list / get_layer_list

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/02-statsig-class.md

Returns names of all loaded entities.

```APIDOC
## get_dynamic_config_list / get_experiment_list / get_layer_list

### Description
Returns names of all loaded entities.

### Signatures
- `pub fn get_dynamic_config_list(&self) -> Vec<String>`
- `pub fn get_experiment_list(&self) -> Vec<String>`
- `pub fn get_layer_list(&self) -> Vec<String>`

### Example
`let configs = statsig.get_dynamic_config_list();`
```

--------------------------------

### Configure Persistent Storage

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Initialize Statsig with a custom persistent storage implementation to enable sticky values.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let storage = Arc::new(MyPersistentStorage::new());
let options = Arc::new(
    StatsigOptions::builder()
        .persistent_storage(Some(storage))
        .build()
);
let statsig = Statsig::new("sdk-key", Some(options));
```

--------------------------------

### Construct StatsigUser instances

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Methods for creating a new StatsigUser instance.

```rust
impl StatsigUser {
    pub fn with_user_id(user_id: impl Into<UnitID>) -> Self
    pub fn with_custom_ids<K, U>(custom_ids: HashMap<K, U>) -> Self
    pub fn new(inner: UserData) -> Self
}
```

--------------------------------

### Initialize StatsigLocalOverrideAdapter

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/06-adapters.md

The default in-memory implementation for managing local overrides.

```rust
pub struct StatsigLocalOverrideAdapter {
    // ...
}

impl StatsigLocalOverrideAdapter {
    pub fn new() -> Arc<Self>
}
```

--------------------------------

### Retrieve a Dynamic Config

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/README.md

Fetches configuration parameters and retrieves a specific value by key.

```rust
let config = statsig.get_dynamic_config(&user, "pricing");
let price = config.get_opt::<f64>("base_price");
```

--------------------------------

### Configure User Agent Parsing in Rust

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/07-advanced-features.md

Control user agent parsing behavior during SDK initialization via StatsigOptions.

```rust
use std::sync::Arc;
use statsig_rust::{Statsig, StatsigOptions};

let options = Arc::new(
    StatsigOptions::builder()
        .wait_for_user_agent_init(Some(true))  // Block init until ready
        .use_third_party_ua_parser(Some(false)) // Use built-in parser
        .build()
);
let statsig = Statsig::new("sdk-key", Some(options));
```

--------------------------------

### Define InitializeResponse struct

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Represents the response structure for client SDK initialization, designed for JSON serialization.

```rust
pub struct InitializeResponse {
    pub feature_gates: HashMap<String, GateEvaluation>,
    pub dynamic_configs: HashMap<String, AnyConfigEvaluation>,
    pub layer_configs: HashMap<String, LayerEvaluation>,
    pub time: u64,
    pub has_updates: bool,
    pub hash_used: String,
    pub user: StatsigUserLoggable,
    pub sdk_info: HashMap<String, String>,
    pub sdk_params: HashMap<String, String>,
    pub evaluated_keys: EvaluatedKeys,
    pub param_stores: HashMap<String, HashMap<String, Parameter>>,
    pub can_record_session: Option<bool>,
    pub session_recording_rate: Option<f64>,
    pub recording_blocked: Option<bool>,
    pub passes_session_recording_targeting: Option<bool>,
    pub session_recording_event_triggers: Option<HashMap<String, SessionReplayTrigger>>,
    pub session_recording_exposure_triggers: Option<HashMap<String, SessionReplayTrigger>>,
    pub session_recording_privacy_settings: Option<SessionReplayPrivacySetting>,
    pub pa_hash: Option<String>,
    pub full_checksum: Option<String>,
}
```

--------------------------------

### Retrieve Dynamic Configuration

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Fetch a dynamic configuration object and safely extract typed values.

```rust
let config = statsig.get_dynamic_config(&user, "user_config");
if let Some(timeout) = config.get_opt::<u32>("timeout_ms") {
    set_timeout(timeout);
}
```

--------------------------------

### Evaluate Features

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/00-index.md

Methods to check feature gates, dynamic configs, experiments, and layers for a given user.

```rust
pub fn check_gate(&self, user: &StatsigUser, gate_name: &str) -> bool
pub fn get_dynamic_config(&self, user: &StatsigUser, config_name: &str) -> DynamicConfig
pub fn get_experiment(&self, user: &StatsigUser, experiment_name: &str) -> Experiment
pub fn get_layer(&self, user: &StatsigUser, layer_name: &str) -> Layer
pub fn get_parameter_store(&self, store_name: &str) -> ParameterStore<'_>
```

--------------------------------

### Handle Initialization Errors in Rust

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/05-errors.md

Use pattern matching on the result of the initialize method to distinguish between initialization and network-related errors.

```rust
use statsig_rust::Statsig;

let statsig = Statsig::new("sdk-key", None);

match statsig.initialize().await {
    Ok(()) => println!("Ready"),
    Err(e) => {
        eprintln!("Init failed: {}", e);
        match e {
            StatsigErr::InitializationError(_) => {
                // Network or specs error
                eprintln!("Will retry on next request");
            }
            StatsigErr::NetworkError(_) => {
                // Network connectivity issue
                eprintln!("Check network connection");
            }
            _ => eprintln!("Unexpected error"),
        }
    }
}
```

--------------------------------

### Link Libraries and Set Build Features

Source: https://github.com/statsig-io/statsig-server-core/blob/main/statsig-cpp/tests/CMakeLists.txt

Configures include directories, links the Statsig library and GTest, and enforces C++17 standard.

```cmake
target_include_directories(google_tests PRIVATE "../include")
target_include_directories(google_tests PRIVATE "../src")

target_link_libraries(google_tests Statsig)
target_link_libraries(google_tests GTest::gtest_main)
target_compile_features(google_tests PUBLIC cxx_std_17)

add_definitions( -DTESTS_ROOT_DIR="${CMAKE_CURRENT_SOURCE_DIR}" )

gtest_discover_tests(google_tests)
```

--------------------------------

### Access Dynamic Configurations

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/09-quick-start.md

Retrieve configuration parameters with typed access.

```rust
// Get config with typed access
let config = statsig.get_dynamic_config(&user, "config_name");
if let Some(value) = config.get_opt::<String>("parameter_name") {
    use_config_value(&value);
}
```

--------------------------------

### Define ParameterStoreEvaluationOptions

Source: https://github.com/statsig-io/statsig-server-core/blob/main/_autodocs/03-types.md

Configuration for parameter store evaluation.

```rust
pub struct ParameterStoreEvaluationOptions {
    pub disable_exposure_logging: bool,
}
```
Tokens:
Raw