statsig-python-core 0.13.0__tar.gz → 0.13.1b2512030239__tar.gz

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/Cargo.lock

@@ -2528,7 +2528,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2602,7 +2602,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "statsig-node"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "async-trait",
  "napi",
@@ -2616,7 +2616,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2630,7 +2630,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -2676,7 +2676,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "parking_lot",
  "rustler",
@@ -2688,7 +2688,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/Cargo.toml

@@ -18,7 +18,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.13.0"
+version = "0.13.1-beta.2512030239"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.13.0
+Version: 0.13.1b2512030239
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/Cargo.toml

@@ -38,7 +38,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.13.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.13.1-beta.2512030239", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }
@@ -70,3 +70,4 @@ custom_network_provider = []
 with_grpc = ["sigstat-grpc"]
 testing = []
 with_zstd = []
+ffi-support = []

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/evaluation/evaluator_result.rs

@@ -20,6 +20,10 @@ use crate::evaluation::secondary_exposure_key::SecondaryExposureKey;
 use crate::hashing::{HashAlgorithm, HashUtil};
 use crate::interned_string::InternedString;
 use crate::specs_response::explicit_params::ExplicitParameters;
+use crate::statsig_types_raw::{DynamicConfigRaw, ExperimentRaw, FeatureGateRaw, LayerRaw};
+use crate::{log_e, EvaluationDetails};
+
+const TAG: &str = "EvaluatorResult";
 
 #[derive(Default, Debug)]
 pub struct EvaluatorResult {
@@ -48,6 +52,31 @@ pub struct EvaluatorResult {
     pub parameter_rule_ids: Option<HashMap<InternedString, InternedString>>,
 }
 
+pub fn result_to_gate_raw(
+    gate_name: &str,
+    eval_details: &EvaluationDetails,
+    result: Option<&EvaluatorResult>,
+) -> String {
+    let raw = match result {
+        Some(result) => FeatureGateRaw {
+            name: gate_name,
+            details: eval_details,
+            rule_id: result.rule_id.as_ref(),
+            id_type: result.id_type.as_ref(),
+            value: result.bool_value,
+        },
+        None => FeatureGateRaw::empty(gate_name, eval_details),
+    };
+
+    match serde_json::to_string(&raw) {
+        Ok(raw) => raw,
+        Err(e) => {
+            log_e!(TAG, "Failed to convert FeatureGateRaw to string: {}", e);
+            format!(r#"{{"name": "{}", "value": false}}"#, gate_name)
+        }
+    }
+}
+
 pub fn result_to_gate_eval(gate_name: &str, result: &mut EvaluatorResult) -> GateEvaluation {
     GateEvaluation {
         base: result_to_base_eval(gate_name, result),
@@ -84,6 +113,33 @@ pub fn result_to_gate_eval_init_v2(
     }
 }
 
+pub fn result_to_experiment_raw(
+    experiment_name: &str,
+    eval_details: &EvaluationDetails,
+    result: Option<&EvaluatorResult>,
+) -> String {
+    let raw = match result {
+        Some(result) => ExperimentRaw {
+            name: experiment_name,
+            value: result.json_value.as_ref(),
+            details: eval_details,
+            rule_id: result.rule_id.as_ref(),
+            id_type: result.id_type.as_ref(),
+            group_name: result.group_name.as_ref(),
+            is_experiment_active: Some(result.is_experiment_active),
+        },
+        None => ExperimentRaw::empty(experiment_name, eval_details),
+    };
+
+    match serde_json::to_string(&raw) {
+        Ok(raw) => raw,
+        Err(e) => {
+            log_e!(TAG, "Failed to convert ExperimentRaw to string: {}", e);
+            format!(r#"{{"name": "{}"}}"#, experiment_name)
+        }
+    }
+}
+
 pub fn result_to_experiment_eval(
     experiment_name: &str,
     spec_entity: Option<&str>,
@@ -203,6 +259,33 @@ pub fn eval_result_to_experiment_eval(
     }
 }
 
+pub fn result_to_layer_raw(
+    layer_name: &str,
+    eval_details: &EvaluationDetails,
+    result: Option<&EvaluatorResult>,
+) -> String {
+    let raw = match result {
+        Some(result) => LayerRaw {
+            name: layer_name,
+            details: eval_details,
+            rule_id: result.rule_id.as_ref(),
+            id_type: result.id_type.as_ref(),
+            group_name: result.group_name.as_ref(),
+            allocated_experiment_name: result.config_delegate.as_ref(),
+            is_experiment_active: Some(result.is_experiment_active),
+        },
+        None => LayerRaw::empty(layer_name, eval_details),
+    };
+
+    match serde_json::to_string(&raw) {
+        Ok(raw) => raw,
+        Err(e) => {
+            log_e!(TAG, "Failed to convert LayerRaw to string: {}", e);
+            format!(r#"{{"name": "{}"}}"#, layer_name)
+        }
+    }
+}
+
 pub fn result_to_layer_eval(layer_name: &str, result: &mut EvaluatorResult) -> LayerEvaluation {
     let mut allocated_experiment_name = None;
     let mut is_experiment_active = None;
@@ -334,6 +417,31 @@ pub fn result_to_layer_eval_init_v2(
     }
 }
 
+pub fn result_to_dynamic_config_raw(
+    dynamic_config_name: &str,
+    eval_details: &EvaluationDetails,
+    result: Option<&EvaluatorResult>,
+) -> String {
+    let raw = match result {
+        Some(result) => DynamicConfigRaw {
+            name: dynamic_config_name,
+            value: result.json_value.as_ref(),
+            details: eval_details,
+            rule_id: result.rule_id.as_ref(),
+            id_type: result.id_type.as_ref(),
+        },
+        None => DynamicConfigRaw::empty(dynamic_config_name, eval_details),
+    };
+
+    match serde_json::to_string(&raw) {
+        Ok(raw) => raw,
+        Err(e) => {
+            log_e!(TAG, "Failed to convert DynamicConfigRaw to string: {}", e);
+            format!(r#"{{"name": "{}"}}"#, dynamic_config_name)
+        }
+    }
+}
+
 pub fn result_to_dynamic_config_eval(
     dynamic_config_name: &str,
     result: &mut EvaluatorResult,

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/lib.rs

@@ -56,6 +56,7 @@ pub mod statsig_metadata;
 pub mod statsig_options;
 pub mod statsig_runtime;
 pub mod statsig_types;
+pub mod statsig_types_raw;
 pub mod user;
 
 mod dcs_str;

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/sdk_event_emitter/event_emitter.rs

@@ -144,6 +144,29 @@ impl Statsig {
         });
     }
 
+    #[cfg(feature = "ffi-support")]
+    pub(crate) fn emit_gate_evaluated_parts(
+        &self,
+        gate_name: &str,
+        reason: &str,
+        eval_result: Option<&crate::evaluation::evaluator_result::EvaluatorResult>,
+    ) {
+        let mut rule_id = None;
+        let mut value = false;
+
+        if let Some(eval) = eval_result {
+            rule_id = eval.rule_id.as_ref().map(|r| r.as_str());
+            value = eval.bool_value;
+        }
+
+        self.emit(SdkEvent::GateEvaluated {
+            gate_name,
+            rule_id: rule_id.unwrap_or_default(),
+            value,
+            reason,
+        });
+    }
+
     pub(crate) fn emit_dynamic_config_evaluated(&self, config: &DynamicConfig) {
         self.emit(SdkEvent::DynamicConfigEvaluated {
             config_name: config.name.as_str(),
@@ -153,12 +176,62 @@ impl Statsig {
         });
     }
 
+    #[cfg(feature = "ffi-support")]
+    pub(crate) fn emit_dynamic_config_evaluated_parts(
+        &self,
+        config_name: &str,
+        reason: &str,
+        eval_result: Option<&crate::evaluation::evaluator_result::EvaluatorResult>,
+    ) {
+        let mut rule_id = None;
+        let mut value = None;
+
+        if let Some(eval) = eval_result {
+            rule_id = eval.rule_id.as_ref().map(|r| r.as_str());
+            value = eval.json_value.as_ref();
+        }
+
+        self.emit(SdkEvent::DynamicConfigEvaluated {
+            config_name,
+            reason,
+            rule_id,
+            value,
+        });
+    }
+
     pub(crate) fn emit_experiment_evaluated(&self, experiment: &Experiment) {
         self.emit(SdkEvent::ExperimentEvaluated {
             experiment_name: experiment.name.as_str(),
             reason: experiment.details.reason.as_str(),
             rule_id: Some(experiment.rule_id.as_str()),
             value: experiment.__evaluation.as_ref().map(|e| &e.value),
+            group_name: experiment.group_name.as_deref(),
+        });
+    }
+
+    #[cfg(feature = "ffi-support")]
+    pub(crate) fn emit_experiment_evaluated_parts(
+        &self,
+        experiment_name: &str,
+        reason: &str,
+        eval_result: Option<&crate::evaluation::evaluator_result::EvaluatorResult>,
+    ) {
+        let mut rule_id = None;
+        let mut value = None;
+        let mut group_name = None;
+
+        if let Some(eval) = eval_result {
+            rule_id = eval.rule_id.as_ref().map(|r| r.as_str());
+            value = eval.json_value.as_ref();
+            group_name = eval.group_name.as_ref().map(|g| g.as_str());
+        }
+
+        self.emit(SdkEvent::ExperimentEvaluated {
+            experiment_name,
+            reason,
+            rule_id,
+            value,
+            group_name,
         });
     }
 
@@ -169,4 +242,24 @@ impl Statsig {
             rule_id: Some(layer.rule_id.as_str()),
         });
     }
+
+    #[cfg(feature = "ffi-support")]
+    pub(crate) fn emit_layer_evaluated_parts(
+        &self,
+        layer_name: &str,
+        reason: &str,
+        eval_result: Option<&crate::evaluation::evaluator_result::EvaluatorResult>,
+    ) {
+        let mut rule_id = None;
+
+        if let Some(eval) = eval_result {
+            rule_id = eval.rule_id.as_ref().map(|r| r.as_str());
+        }
+
+        self.emit(SdkEvent::LayerEvaluated {
+            layer_name,
+            reason,
+            rule_id,
+        });
+    }
 }

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/sdk_event_emitter/event_types.rs

@@ -59,6 +59,7 @@ pub enum SdkEvent<'a> {
         reason: &'a str,
         rule_id: Option<&'a str>,
         value: Option<&'a crate::DynamicReturnable>,
+        group_name: Option<&'a str>,
     },
     LayerEvaluated {
         layer_name: &'a str,

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/statsig.rs

@@ -1129,6 +1129,41 @@ impl Statsig {
         self.spec_store
             .get_fields_used_for_entity(gate_name, SpecType::Gate)
     }
+
+    #[cfg(feature = "ffi-support")]
+    pub fn get_raw_gate_with_options(
+        &self,
+        user: &StatsigUser,
+        gate_name: &str,
+        options: FeatureGateEvaluationOptions,
+    ) -> String {
+        use crate::evaluation::evaluator_result::result_to_gate_raw;
+
+        let interned_gate_name = InternedString::from_str_ref(gate_name);
+        let user_internal = self.internalize_user(user);
+
+        let (details, evaluation) =
+            self.evaluate_spec_raw(&user_internal, gate_name, &SpecType::Gate, None);
+
+        let raw = result_to_gate_raw(gate_name, &details, evaluation.as_ref());
+
+        self.emit_gate_evaluated_parts(gate_name, details.reason.as_str(), evaluation.as_ref());
+
+        if options.disable_exposure_logging {
+            log_d!(TAG, "Exposure logging is disabled for gate {}", gate_name);
+            self.event_logger.increment_non_exposure_checks(gate_name);
+        } else {
+            self.event_logger.enqueue(EnqueueExposureOp::gate_exposure(
+                &user_internal,
+                &interned_gate_name,
+                ExposureTrigger::Auto,
+                details,
+                evaluation,
+            ));
+        }
+
+        raw
+    }
 }
 
 // ------------------------------------------------------------------------------- [ Dynamic Config ]
@@ -1211,6 +1246,56 @@ impl Statsig {
         self.spec_store
             .get_fields_used_for_entity(config_name, SpecType::DynamicConfig)
     }
+
+    #[cfg(feature = "ffi-support")]
+    pub fn get_raw_dynamic_config_with_options(
+        &self,
+        user: &StatsigUser,
+        dynamic_config_name: &str,
+        options: DynamicConfigEvaluationOptions,
+    ) -> String {
+        use crate::evaluation::evaluator_result::result_to_dynamic_config_raw;
+
+        let interned_dynamic_config_name = InternedString::from_str_ref(dynamic_config_name);
+        let user_internal = self.internalize_user(user);
+        let disable_exposure_logging: bool = options.disable_exposure_logging;
+
+        let (details, evaluation) = self.evaluate_spec_raw(
+            &user_internal,
+            dynamic_config_name,
+            &SpecType::DynamicConfig,
+            Some(disable_exposure_logging),
+        );
+
+        let raw = result_to_dynamic_config_raw(dynamic_config_name, &details, evaluation.as_ref());
+
+        self.emit_dynamic_config_evaluated_parts(
+            dynamic_config_name,
+            details.reason.as_str(),
+            evaluation.as_ref(),
+        );
+
+        if disable_exposure_logging {
+            log_d!(
+                TAG,
+                "Exposure logging is disabled for Dynamic Config {}",
+                dynamic_config_name
+            );
+            self.event_logger
+                .increment_non_exposure_checks(dynamic_config_name);
+        } else {
+            self.event_logger
+                .enqueue(EnqueueExposureOp::dynamic_config_exposure(
+                    &user_internal,
+                    &interned_dynamic_config_name,
+                    ExposureTrigger::Auto,
+                    details,
+                    evaluation,
+                ));
+        }
+
+        raw
+    }
 }
 
 // ------------------------------------------------------------------------------- [ Experiment ]
@@ -1354,6 +1439,56 @@ impl Statsig {
             EvaluationDetails::unrecognized(&data.source, data.values.time, data.time_received_at),
         )
     }
