oai-statsig-python-core 0.24.0rc2__tar.gz → 0.24.1__tar.gz

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/Cargo.lock

@@ -1722,7 +1722,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1737,7 +1737,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3011,7 +3011,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "async-trait",
  "napi",
@@ -3026,7 +3026,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3041,7 +3041,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "async-trait",
  "oai-statsig-rust",
@@ -3054,7 +3054,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.24.0-rc.2"
+version = "0.24.1"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/Cargo.toml

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

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.24.0rc2
+Version: 0.24.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/Cargo.toml

@@ -43,7 +43,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-oai-statsig-grpc = { path = "../statsig-grpc", version = "0.24.0-rc.2", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.24.1", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/src/event_logging/event_logger.rs

@@ -21,6 +21,7 @@ use crate::{
     statsig_metadata::StatsigMetadata,
     write_lock_or_noop, EventLoggingAdapter, StatsigErr, StatsigOptions, StatsigRuntime,
 };
+use chrono::Utc;
 use parking_lot::RwLock;
 use std::{collections::HashMap, sync::Arc};
 use std::{
@@ -387,10 +388,19 @@ impl EventLogger {
             flush_type.to_string(),
         );
 
-        let result = self
-            .logging_adapter
-            .log_events(batch.get_log_event_request(statsig_metadata))
-            .await;
+        let request = batch.get_log_event_request(statsig_metadata);
+        let max_event_queue_time_ms =
+            batch.get_max_event_queue_time_ms(Utc::now().timestamp_millis() as u64);
+        let observability_tags = self.logging_adapter.get_observability_tags();
+
+        self.ops_stats.log_event_request_batch_stats(
+            batch.events.len(),
+            max_event_queue_time_ms,
+            flush_type,
+            observability_tags.clone(),
+        );
+
+        let result = self.logging_adapter.log_events(request).await;
 
         batch.attempts += 1;
 
@@ -398,7 +408,8 @@ impl EventLogger {
             Ok(true) => {
                 self.ops_stats.log_event_request_success(
                     batch.events.len(),
-                    self.logging_adapter.get_observability_tags(),
+                    flush_type,
+                    observability_tags,
                 );
                 Ok(())
             }

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/src/event_logging/event_logger_ops_stats.rs

@@ -27,16 +27,55 @@ impl OpsStatsForInstance {
         });
     }
 
+    pub fn log_event_request_batch_stats(
+        &self,
+        event_count: usize,
+        max_event_queue_time_ms: u64,
+        flush_type: FlushType,
+        tags: Option<HashMap<String, String>>,
+    ) {
+        let tags = Some(get_event_request_tags(tags, flush_type));
+
+        self.log(OpsStatsEvent::Observability(ObservabilityEvent {
+            metric_type: MetricType::Dist,
+            metric_name: "log_event_request_event_count".to_string(),
+            value: event_count as f64,
+            tags: tags.clone(),
+        }));
+
+        self.log(OpsStatsEvent::Observability(ObservabilityEvent {
+            metric_type: MetricType::Dist,
+            metric_name: "log_event_request_max_event_queue_time_ms".to_string(),
+            value: max_event_queue_time_ms as f64,
+            tags,
+        }));
+    }
+
     pub fn log_event_request_success(
         &self,
         event_count: usize,
+        flush_type: FlushType,
         tags: Option<HashMap<String, String>>,
     ) {
         self.log(OpsStatsEvent::Observability(ObservabilityEvent {
             metric_type: MetricType::Increment,
             metric_name: "events_successfully_sent_count".to_string(),
             value: event_count as f64,
-            tags,
+            tags: Some(get_event_request_tags(tags, flush_type)),
+        }))
+    }
+
+    pub fn log_event_request_uncompressed_body_size_bytes(
+        &self,
+        uncompressed_body_size_bytes: usize,
+        flush_type: String,
+        tags: Option<HashMap<String, String>>,
+    ) {
+        self.log(OpsStatsEvent::Observability(ObservabilityEvent {
+            metric_type: MetricType::Dist,
+            metric_name: "log_event_request_uncompressed_body_size_bytes".to_string(),
+            value: uncompressed_body_size_bytes as f64,
+            tags: Some(get_event_request_tags(tags, flush_type)),
         }))
     }
 
@@ -74,3 +113,12 @@ impl OpsStatsForInstance {
         });
     }
 }
