statsig-python-core 0.19.5rc2606050349__tar.gz → 0.19.6__tar.gz

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/Cargo.lock

@@ -2902,7 +2902,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2994,7 +2994,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "async-trait",
  "napi",
@@ -3009,7 +3009,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3024,7 +3024,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3075,7 +3075,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3088,7 +3088,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/Cargo.toml

@@ -19,7 +19,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.19.5-rc.2606050349"
+version = "0.19.6"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.19.5rc2606050349
+Version: 0.19.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/statsig-rust/Cargo.toml

@@ -41,7 +41,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.19.5-rc.2606050349", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.19.6", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/statsig-rust/src/event_logging/event_logger.rs

@@ -194,14 +194,37 @@ impl EventLogger {
         }
     }
 
-    pub async fn flush_all_pending_events(&self) -> Result<(), StatsigErr> {
+    pub async fn flush_all_pending_events(
+        &self,
+        statsig_rt: &Arc<StatsigRuntime>,
+    ) -> Result<(), StatsigErr> {
+        // Wait for any background limit-flush tasks that are already in flight.
+        // They dequeue their batch before the network call, so those events are
+        // no longer in the queue and would otherwise not be awaited by a manual
+        // flush. Without this, flush_events() can return while exposures are
+        // still being delivered (or, on shutdown, get aborted and dropped).
+        // Scheduled flushes run inline in the bg loop (not as LIMIT_FLUSH_TAG
+        // tasks), so a manual flush can still return while one is in flight;
+        // shutdown() stops and awaits the bg loop, covering flush-then-shutdown.
+        statsig_rt.await_tasks_with_tag(LIMIT_FLUSH_TAG).await;
+
         self.try_flush_all_pending_events(FlushType::Manual).await
     }
 
-    pub async fn shutdown(&self) -> Result<(), StatsigErr> {
-        let result = self.try_flush_all_pending_events(FlushType::Shutdown).await;
+    pub async fn shutdown(&self, statsig_rt: &Arc<StatsigRuntime>) -> Result<(), StatsigErr> {
+        // Stop the background loop so it won't spawn new limit-flush tasks while
+        // we are draining.
         self.shutdown_notify.notify_one();
-        result
+
+        // Wait for the background loop (which may be mid scheduled-flush) and any
+        // in-flight limit-flush tasks to finish before we let the runtime abort
+        // tasks. Each of these can hold a batch it already dequeued; aborting
+        // them mid network-request silently drops those exposures.
+        statsig_rt.await_tasks_with_tag(BG_LOOP_TAG).await;
+        statsig_rt.await_tasks_with_tag(LIMIT_FLUSH_TAG).await;
+
+        // Finally flush whatever remains in the queue.
+        self.try_flush_all_pending_events(FlushType::Shutdown).await
     }
 
     pub fn force_shutdown(&self) {

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/statsig-rust/src/statsig.rs

@@ -354,7 +354,7 @@ impl Statsig {
 
                 try_join!(
                     id_list_shutdown,
-                    self.event_logger.shutdown(),
+                    self.event_logger.shutdown(&self.statsig_runtime),
                     self.specs_adapter.inner.shutdown(timeout, &self.statsig_runtime),
                 )
             } => {
@@ -677,7 +677,10 @@ impl Statsig {
     }
 
     pub async fn flush_events(&self) {
-        let _ = self.event_logger.flush_all_pending_events().await;
+        let _ = self
+            .event_logger
+            .flush_all_pending_events(&self.statsig_runtime)
+            .await;
     }
 }
 

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/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.19.5-rc.2606050349";
+pub const SDK_VERSION: &str = "0.19.6";
 
 const TAG: &str = stringify!(StatsigMetadata);
 

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/statsig-rust/tests/event_logger_flush_tests.rs

@@ -78,6 +78,87 @@ async fn test_limit_flushing() {
     teardown(Some(statsig)).await;
 }
 
+#[tokio::test]
+#[serial]
+async fn test_shutdown_waits_for_inflight_limit_flush() {
+    let mut options = StatsigOptions::new();
+    options.event_logging_max_queue_size = Some(10);
+    options.event_logging_max_pending_batch_queue_size = Some(60);
+
+    let (statsig, logging_adapter, _) = setup(options).await;
+
+    // Drain any events queued during initialization (e.g. diagnostics) so the
+    // queue is empty before we set up the in-flight scenario.
+    statsig.flush_events().await;
+    logging_adapter
+        .no_diagnostics_logged_event_count
+        .store(0, Ordering::SeqCst);
+
+    // Make the network call slow so the background limit-flush task is still
+    // in flight (it has already dequeued its batch) when we call shutdown.
+    logging_adapter.log_delay_ms.store(500, Ordering::SeqCst);
+
+    // Exactly one full batch triggers exactly one limit flush, which dequeues
+    // all 10 events and leaves the queue empty.
+    let baseline = logging_adapter.times_called.load(Ordering::SeqCst);
+    log_some_events(&statsig, 10);
+
+    // Wait until the limit-flush task has entered the (slow) network call.
+    // Use times_called (incremented before the sleep) rather than on_log_notify,
+    // which can have a stale permit left by the drain flush_events() above.
+    assert_eventually!(|| logging_adapter.times_called.load(Ordering::SeqCst) > baseline);
+
+    // Shutdown while the limit flush is in flight. The queue is empty, so the
+    // only events in the system are the ones held by the in-flight background
+    // task. Before the fix, runtime shutdown aborted that task mid-request and
+    // those 10 exposures were silently dropped.
+    statsig.shutdown().await.unwrap();
+
+    assert_eq!(
+        logging_adapter
+            .no_diagnostics_logged_event_count
+            .load(Ordering::SeqCst),
+        10
+    );
+
+    teardown(Some(statsig)).await;
+}
+
+#[tokio::test]
+#[serial]
+async fn test_flush_events_waits_for_inflight_limit_flush() {
+    let mut options = StatsigOptions::new();
+    options.event_logging_max_queue_size = Some(10);
+    options.event_logging_max_pending_batch_queue_size = Some(60);
+
+    let (statsig, logging_adapter, _) = setup(options).await;
+
+    statsig.flush_events().await;
+    logging_adapter
+        .no_diagnostics_logged_event_count
+        .store(0, Ordering::SeqCst);
+
+    logging_adapter.log_delay_ms.store(500, Ordering::SeqCst);
+
+    let baseline = logging_adapter.times_called.load(Ordering::SeqCst);
+    log_some_events(&statsig, 10);
+
+    assert_eventually!(|| logging_adapter.times_called.load(Ordering::SeqCst) > baseline);
+
+    // A manual flush must also await background limit-flush tasks already in
+    // flight, not just the batches currently in the queue.
+    statsig.flush_events().await;
+
+    assert_eq!(
+        logging_adapter
+            .no_diagnostics_logged_event_count
+            .load(Ordering::SeqCst),
+        10
+    );
+
+    teardown(Some(statsig)).await;
+}
+
 #[tokio::test]
 #[serial]
 async fn test_scheduled_flush_batch_size() {

{statsig_python_core-0.19.5rc2606050349 → statsig_python_core-0.19.6}/statsig-rust/tests/utils/mock_event_logging_adapter.rs

@@ -5,6 +5,7 @@ use statsig_rust::{EventLoggingAdapter, StatsigErr, StatsigRuntime};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
+use std::time::Duration;
 use tokio::sync::Notify;
 
 pub struct MockEventLoggingAdapter {
@@ -14,6 +15,9 @@ pub struct MockEventLoggingAdapter {
     pub logged_payloads: Mutex<Vec<LogEventPayload>>,
     pub mocked_log_events_result: Mutex<Result<bool, StatsigErr>>,
     pub on_log_notify: Notify,
+    // When > 0, log_events sleeps this long (simulating a slow network call)
+    // after signalling on_log_notify but before recording the events.
+    pub log_delay_ms: AtomicU64,
 }
 
 impl Default for MockEventLoggingAdapter {
@@ -31,6 +35,7 @@ impl MockEventLoggingAdapter {
             logged_payloads: Mutex::new(Vec::new()),
             mocked_log_events_result: Mutex::new(Ok(true)),
             on_log_notify: Notify::new(),
+            log_delay_ms: AtomicU64::new(0),
         }
     }
 
@@ -99,6 +104,11 @@ impl EventLoggingAdapter for MockEventLoggingAdapter {
         self.times_called.fetch_add(1, Ordering::SeqCst);
         self.on_log_notify.notify_one();
 
+        let delay_ms = self.log_delay_ms.load(Ordering::SeqCst);
+        if delay_ms > 0 {
+            tokio::time::sleep(Duration::from_millis(delay_ms)).await;
+        }
+
         let result = self.mocked_log_events_result.lock().unwrap().clone()?;
         let mut payloads = self.logged_payloads.lock().unwrap();