statsig-python-core 0.11.0__tar.gz → 0.11.1b2510290239__tar.gz

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/Cargo.lock

@@ -2374,7 +2374,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2438,7 +2438,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "statsig-node"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "async-trait",
  "napi",
@@ -2452,7 +2452,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2466,7 +2466,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -2507,7 +2507,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "parking_lot",
  "rustler",
@@ -2519,7 +2519,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.11.0"
+version = "0.11.1-beta.2510290239"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/Cargo.toml

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

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.11.0
+Version: 0.11.1b2510290239
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/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.11.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.11.1-beta.2510290239", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/__tests__/spec_store_tests.rs

@@ -6,6 +6,7 @@ use parking_lot::Mutex;
 use crate::{
     data_store_interface::{DataStoreResponse, DataStoreTrait, RequestPath},
     networking::ResponseData,
+    sdk_event_emitter::SdkEventEmitter,
     SpecStore, SpecsSource, SpecsUpdate, StatsigErr, StatsigRuntime,
 };
 
@@ -65,6 +66,7 @@ async fn test_spec_store_data_store_updates_forwarded_to_data_store() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         Some(data_store.clone()),
     );
 
@@ -97,6 +99,7 @@ fn test_failure_to_update() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         None,
     );
 
@@ -116,6 +119,7 @@ fn test_no_updates() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         None,
     );
 

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/networking/network_client.rs

@@ -13,7 +13,14 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Weak};
 use std::time::Duration;
 
-const NON_RETRY_CODES: [u16; 4] = [400, 403, 405, 501];
+const NON_RETRY_CODES: [u16; 6] = [
+    400, // Bad Request
+    403, // Forbidden
+    413, // Payload Too Large
+    405, // Method Not Allowed
+    429, // Too Many Requests
+    501, // Not Implemented
+];
 const SHUTDOWN_ERROR: &str = "Request was aborted because the client is shutting down";
 
 const TAG: &str = stringify!(NetworkClient);

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/sdk_event_emitter/event_types.rs

@@ -1,4 +1,8 @@
-use crate::statsig_types::{DynamicConfig, Experiment, Layer};
+use crate::{
+    specs_response::spec_types::SpecsResponseFull,
+    statsig_types::{DynamicConfig, Experiment, Layer},
+    SpecsSource,
+};
 use serde::Serialize;
 use serde_json::json;
 use std::borrow::Cow;
@@ -12,6 +16,7 @@ pub enum SdkEventCode {
     DynamicConfigEvaluated = 3,
     ExperimentEvaluated = 4,
     LayerEvaluated = 5,
+    SpecsUpdated = 6,
 }
 
 impl SdkEventCode {
@@ -22,6 +27,7 @@ impl SdkEventCode {
             SdkEvent::DYNAMIC_CONFIG_EVALUATED => SdkEventCode::DynamicConfigEvaluated,
             SdkEvent::EXPERIMENT_EVALUATED => SdkEventCode::ExperimentEvaluated,
             SdkEvent::LAYER_EVALUATED => SdkEventCode::LayerEvaluated,
+            SdkEvent::SPECS_UPDATED => SdkEventCode::SpecsUpdated,
             _ => SdkEventCode::Unknown,
         }
     }