+
+    #[cfg(feature = "ffi-support")]
+    pub fn get_raw_experiment_with_options(
+        &self,
+        user: &StatsigUser,
+        experiment_name: &str,
+        options: ExperimentEvaluationOptions,
+    ) -> String {
+        use crate::evaluation::evaluator_result::result_to_experiment_raw;
+
+        let interned_experiment_name = InternedString::from_str_ref(experiment_name);
+        let user_internal = self.internalize_user(user);
+        let disable_exposure_logging: bool = options.disable_exposure_logging;
+
+        let (details, evaluation) = self.evaluate_spec_raw(
+            &user_internal,
+            experiment_name,
+            &SpecType::Experiment,
+            Some(disable_exposure_logging),
+        );
+
+        let raw = result_to_experiment_raw(experiment_name, &details, evaluation.as_ref());
+
+        self.emit_experiment_evaluated_parts(
+            experiment_name,
+            details.reason.as_str(),
+            evaluation.as_ref(),
+        );
+
+        if disable_exposure_logging {
+            log_d!(
+                TAG,
+                "Exposure logging is disabled for Experiment {}",
+                experiment_name
+            );
+            self.event_logger
+                .increment_non_exposure_checks(experiment_name);
+        } else {
+            self.event_logger
+                .enqueue(EnqueueExposureOp::dynamic_config_exposure(
+                    &user_internal,
+                    &interned_experiment_name,
+                    ExposureTrigger::Auto,
+                    details,
+                    evaluation,
+                ));
+        }
+
+        raw
+    }
 }
 
 // ------------------------------------------------------------------------------- [ Layer ]
