statsig-python-core 0.23.0__tar.gz → 0.23.1b2609160206__tar.gz

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/Cargo.lock

@@ -2987,7 +2987,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "async-trait",
  "chrono",
@@ -3079,7 +3079,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "async-trait",
  "napi",
@@ -3094,7 +3094,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3109,7 +3109,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3163,7 +3163,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3176,7 +3176,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/Cargo.toml

@@ -19,7 +19,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.23.0"
+version = "0.23.1-beta.2609160206"
 homepage = "https://statsig.com/"
 authors = ["Statsig"]
 readme = "README.md"

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.23.0
+Version: 0.23.1b2609160206
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/statsig-rust/Cargo.toml

@@ -44,7 +44,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.23.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.23.1-beta.2609160206", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/statsig-rust/src/event_logging/event_queue/queued_expo.rs

@@ -201,7 +201,12 @@ impl<'a> EnqueueExposureOp<'a> {
         if let Some(result) = result {
             data.exposure_info = Some(result_to_extra_exposure_info(&result));
 
-            data.rule_id = result.rule_id;
+            data.rule_id = match result.rule_id_suffix {
+                Some(suffix) => result.rule_id.as_ref().map(|rule_id| {
+                    InternedString::from_str_parts(&[rule_id.as_str(), ":", suffix])
+                }),
+                None => result.rule_id,
+            };
             data.version = result.version;
             data.override_spec_name = result.override_config_name;
             data.secondary_exposures = Some(result.secondary_exposures);

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/statsig-rust/src/statsig_global.rs

@@ -1,8 +1,8 @@
-use crate::log_d;
+use crate::{log_d, log_e};
 use arc_swap::ArcSwap;
 use parking_lot::Mutex;
 use std::sync::{Arc, OnceLock};
-use tokio::runtime::Runtime;
+use tokio::runtime::{Handle, Runtime};
 
 const TAG: &str = "StatsigGlobal";
 
@@ -40,6 +40,29 @@ impl StatsigGlobal {
         ptr.store(Arc::new(StatsigGlobal::new()));
     }
 
+    /// Stops the shared tokio runtime, joining its worker threads.
+    ///
+    /// Per-instance shutdown deliberately leaves the shared runtime running so
+    /// later instances can reuse it. Callers that unload this library while the
+    /// process keeps running need those threads gone first, and this is the
+    /// only thing that stops them.
+    ///
+    /// Returns false without resetting when called from a runtime thread.
+    /// Dropping a runtime from inside itself panics, and binding teardown can
+    /// reach this from one, so the guard lives here rather than in callers.
+    pub fn shutdown_shared_runtime() -> bool {
+        if Handle::try_current().is_ok() {
+            log_e!(
+                TAG,
+                "Refusing to shut down the shared runtime from inside a runtime thread"
+            );
+            return false;
+        }
+
+        Self::reset();
+        true
+    }
+
     fn new() -> Self {
         Self {
             tokio_runtime: Mutex::new(None),

{statsig_python_core-0.23.0 → statsig_python_core-0.23.1b2609160206}/statsig-rust/src/statsig_metadata.rs

@@ -10,7 +10,7 @@ lazy_static! {
     static ref STATSIG_METADATA: RwLock<StatsigMetadata> = RwLock::new(StatsigMetadata::new());
 }
 
-pub const SDK_VERSION: &str = "0.23.0";
+pub const SDK_VERSION: &str = "0.23.1-beta.2609160206";
 
 const TAG: &str = stringify!(StatsigMetadata);
 

statsig_python_core-0.23.1b2609160206/statsig-rust/tests/cmab_exposure_rule_id_tests.rs

@@ -0,0 +1,86 @@
+mod utils;
+
+use std::sync::Arc;
+
+#[cfg(feature = "ffi-support")]
+use serde_json::Value;
+#[cfg(feature = "ffi-support")]
+use statsig_rust::ExperimentEvaluationOptions;
+use statsig_rust::{Statsig, StatsigOptions, StatsigUser};
+use utils::{
+    mock_event_logging_adapter::MockEventLoggingAdapter, mock_specs_adapter::MockSpecsAdapter,
+};
+
+const DCS_PATH: &str = "tests/data/dcs_cmab_exposure_rule_id.json";
+
+async fn setup() -> (Statsig, Arc<MockEventLoggingAdapter>) {
+    let event_logging_adapter = Arc::new(MockEventLoggingAdapter::new());
+    let mut options = StatsigOptions::new();
+    options.specs_adapter = Some(Arc::new(MockSpecsAdapter::with_data(DCS_PATH)));
+    options.event_logging_adapter = Some(event_logging_adapter.clone());
+
+    let statsig = Statsig::new("secret-cmab-rule-id-test", Some(Arc::new(options)));
+    statsig.initialize().await.unwrap();
+
+    (statsig, event_logging_adapter)
+}
+
+fn get_logged_rule_id(adapter: &MockEventLoggingAdapter) -> String {
+    adapter.force_get_first_event()["metadata"]["ruleID"]
+        .as_str()
+        .unwrap()
+        .to_string()
+}
+
+#[tokio::test]
+async fn typed_cmab_exposure_preserves_explore_suffix() {
+    let (statsig, adapter) = setup().await;
+    let user = StatsigUser::with_user_id("typed-explore-user".to_string());
+
+    let experiment = statsig.get_experiment(&user, "cmab_always_explore");
+    let returned_rule_id = experiment.rule_id.clone();
+    statsig.shutdown().await.unwrap();
+
+    assert!(returned_rule_id.ends_with(":explore"));
+    assert_eq!(get_logged_rule_id(&adapter), returned_rule_id);
+}
+
+#[tokio::test]
+#[cfg(feature = "ffi-support")]
+async fn raw_ffi_cmab_exposure_preserves_explore_suffix() {
+    let (statsig, adapter) = setup().await;
+    let user = StatsigUser::with_user_id("raw-explore-user".to_string());
+
+    let raw_json = statsig.use_raw_experiment_with_options(
+        &user,
+        "cmab_always_explore",
+        ExperimentEvaluationOptions::default(),
+        |raw| raw.unperformant_to_json_string(),
+    );
+    let raw: Value = serde_json::from_str(&raw_json).unwrap();
+    let returned_rule_id = raw["ruleID"].as_str().unwrap().to_string();
+    statsig.shutdown().await.unwrap();
+
+    assert!(returned_rule_id.ends_with(":explore"));
+    assert_eq!(get_logged_rule_id(&adapter), returned_rule_id);
+}
+
+#[tokio::test]
+#[cfg(feature = "ffi-support")]
+async fn raw_ffi_cmab_exploit_rule_id_remains_bare() {
+    let (statsig, adapter) = setup().await;
+    let user = StatsigUser::with_user_id("raw-exploit-user".to_string());
+
+    let raw_json = statsig.use_raw_experiment_with_options(
+        &user,
+        "cmab_never_explore",
+        ExperimentEvaluationOptions::default(),
+        |raw| raw.unperformant_to_json_string(),
+    );
+    let raw: Value = serde_json::from_str(&raw_json).unwrap();
+    let returned_rule_id = raw["ruleID"].as_str().unwrap().to_string();
+    statsig.shutdown().await.unwrap();
+
+    assert_eq!(returned_rule_id, "treatment-group-id");
+    assert_eq!(get_logged_rule_id(&adapter), returned_rule_id);
+}

statsig_python_core-0.23.1b2609160206/statsig-rust/tests/data/dcs_cmab_exposure_rule_id.json

@@ -0,0 +1,86 @@
+{
+  "dynamic_configs": {},
+  "feature_gates": {},
+  "layer_configs": {},
+  "cmab_configs": {
+    "cmab_always_explore": {
+      "salt": "cmab-always-explore-salt",
+      "defaultValue": {"arm": "default"},
+      "idType": "userID",
+      "enabled": true,
+      "version": 1,
+      "sampleRate": 1.0,
+      "higherIsBetter": true,
+      "groups": [
+        {
+          "name": "control",
+          "parameterValues": {"arm": "control"},
+          "id": "control-group-id"
+        },
+        {
+          "name": "treatment",
+          "parameterValues": {"arm": "treatment"},
+          "id": "treatment-group-id"
+        }
+      ],
+      "config": {
+        "control-group-id": {
+          "alpha": 1.0,
+          "intercept": 0.0,
+          "records": 1,
+          "weightsNumerical": {"unused": 0.0},
+          "weightsCategorical": {}
+        },
+        "treatment-group-id": {
+          "alpha": 1.0,
+          "intercept": 1.0,
+          "records": 1,
+          "weightsNumerical": {"unused": 0.0},
+          "weightsCategorical": {}
+        }
+      }
+    },
+    "cmab_never_explore": {
+      "salt": "cmab-never-explore-salt",
+      "defaultValue": {"arm": "default"},
+      "idType": "userID",
+      "enabled": true,
+      "version": 1,
+      "sampleRate": 0.0,
+      "higherIsBetter": true,
+      "groups": [
+        {
+          "name": "control",
+          "parameterValues": {"arm": "control"},
+          "id": "control-group-id"
+        },
+        {
+          "name": "treatment",
+          "parameterValues": {"arm": "treatment"},
+          "id": "treatment-group-id"
+        }
+      ],
+      "config": {
+        "control-group-id": {
+          "alpha": 1.0,
+          "intercept": 0.0,
+          "records": 1,
+          "weightsNumerical": {"unused": 0.0},
+          "weightsCategorical": {}
+        },
+        "treatment-group-id": {
+          "alpha": 1.0,
+          "intercept": 1.0,
+          "records": 1,
+          "weightsNumerical": {"unused": 0.0},
+          "weightsCategorical": {}
+        }
+      }
+    }
+  },
+  "condition_map": {},
+  "experiment_to_layer": {},
+  "param_stores": {},
+  "time": 1,
+  "has_updates": true
+}

statsig_python_core-0.23.1b2609160206/statsig-rust/tests/statsig_global_tests.rs

@@ -0,0 +1,236 @@
+use serial_test::serial;
+use statsig_rust::{statsig_global::StatsigGlobal, StatsigRuntime};
+use std::collections::HashSet;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc;
+use std::thread::ThreadId;
+use std::time::{Duration, Instant};
+
+fn is_runtime_none() -> bool {
+    let global = StatsigGlobal::get();
+    let rt = &global.tokio_runtime;
+    let lock_result = rt.try_lock().expect("Failed to lock tokio runtime");
+    lock_result.is_none()
+}
+
+fn is_runtime_some() -> bool {
+    let global = StatsigGlobal::get();
+    let rt = &global.tokio_runtime;
+    let lock_result = rt.try_lock().expect("Failed to lock tokio runtime");
+    lock_result.is_some()
+}
+
+static WORKERS_EXITED: AtomicUsize = AtomicUsize::new(0);
+
+struct ExitRecorder;
+
+impl Drop for ExitRecorder {
+    fn drop(&mut self) {
+        WORKERS_EXITED.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+thread_local! {
+    /// Initialized on every worker thread that runs a task below, so each one
+    /// reports itself when it exits. Portable stand-in for counting OS threads.
+    static EXIT_RECORDER: ExitRecorder = const { ExitRecorder };
+}
+
+/// Runs work on the shared runtime until every worker thread has been used,
+/// and returns the set of threads that ran it. Each of those threads now has
+/// an `ExitRecorder` that fires when the thread terminates.
+fn occupy_worker_threads(runtime: &StatsigRuntime) -> HashSet<ThreadId> {
+    let handle = runtime.get_handle().expect("Failed to get runtime handle");
+    let (tx, rx) = mpsc::channel::<ThreadId>();
+
+    for _ in 0..40 {
+        let tx = tx.clone();
+        handle.spawn(async move {
+            EXIT_RECORDER.with(|_| {});
+            let _ = tx.send(std::thread::current().id());
+            // Hold the worker so the pool spreads the remaining tasks around.
+            std::thread::sleep(Duration::from_millis(20));
+        });
+    }
+    drop(tx);
+
+    let mut threads = HashSet::new();
+    while let Ok(id) = rx.recv_timeout(Duration::from_secs(10)) {
+        threads.insert(id);
+    }
+
+    threads
+}
+
+fn wait_for(timeout: Duration, condition: impl Fn() -> bool) -> bool {
+    let deadline = Instant::now() + timeout;
+    while Instant::now() < deadline {
+        if condition() {
+            return true;
+        }
+        std::thread::sleep(Duration::from_millis(10));
+    }
+    condition()
+}
+
+#[test]
+#[serial]
+fn test_get_runtime() {
+    let global = StatsigGlobal::get();
+    let global_again = StatsigGlobal::get();
+
+    assert_eq!(global.pid, global_again.pid);
+}
+
+#[test]
+#[serial]
+fn test_fork_resetting_runtime() {
+    let global = StatsigGlobal::get();
+    let original_pid = global.pid;
+
+    assert!(is_runtime_none());
+
+    let original_rt = StatsigRuntime::get_runtime();
+    assert_eq!(original_pid, std::process::id());
+
+    original_rt
+        .spawn("test", |_| async {
+            tokio::time::sleep(Duration::from_secs(5)).await;
+        })
+        .unwrap();
+
+    assert!(is_runtime_some());
+
+    let pid = unsafe { libc::fork() };
+    if pid == 0 {
+        let child_global = StatsigGlobal::get();
+        assert_ne!(child_global.pid, original_pid);
+
+        assert!(is_runtime_none());
+
+        let child_rt = StatsigRuntime::get_runtime();
+        child_rt
+            .spawn("test", |_| async {
+                tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+            })
+            .unwrap();
+
+        assert!(is_runtime_some());
+
+        std::process::exit(0);
+    }
+
+    let global = StatsigGlobal::get();
+    assert_eq!(global.pid, original_pid);
+
+    unsafe {
+        let mut status: i32 = 0;
+        libc::waitpid(pid, &mut status, 0);
+        assert_eq!(libc::WEXITSTATUS(status), 0);
+    };
+
+    let another_rt = StatsigRuntime::get_runtime();
+    another_rt.shutdown();
+    drop(another_rt);
+
+    assert!(
+        is_runtime_some(),
+        "Per-instance shutdown must leave the shared runtime for the next instance. \
+         StatsigGlobal::shutdown_shared_runtime is what stops it."
+    );
+
+    StatsigGlobal::shutdown_shared_runtime();
+}
+
+#[test]
+#[serial]
+fn test_shutdown_shared_runtime_stops_worker_threads() {
+    StatsigGlobal::shutdown_shared_runtime();
+    WORKERS_EXITED.store(0, Ordering::SeqCst);
+
+    let rt = StatsigRuntime::get_runtime();
+    let workers = occupy_worker_threads(&rt);
+
+    assert!(
+        !workers.is_empty(),
+        "No worker threads ran, so nothing was observed"
+    );
+    assert_eq!(
+        WORKERS_EXITED.load(Ordering::SeqCst),
+        0,
+        "Worker threads exited while the runtime was still in use"
+    );
+
+    // The most complete teardown a binding can do per instance.
+    rt.shutdown();
+    drop(rt);
+
+    assert!(
+        !wait_for(Duration::from_millis(500), || WORKERS_EXITED
+            .load(Ordering::SeqCst)
+            > 0),
+        "Per-instance shutdown stopped shared worker threads. \
+         Bindings rely on the shared runtime surviving it."
+    );
+    assert!(is_runtime_some());
+
+    // This is what a binding must call before the library is unloaded. PHP
+    // unloads it at the end of every request, and on Windows that unmaps the
+    // module while these threads are still running inside it.
+    assert!(StatsigGlobal::shutdown_shared_runtime());
+
+    assert!(
+        wait_for(Duration::from_secs(5), || WORKERS_EXITED
+            .load(Ordering::SeqCst)
+            >= workers.len()),
+        "Only {} of {} worker threads exited. Threads that outlive the library \
+         fault when the module is unmapped.",
+        WORKERS_EXITED.load(Ordering::SeqCst),
+        workers.len()
+    );
+    assert!(is_runtime_none());
+}
+
+#[test]
+#[serial]
+fn test_shutdown_shared_runtime_is_idempotent_and_safe_when_unused() {
+    StatsigGlobal::shutdown_shared_runtime();
+
+    // Never initialized, and repeated calls.
+    assert!(StatsigGlobal::shutdown_shared_runtime());
+    assert!(StatsigGlobal::shutdown_shared_runtime());
+    assert!(is_runtime_none());
+
+    let rt = StatsigRuntime::get_runtime();
+    assert!(is_runtime_some());
+    drop(rt);
+
+    assert!(StatsigGlobal::shutdown_shared_runtime());
+    assert!(StatsigGlobal::shutdown_shared_runtime());
+    assert!(is_runtime_none());
+}
+
+#[test]
+#[serial]
+fn test_shutdown_shared_runtime_refuses_from_inside_a_runtime_thread() {
+    StatsigGlobal::shutdown_shared_runtime();
+
+    let rt = StatsigRuntime::get_runtime();
+    let handle = rt.get_handle().expect("Failed to get runtime handle");
+
+    // Dropping a runtime from inside itself panics. PHP's teardown made this
+    // reachable, so the guard has to hold rather than relying on callers.
+    let reset_from_worker = handle.block_on(async { StatsigGlobal::shutdown_shared_runtime() });
+
+    assert!(
+        !reset_from_worker,
+        "Shared runtime was reset from inside a runtime thread"
+    );
+    assert!(
+        is_runtime_some(),
+        "The runtime was dropped from inside itself"
+    );
+
+    drop(rt);
+    StatsigGlobal::shutdown_shared_runtime();
+}

statsig_python_core-0.23.0/statsig-rust/tests/statsig_global_tests.rs

@@ -1,80 +0,0 @@
-use serial_test::serial;
-use statsig_rust::{statsig_global::StatsigGlobal, StatsigRuntime};
-use std::time::Duration;
-
-fn is_runtime_none() -> bool {
-    let global = StatsigGlobal::get();
-    let rt = &global.tokio_runtime;
-    let lock_result = rt.try_lock().expect("Failed to lock tokio runtime");
-    lock_result.is_none()
-}
-
-fn is_runtime_some() -> bool {
-    let global = StatsigGlobal::get();
-    let rt = &global.tokio_runtime;
-    let lock_result = rt.try_lock().expect("Failed to lock tokio runtime");
-    lock_result.is_some()
-}
-
-#[test]
-#[serial]
-fn test_get_runtime() {
-    let global = StatsigGlobal::get();
-    let global_again = StatsigGlobal::get();
-
-    assert_eq!(global.pid, global_again.pid);
-}
-
-#[test]
-#[serial]
-fn test_fork_resetting_runtime() {
-    let global = StatsigGlobal::get();
-    let original_pid = global.pid;
-
-    assert!(is_runtime_none());
-
-    let original_rt = StatsigRuntime::get_runtime();
-    assert_eq!(original_pid, std::process::id());
-
-    original_rt
-        .spawn("test", |_| async {
-            tokio::time::sleep(Duration::from_secs(5)).await;
-        })
-        .unwrap();
-
-    assert!(is_runtime_some());
-
-    let pid = unsafe { libc::fork() };
-    if pid == 0 {
-        let child_global = StatsigGlobal::get();
-        assert_ne!(child_global.pid, original_pid);
-
-        assert!(is_runtime_none());
-
-        let child_rt = StatsigRuntime::get_runtime();
-        child_rt
-            .spawn("test", |_| async {
-                tokio::time::sleep(std::time::Duration::from_secs(5)).await;
-            })
-            .unwrap();
-
-        assert!(is_runtime_some());
-
-        std::process::exit(0);
-    }
-
-    let global = StatsigGlobal::get();
-    assert_eq!(global.pid, original_pid);
-
-    unsafe {
-        let mut status: i32 = 0;
-        libc::waitpid(pid, &mut status, 0);
-        assert_eq!(libc::WEXITSTATUS(status), 0);
-    };
-
-    let another_rt = StatsigRuntime::get_runtime();
-    another_rt.shutdown();
-    drop(another_rt);
-
-    assert!(is_runtime_some(), "The runtime should not be dropped");
-}