+
+fn get_event_request_tags(
+    tags: Option<HashMap<String, String>>,
+    flush_type: impl ToString,
+) -> HashMap<String, String> {
+    let mut tags = tags.unwrap_or_default();
+    tags.insert("flush_type".to_string(), flush_type.to_string());
+    tags
+}

oai_statsig_python_core-0.24.1/statsig-rust/src/event_logging/event_queue/batch.rs

@@ -0,0 +1,84 @@
+use crate::event_logging::statsig_event_internal::StatsigEventInternal;
+use crate::log_event_payload::{LogEventPayload, LogEventRequest};
+use crate::statsig_metadata::StatsigMetadataWithLogEventExtras;
+use serde_json::json;
+
+pub struct EventBatch {
+    pub attempts: u8,
+    pub events: Vec<StatsigEventInternal>,
+    first_event_time_ms: Option<u64>,
+}
+
+impl EventBatch {
+    pub fn new(events: Vec<StatsigEventInternal>) -> Self {
+        let first_event_time_ms = events.first().map(|event| event.time);
+        Self {
+            events,
+            attempts: 0,
+            first_event_time_ms,
+        }
+    }
+
+    pub fn get_max_event_queue_time_ms(&self, now_ms: u64) -> u64 {
+        self.first_event_time_ms
+            .map(|first_event_time_ms| now_ms.saturating_sub(first_event_time_ms))
+            .unwrap_or_default()
+    }
+
+    pub fn get_log_event_request(
+        &self,
+        statsig_metadata: StatsigMetadataWithLogEventExtras,
+    ) -> LogEventRequest {
+        let payload = LogEventPayload {
+            events: json!(self.events),
+            statsig_metadata: json!(statsig_metadata),
+        };
+
+        LogEventRequest {
+            payload,
+            event_count: self.events.len() as u64,
+            retries: self.attempts as u32,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{event_logging::statsig_event::StatsigEvent, user::StatsigUserLoggable};
+
+    fn make_event(time: u64) -> StatsigEventInternal {
+        StatsigEventInternal::new(
+            time,
+            StatsigUserLoggable::null(),
+            StatsigEvent {
+                event_name: "test_event".to_string(),
+                value: None,
+                metadata: None,
+                statsig_metadata: None,
+            },
+            None,
+        )
+    }
+
+    #[test]
+    fn max_event_queue_time_uses_cached_first_event_time() {
+        let batch = EventBatch::new(vec![make_event(100), make_event(200)]);
+
+        assert_eq!(batch.get_max_event_queue_time_ms(350), 250);
+    }
+
+    #[test]
+    fn max_event_queue_time_saturates_at_zero() {
+        let batch = EventBatch::new(vec![make_event(200)]);
+
+        assert_eq!(batch.get_max_event_queue_time_ms(100), 0);
+    }
+
+    #[test]
+    fn max_event_queue_time_defaults_for_empty_batch() {
+        let batch = EventBatch::new(Vec::new());
+
+        assert_eq!(batch.get_max_event_queue_time_ms(100), 0);
+    }
+}

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/src/event_logging/event_queue/queue.rs

@@ -122,7 +122,7 @@ impl EventQueue {
     }
 
     pub fn reconcile_batching(&self) -> QueueReconcileResult {
-        let mut pending_events: VecDeque<StatsigEventInternal> = self
+        let pending_events: VecDeque<StatsigEventInternal> = self
             .take_all_pending_events()
             .into_iter()
             .map(|evt| evt.into_statsig_event_internal())
@@ -140,11 +140,13 @@ impl EventQueue {
             .into_iter()
             .partition(|batch| batch.events.len() >= self.batch_size);
 
+        let mut events_to_batch = VecDeque::new();
         for batch in partial_batches {
-            pending_events.extend(batch.events);
+            events_to_batch.extend(batch.events);
         }
+        events_to_batch.extend(pending_events);
 
-        let new_batches = self.create_batches(pending_events);
+        let new_batches = self.create_batches(events_to_batch);
 
         batches.extend(full_batches);
         batches.extend(new_batches);

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/src/event_logging_adapter/statsig_http_event_logging_adapter.rs

@@ -2,6 +2,7 @@ use crate::compression::compression_helper::{compress_data, get_compression_form
 use crate::event_logging_adapter::EventLoggingAdapter;
 use crate::log_event_payload::LogEventRequest;
 use crate::networking::{NetworkClient, NetworkError, RequestArgs};
+use crate::observability::ops_stats::{OpsStatsForInstance, OPS_STATS};
 use crate::statsig_metadata::StatsigMetadata;
 use crate::{log_d, StatsigErr, StatsigOptions, StatsigRuntime};
 use async_trait::async_trait;
@@ -22,6 +23,7 @@ const TAG: &str = stringify!(StatsigHttpEventLoggingAdapter);
 pub struct StatsigHttpEventLoggingAdapter {
     log_event_url: String,
     network: NetworkClient,
+    ops_stats: Arc<OpsStatsForInstance>,
 }
 
 impl StatsigHttpEventLoggingAdapter {
@@ -37,9 +39,14 @@ impl StatsigHttpEventLoggingAdapter {
             .map(|u| u.to_string())
             .unwrap_or_else(|| DEFAULT_LOG_EVENT_URL.to_string());
 
+        let sdk_instance_id = options
+            .map(|opts| opts.get_sdk_instance_id(sdk_key))
+            .unwrap_or(sdk_key);
+
         Self {
             log_event_url,
             network: NetworkClient::new(sdk_key, Some(headers), options),
+            ops_stats: OPS_STATS.get_for_instance(sdk_instance_id),
         }
     }
 
@@ -70,6 +77,13 @@ impl StatsigHttpEventLoggingAdapter {
         // Compress data before sending it
         let bytes = serde_json::to_vec(&request.payload)
             .map_err(|e| StatsigErr::SerializationError(e.to_string()))?;
+        self.ops_stats
+            .log_event_request_uncompressed_body_size_bytes(
+                bytes.len(),
+                get_request_flush_type(request),
+                self.get_observability_tags(),
+            );
+
         let compressed = match compress_data(&bytes) {
             Ok(c) => c,
             Err(e) => return Err(e),
@@ -118,6 +132,16 @@ impl StatsigHttpEventLoggingAdapter {
     }
 }
 
+fn get_request_flush_type(request: &LogEventRequest) -> String {
+    request
+        .payload
+        .statsig_metadata
+        .get("flushType")
+        .and_then(|value| value.as_str())
+        .unwrap_or("unknown")
+        .to_string()
+}
+
 #[async_trait]
 impl EventLoggingAdapter for StatsigHttpEventLoggingAdapter {
     async fn start(&self, _statsig_runtime: &Arc<StatsigRuntime>) -> Result<(), StatsigErr> {

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/src/statsig_metadata.rs

@@ -11,7 +11,7 @@ lazy_static! {
 }
 
 /// Canonical SDK release version embedded in shared-core metadata.
-pub const SDK_VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const SDK_VERSION: &str = "0.24.1";
 
 const TAG: &str = stringify!(StatsigMetadata);
 

{oai_statsig_python_core-0.24.0rc2 → oai_statsig_python_core-0.24.1}/statsig-rust/tests/observability_client_usage_tests.rs

@@ -351,7 +351,7 @@ async fn test_sdk_initialization_dist_recorded() {
 
 #[tokio::test]
 #[serial]
-async fn test_event_success_count_includes_log_event_endpoint() {
+async fn test_event_logging_metrics_include_request_context() {
     let obs_client = Arc::new(MockObservabilityClient {
         calls: Mutex::new(Vec::new()),
     });
@@ -369,22 +369,60 @@ async fn test_event_success_count_includes_log_event_endpoint() {
 
     let expected_source_api = mock_scrapi.url_for_endpoint(Endpoint::LogEvent);
     let deadline = Instant::now() + Duration::from_secs(1);
-    let mut found_metric = false;
+    let mut found_success_count = false;
+    let mut found_event_count = false;
+    let mut found_uncompressed_body_size = false;
+    let mut found_max_event_queue_time = false;
 
     while Instant::now() < deadline {
         {
             let calls = obs_client.calls.lock().unwrap();
-            found_metric = calls.iter().any(|call| match call {
+            found_success_count = calls.iter().any(|call| match call {
                 RecordedCall::Increment(metric_name, value, Some(tags)) => {
                     metric_name == "statsig.sdk.events_successfully_sent_count"
                         && *value > 0.0
                         && tags.get("source_api") == Some(&expected_source_api)
+                        && tags.get("flush_type").map(String::as_str) == Some("manual")
+                }
+                _ => false,
+            });
+
+            found_event_count = calls.iter().any(|call| match call {
+                RecordedCall::Dist(metric_name, value, Some(tags)) => {
+                    metric_name == "statsig.sdk.log_event_request_event_count"
+                        && *value > 0.0
+                        && tags.get("source_api") == Some(&expected_source_api)
+                        && tags.get("flush_type").map(String::as_str) == Some("manual")
+                }
+                _ => false,
+            });
+
+            found_uncompressed_body_size = calls.iter().any(|call| match call {
+                RecordedCall::Dist(metric_name, value, Some(tags)) => {
+                    metric_name == "statsig.sdk.log_event_request_uncompressed_body_size_bytes"
+                        && *value > 0.0
+                        && tags.get("source_api") == Some(&expected_source_api)
+                        && tags.get("flush_type").map(String::as_str) == Some("manual")
+                }
+                _ => false,
+            });
+
+            found_max_event_queue_time = calls.iter().any(|call| match call {
+                RecordedCall::Dist(metric_name, value, Some(tags)) => {
+                    metric_name == "statsig.sdk.log_event_request_max_event_queue_time_ms"
+                        && *value >= 0.0
+                        && tags.get("source_api") == Some(&expected_source_api)
+                        && tags.get("flush_type").map(String::as_str) == Some("manual")
                 }
                 _ => false,
             });
         }
 
-        if found_metric {
+        if found_success_count
+            && found_event_count
+            && found_uncompressed_body_size
+            && found_max_event_queue_time
+        {
             break;
         }
 
@@ -392,8 +430,20 @@ async fn test_event_success_count_includes_log_event_endpoint() {
     }
 
     assert!(
-        found_metric,
-        "Expected events_successfully_sent_count to include source_api"
+        found_success_count,
+        "Expected events_successfully_sent_count to include source_api and flush_type"
+    );
+    assert!(
+        found_event_count,
+        "Expected log_event_request_event_count to include request context"
+    );
+    assert!(
+        found_uncompressed_body_size,
+        "Expected log_event_request_uncompressed_body_size_bytes to include request context"
+    );
+    assert!(
+        found_max_event_queue_time,
+        "Expected log_event_request_max_event_queue_time_ms to include request context"
     );
 }
 

oai_statsig_python_core-0.24.0rc2/statsig-rust/src/event_logging/event_queue/batch.rs

@@ -1,34 +0,0 @@
-use crate::event_logging::statsig_event_internal::StatsigEventInternal;
-use crate::log_event_payload::{LogEventPayload, LogEventRequest};
-use crate::statsig_metadata::StatsigMetadataWithLogEventExtras;
-use serde_json::json;
-
-pub struct EventBatch {
-    pub attempts: u8,
-    pub events: Vec<StatsigEventInternal>,
-}
-
-impl EventBatch {
-    pub fn new(events: Vec<StatsigEventInternal>) -> Self {
-        Self {
-            events,
-            attempts: 0,
-        }
-    }
-
-    pub fn get_log_event_request(
-        &self,
-        statsig_metadata: StatsigMetadataWithLogEventExtras,
-    ) -> LogEventRequest {
-        let payload = LogEventPayload {
-            events: json!(self.events),
-            statsig_metadata: json!(statsig_metadata),
-        };
-
-        LogEventRequest {
-            payload,
-            event_count: self.events.len() as u64,
-            retries: self.attempts as u32,
-        }
-    }
-}