@@ -33,6 +39,11 @@ impl SdkEventCode {
 
 #[derive(Serialize, Clone)]
 pub enum SdkEvent<'a> {
+    SpecsUpdated {
+        source: &'a SpecsSource,
+        source_api: &'a Option<String>,
+        values: &'a SpecsResponseFull,
+    },
     GateEvaluated {
         gate_name: Cow<'a, str>,
         rule_id: Cow<'a, str>,
@@ -56,6 +67,7 @@ impl SdkEvent<'_> {
     pub const DYNAMIC_CONFIG_EVALUATED: &'static str = "dynamic_config_evaluated";
     pub const EXPERIMENT_EVALUATED: &'static str = "experiment_evaluated";
     pub const LAYER_EVALUATED: &'static str = "layer_evaluated";
+    pub const SPECS_UPDATED: &'static str = "specs_updated";
 
     pub fn get_code(&self) -> SdkEventCode {
         match self {
@@ -63,6 +75,7 @@ impl SdkEvent<'_> {
             SdkEvent::DynamicConfigEvaluated { .. } => SdkEventCode::DynamicConfigEvaluated,
             SdkEvent::ExperimentEvaluated { .. } => SdkEventCode::ExperimentEvaluated,
             SdkEvent::LayerEvaluated { .. } => SdkEventCode::LayerEvaluated,
+            SdkEvent::SpecsUpdated { .. } => SdkEventCode::SpecsUpdated,
         }
     }
 
@@ -73,6 +86,7 @@ impl SdkEvent<'_> {
             SdkEventCode::DynamicConfigEvaluated => SdkEvent::DYNAMIC_CONFIG_EVALUATED,
             SdkEventCode::ExperimentEvaluated => SdkEvent::EXPERIMENT_EVALUATED,
             SdkEventCode::LayerEvaluated => SdkEvent::LAYER_EVALUATED,
+            SdkEventCode::SpecsUpdated => SdkEvent::SPECS_UPDATED,
             SdkEventCode::Unknown => "unknown",
         }
     }
@@ -103,6 +117,15 @@ impl SdkEvent<'_> {
             SdkEvent::LayerEvaluated { layer } => {
                 map.insert("layer".to_string(), json!(layer));
             }
+            SdkEvent::SpecsUpdated {
+                source,
+                source_api,
+                values,
+            } => {
+                map.insert("source".to_string(), json!(source));
+                map.insert("source_api".to_string(), json!(source_api));
+                map.insert("values".to_string(), json!(values));
+            }
         }
 
         map

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/spec_store.rs

@@ -5,6 +5,7 @@ use crate::networking::ResponseData;
 use crate::observability::observability_client_adapter::{MetricType, ObservabilityEvent};
 use crate::observability::ops_stats::{OpsStatsForInstance, OPS_STATS};
 use crate::observability::sdk_errors_observer::ErrorBoundaryEvent;