@@ -1400,6 +1535,37 @@ impl Statsig {
         self.spec_store
             .get_fields_used_for_entity(layer_name, SpecType::Layer)
     }
+
+    #[cfg(feature = "ffi-support")]
+    pub fn get_raw_layer_with_options(
+        &self,
+        user: &StatsigUser,
+        layer_name: &str,
+        options: LayerEvaluationOptions,
+    ) -> String {
+        use crate::evaluation::evaluator_result::result_to_layer_raw;
+
+        let user_internal = self.internalize_user(user);
+        let disable_exposure_logging: bool = options.disable_exposure_logging;
+
+        let (details, evaluation) = self.evaluate_spec_raw(
+            &user_internal,
+            layer_name,
+            &SpecType::Experiment,
+            Some(disable_exposure_logging),
+        );
+
+        let raw = result_to_layer_raw(layer_name, &details, evaluation.as_ref());
+
+        self.emit_layer_evaluated_parts(layer_name, details.reason.as_str(), evaluation.as_ref());
+
+        if disable_exposure_logging {
+            log_d!(TAG, "Exposure logging is disabled for Layer {}", layer_name);
+            self.event_logger.increment_non_exposure_checks(layer_name);
+        }
+
+        raw
+    }
 }
 
 // ------------------------------------------------------------------------------- [ Internal ]

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/src/statsig_metadata.rs