+use crate::sdk_event_emitter::{SdkEvent, SdkEventEmitter};
 use crate::specs_response::spec_types::{SpecsResponseFull, SpecsResponseNoUpdates};
 use crate::utils::maybe_trim_malloc;
 use crate::{
@@ -36,6 +37,7 @@ pub struct SpecStore {
     statsig_runtime: Arc<StatsigRuntime>,
     ops_stats: Arc<OpsStatsForInstance>,
     global_configs: Arc<GlobalConfigs>,
+    event_emitter: Arc<SdkEventEmitter>,
 }
 
 impl SpecStore {
@@ -44,6 +46,7 @@ impl SpecStore {
         sdk_key: &str,
         hashed_sdk_key: String,
         statsig_runtime: Arc<StatsigRuntime>,
+        event_emitter: Arc<SdkEventEmitter>,
         data_store: Option<Arc<dyn DataStoreTrait>>,
     ) -> SpecStore {
         SpecStore {
@@ -56,6 +59,7 @@ impl SpecStore {
                 source_api: None,
                 id_lists: HashMap::new(),
             })),
+            event_emitter,
             data_store,
             statsig_runtime,
             ops_stats: OPS_STATS.get_for_instance(sdk_key),
@@ -189,6 +193,9 @@ impl SpecStore {
 
                 data.time_received_at = Some(now);
                 data.source_api = source_api;
+
+                self.emit_specs_updated_sdk_event(&data.source, &data.source_api, &data.values);
+
                 Ok((prev_source, prev_lcut, data.values.time))
             }
             None => {
@@ -200,6 +207,19 @@ impl SpecStore {
         }
     }
 
+    fn emit_specs_updated_sdk_event(
+        &self,
+        source: &SpecsSource,
+        source_api: &Option<String>,
+        values: &SpecsResponseFull,
+    ) {
+        self.event_emitter.emit(SdkEvent::SpecsUpdated {
+            source,
+            source_api,
+            values,
+        });
+    }
+
     fn ops_stats_log_no_update(&self, source: SpecsSource, source_api: Option<String>) {
         log_d!(TAG, "No Updates");
         self.ops_stats.log(ObservabilityEvent::new_event(

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/statsig.rs

@@ -83,7 +83,7 @@ lazy_static::lazy_static! {
 pub struct Statsig {
     pub statsig_runtime: Arc<StatsigRuntime>,
     pub options: Arc<StatsigOptions>,
-    pub event_emitter: SdkEventEmitter,
+    pub event_emitter: Arc<SdkEventEmitter>,
 
     sdk_key: String,
     event_logger: Arc<EventLogger>,
@@ -167,10 +167,13 @@ impl Statsig {
             &options.observability_client,
         );
 
+        let event_emitter = Arc::new(SdkEventEmitter::default());
+
         let spec_store = Arc::new(SpecStore::new(
             sdk_key,
             hashing.sha256(sdk_key),
             statsig_runtime.clone(),
+            event_emitter.clone(),
             options.data_store.clone(),
         ));
 
@@ -206,7 +209,7 @@ impl Statsig {
             background_tasks_started: Arc::new(AtomicBool::new(false)),
             persistent_values_manager,
             initialize_details: Mutex::new(InitializeDetails::default()),
-            event_emitter: SdkEventEmitter::default(),
+            event_emitter,
         }
     }
 

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/src/statsig_metadata.rs

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

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510290239}/statsig-rust/tests/global_configs_test.rs

@@ -1,6 +1,6 @@
 use statsig_rust::{
-    global_configs::GlobalConfigs, networking::ResponseData, SpecStore, SpecsSource, SpecsUpdate,
-    StatsigRuntime,
+    global_configs::GlobalConfigs, networking::ResponseData, sdk_event_emitter::SdkEventEmitter,
+    SpecStore, SpecsSource, SpecsUpdate, StatsigRuntime,
 };
 use std::fs;
 
@@ -9,6 +9,7 @@ fn create_test_spec_store(sdk_key: &str) -> SpecStore {
         sdk_key,
         sdk_key.to_string(),
         StatsigRuntime::get_runtime(),
+        std::sync::Arc::new(SdkEventEmitter::default()),
         None,
     )
 }

statsig_python_core-0.11.1b2510290239/statsig-rust/tests/statsig_event_emitter_usage_test.rs

@@ -0,0 +1,156 @@
+mod utils;
+
+use crate::utils::mock_specs_adapter::MockSpecsAdapter;
+use statsig_rust::{sdk_event_emitter::SdkEvent, Statsig, StatsigOptions, StatsigUser};
+use std::{
+    sync::{mpsc, Arc},
+    time::Duration,
+};
+
+#[derive(Debug, PartialEq)]
+enum EventData {
+    Evaluation(String, String),
+    SpecsUpdated(String, u64),
+}
+
+struct ReceivedEvent {
+    event_name: String,
+    data: EventData,
+}
+
+fn setup(sdk_key: &str) -> (Statsig, StatsigUser, mpsc::Receiver<ReceivedEvent>) {
+    let specs_adapter = Arc::new(MockSpecsAdapter::with_data("tests/data/eval_proj_dcs.json"));
+    let options = StatsigOptions {
+        specs_adapter: Some(specs_adapter),
+        ..StatsigOptions::default()
+    };
+    let statsig = Statsig::new(sdk_key, Some(Arc::new(options)));
+    let (tx, rx) = mpsc::channel::<ReceivedEvent>();
+    let user = StatsigUser::with_user_id("a_user".to_string());
+
+    statsig.subscribe(SdkEvent::ALL, move |event| {
+        let mut result = ReceivedEvent {
+            event_name: event.get_name().to_string(),
+            data: EventData::Evaluation(String::new(), String::new()),
+        };
+
+        match event {
+            SdkEvent::GateEvaluated {
+                gate_name, reason, ..
+            } => {
+                result.data = EventData::Evaluation(gate_name.to_string(), reason.to_string());
+            }
+            SdkEvent::DynamicConfigEvaluated { dynamic_config } => {
+                result.data = EventData::Evaluation(
+                    dynamic_config.name.to_string(),
+                    dynamic_config.details.reason.to_string(),
+                );
+            }
+            SdkEvent::ExperimentEvaluated { experiment } => {
+                result.data = EventData::Evaluation(
+                    experiment.name.to_string(),
+                    experiment.details.reason.to_string(),
+                );
+            }
+            SdkEvent::LayerEvaluated { layer } => {
+                result.data =
+                    EventData::Evaluation(layer.name.to_string(), layer.details.reason.to_string());
+            }
+            SdkEvent::SpecsUpdated {
+                source,
+                source_api: _,
+                values,
+            } => {
+                result.data = EventData::SpecsUpdated(source.to_string(), values.time);
+            }
+        }
+
+        tx.send(result).unwrap();
+    });
+
+    (statsig, user, rx)
+}
+
+#[tokio::test]
+async fn test_gate_evaluated_event_for_check_gate() {
+    let (statsig, user, rx) = setup("secret-check_gate");
+
+    statsig.check_gate(&user, "test_gate");
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "gate_evaluated");
+    assert_eq!(
+        event.data,
+        EventData::Evaluation("test_gate".to_string(), "Uninitialized".to_string())
+    );
+}
+
+#[tokio::test]
+async fn test_gate_evaluated_event_for_get_feature_gate() {
+    let (statsig, user, rx) = setup("secret-get_feature_gate");
+
+    statsig.get_feature_gate(&user, "test_gate");
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "gate_evaluated");
+    assert_eq!(
+        event.data,
+        EventData::Evaluation("test_gate".to_string(), "Uninitialized".to_string())
+    );
+}
+
+#[tokio::test]
+async fn test_dynamic_config_evaluated_event() {
+    let (statsig, user, rx) = setup("secret-get_dynamic_config");
+
+    statsig.get_dynamic_config(&user, "test_config");
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "dynamic_config_evaluated");
+    assert_eq!(
+        event.data,
+        EventData::Evaluation("test_config".to_string(), "Uninitialized".to_string())
+    );
+}
+
+#[tokio::test]
+async fn test_experiment_evaluated_event() {
+    let (statsig, user, rx) = setup("secret-get_experiment");
+
+    statsig.get_experiment(&user, "test_experiment");
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "experiment_evaluated");
+    assert_eq!(
+        event.data,
+        EventData::Evaluation("test_experiment".to_string(), "Uninitialized".to_string())
+    );
+}
+
+#[tokio::test]
+async fn test_layer_evaluated_event() {
+    let (statsig, user, rx) = setup("secret-get_layer");
+
+    statsig.get_layer(&user, "test_layer");
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "layer_evaluated");
+    assert_eq!(
+        event.data,
+        EventData::Evaluation("test_layer".to_string(), "Uninitialized".to_string())
+    );
+}
+
+#[tokio::test]
+async fn test_specs_updated_event() {
+    let (statsig, _, rx) = setup("secret-get_specs_updated");
+
+    statsig.initialize().await.unwrap();
+
+    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
+    assert_eq!(event.event_name, "specs_updated");
+    assert_eq!(
+        event.data,
+        EventData::SpecsUpdated("Bootstrap".to_string(), 1729873603830)
+    );
+}

statsig_python_core-0.11.0/statsig-rust/tests/statsig_event_emitter_usage_test.rs

@@ -1,107 +0,0 @@
-use statsig_rust::{sdk_event_emitter::SdkEvent, Statsig, StatsigUser};
-use std::{sync::mpsc, time::Duration};
-
-struct ReceivedEvent {
-    event_name: String,
-    spec_name: String,
-    eval_reason: String,
-}
-
-fn setup(sdk_key: &str) -> (Statsig, StatsigUser, mpsc::Receiver<ReceivedEvent>) {
-    let statsig = Statsig::new(sdk_key, None);
-    let (tx, rx) = mpsc::channel::<ReceivedEvent>();
-    let user = StatsigUser::with_user_id("a_user".to_string());
-
-    statsig.subscribe(SdkEvent::ALL, move |event| {
-        let mut result = ReceivedEvent {
-            event_name: event.get_name().to_string(),
-            spec_name: String::new(),
-            eval_reason: String::new(),
-        };
-
-        match event {
-            SdkEvent::GateEvaluated {
-                gate_name, reason, ..
-            } => {
-                result.spec_name = gate_name.to_string();
-                result.eval_reason = reason.to_string();
-            }
-            SdkEvent::DynamicConfigEvaluated { dynamic_config } => {
-                result.spec_name = dynamic_config.name.to_string();
-                result.eval_reason = dynamic_config.details.reason.to_string();
-            }
-            SdkEvent::ExperimentEvaluated { experiment } => {
-                result.spec_name = experiment.name.to_string();
-                result.eval_reason = experiment.details.reason.to_string();
-            }
-            SdkEvent::LayerEvaluated { layer } => {
-                result.spec_name = layer.name.to_string();
-                result.eval_reason = layer.details.reason.to_string();
-            }
-        }
-
-        tx.send(result).unwrap();
-    });
-
-    (statsig, user, rx)
-}
-
-#[tokio::test]
-async fn test_gate_evaluated_event_for_check_gate() {
-    let (statsig, user, rx) = setup("secret-check_gate");
-
-    statsig.check_gate(&user, "test_gate");
-
-    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
-    assert_eq!(event.event_name, "gate_evaluated");
-    assert_eq!(event.spec_name, "test_gate");
-    assert_eq!(event.eval_reason, "Uninitialized");
-}
-
-#[tokio::test]
-async fn test_gate_evaluated_event_for_get_feature_gate() {
-    let (statsig, user, rx) = setup("secret-get_feature_gate");
-
-    statsig.get_feature_gate(&user, "test_gate");
-
-    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
-    assert_eq!(event.event_name, "gate_evaluated");
-    assert_eq!(event.spec_name, "test_gate");
-    assert_eq!(event.eval_reason, "Uninitialized");
-}
-
-#[tokio::test]
-async fn test_dynamic_config_evaluated_event() {
-    let (statsig, user, rx) = setup("secret-get_dynamic_config");
-
-    statsig.get_dynamic_config(&user, "test_config");
-
-    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
-    assert_eq!(event.event_name, "dynamic_config_evaluated");
-    assert_eq!(event.spec_name, "test_config");
-    assert_eq!(event.eval_reason, "Uninitialized");
-}
-
-#[tokio::test]
-async fn test_experiment_evaluated_event() {
-    let (statsig, user, rx) = setup("secret-get_experiment");
-
-    statsig.get_experiment(&user, "test_experiment");
-
-    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
-    assert_eq!(event.event_name, "experiment_evaluated");
-    assert_eq!(event.spec_name, "test_experiment");
-    assert_eq!(event.eval_reason, "Uninitialized");
-}
-
-#[tokio::test]
-async fn test_layer_evaluated_event() {
-    let (statsig, user, rx) = setup("secret-get_layer");
-
-    statsig.get_layer(&user, "test_layer");
-
-    let event = rx.recv_timeout(Duration::from_secs(1)).unwrap();
-    assert_eq!(event.event_name, "layer_evaluated");
-    assert_eq!(event.spec_name, "test_layer");
-    assert_eq!(event.eval_reason, "Uninitialized");
-}