@@ -49,7 +49,7 @@ pub struct StatsigMetadataWithLogEventExtras {
 impl StatsigMetadata {
     fn new() -> Self {
         Self {
-            sdk_version: "0.13.0".to_string(),
+            sdk_version: "0.13.1-beta.2512030239".to_string(),
             sdk_type: "statsig-server-core".to_string(),
             session_id: Uuid::new_v4().to_string(),
             os: None,

statsig_python_core-0.13.1b2512030239/statsig-rust/src/statsig_types_raw.rs

@@ -0,0 +1,125 @@
+use serde::Serialize;
+
+use crate::evaluation::dynamic_returnable::DynamicReturnable;
+use crate::evaluation::evaluation_details::EvaluationDetails;
+use crate::interned_string::InternedString;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct FeatureGateRaw<'a> {
+    pub name: &'a str,
+
+    pub value: bool,
+
+    #[serde(rename = "ruleID")]
+    pub rule_id: Option<&'a InternedString>,
+
+    pub id_type: Option<&'a InternedString>,
+
+    pub details: &'a EvaluationDetails,
+}
+
+impl<'a> FeatureGateRaw<'a> {
+    pub fn empty(name: &'a str, details: &'a EvaluationDetails) -> Self {
+        Self {
+            name,
+            value: false,
+            details,
+            rule_id: None,
+            id_type: None,
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DynamicConfigRaw<'a> {
+    pub name: &'a str,
+
+    pub value: Option<&'a DynamicReturnable>,
+
+    #[serde(rename = "ruleID")]
+    pub rule_id: Option<&'a InternedString>,
+
+    pub id_type: Option<&'a InternedString>,
+
+    pub details: &'a EvaluationDetails,
+}
+
+impl<'a> DynamicConfigRaw<'a> {
+    pub fn empty(name: &'a str, details: &'a EvaluationDetails) -> Self {
+        Self {
+            name,
+            value: None,
+            details,
+            rule_id: None,
+            id_type: None,
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ExperimentRaw<'a> {
+    pub name: &'a str,
+
+    pub value: Option<&'a DynamicReturnable>,
+
+    #[serde(rename = "ruleID")]
+    pub rule_id: Option<&'a InternedString>,
+
+    pub id_type: Option<&'a InternedString>,
+
+    pub group_name: Option<&'a InternedString>,
+
+    pub is_experiment_active: Option<bool>,
+
+    pub details: &'a EvaluationDetails,
+}
+
+impl<'a> ExperimentRaw<'a> {
+    pub fn empty(name: &'a str, details: &'a EvaluationDetails) -> Self {
+        Self {
+            name,
+            value: None,
+            details,
+            rule_id: None,
+            id_type: None,
+            group_name: None,
+            is_experiment_active: None,
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct LayerRaw<'a> {
+    pub name: &'a str,
+
+    #[serde(rename = "ruleID")]
+    pub rule_id: Option<&'a InternedString>,
+
+    pub id_type: Option<&'a InternedString>,
+
+    pub group_name: Option<&'a InternedString>,
+
+    pub is_experiment_active: Option<bool>,
+
+    pub allocated_experiment_name: Option<&'a InternedString>,
+
+    pub details: &'a EvaluationDetails,
+}
+
+impl<'a> LayerRaw<'a> {
+    pub fn empty(name: &'a str, details: &'a EvaluationDetails) -> Self {
+        Self {
+            name,
+            details,
+            rule_id: None,
+            id_type: None,
+            group_name: None,
+            is_experiment_active: None,
+            allocated_experiment_name: None,
+        }
+    }
+}

{statsig_python_core-0.13.0 → statsig_python_core-0.13.1b2512030239}/statsig-rust/tests/statsig_event_emitter_usage_test.rs

@@ -53,6 +53,7 @@ fn setup(sdk_key: &str) -> (Statsig, StatsigUser, mpsc::Receiver<ReceivedEvent>)
                 reason,
                 rule_id: _,
                 value: _,
+                group_name: _,
             } => {
                 result.data =
                     EventData::Evaluation(experiment_name.to_string(), reason.to_string());