statsig-python-core 0.16.0__tar.gz → 0.16.1__tar.gz

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/Cargo.lock

@@ -2553,7 +2553,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2627,7 +2627,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "statsig-node"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "async-trait",
  "napi",
@@ -2641,7 +2641,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2655,7 +2655,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -2701,7 +2701,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -2714,7 +2714,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/Cargo.toml

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

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/PKG-INFO

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

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/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.16.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.16.1", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/statsig-rust/src/id_lists_adapter/statsig_http_id_lists_adapter.rs

@@ -11,6 +11,7 @@ use crate::{
     log_d, log_e, log_error_to_statsig_and_console, StatsigErr, StatsigOptions, StatsigRuntime,
 };
 use async_trait::async_trait;
+use chrono::Utc;
 use parking_lot::RwLock;
 use std::collections::HashMap;
 use std::sync::{Arc, Weak};
@@ -25,6 +26,10 @@ const DEFAULT_ID_LIST_SYNC_INTERVAL_MS: u32 = 60_000;
 type IdListsResponse = HashMap<String, IdListMetadata>;
 
 const TAG: &str = stringify!(StatsigHttpIdListsAdapter);
+const ID_LISTS_SYNC_OVERALL_LATENCY_METRIC: &str = "id_lists_sync_overall.latency";
+const ID_LISTS_SYNC_OVERALL_MANIFEST_SUCCESS_TAG: &str = "id_list_manifest_success";
+const ID_LISTS_SYNC_OVERALL_SUCCEED_SINGLE_ID_LIST_NUMBER_TAG: &str =
+    "succeed_single_id_list_number";
 
 pub struct StatsigHttpIdListsAdapter {
     id_lists_manifest_url: String,
@@ -318,8 +323,36 @@ impl StatsigHttpIdListsAdapter {
     }
 
     async fn sync_id_lists(&self) -> Result<(), StatsigErr> {
-        let new_manifest = self.fetch_id_list_manifests_from_network().await?;
-        let curr_manifest = self.get_current_id_list_metadata()?;
+        let sync_start_ms = Utc::now().timestamp_millis() as u64;
+        let mut id_list_manifest_success = false;
+        let mut successful_single_id_list_number = 0_u64;
+
+        let new_manifest = match self.fetch_id_list_manifests_from_network().await {
+            Ok(manifest) => {
+                id_list_manifest_success = true;
+                manifest
+            }
+            Err(e) => {
+                self.log_id_lists_sync_overall_latency(
+                    sync_start_ms,
+                    id_list_manifest_success,
+                    successful_single_id_list_number,
+                );
+                return Err(e);
+            }
+        };
+
+        let curr_manifest = match self.get_current_id_list_metadata() {
+            Ok(manifest) => manifest,
+            Err(e) => {
+                self.log_id_lists_sync_overall_latency(
+                    sync_start_ms,
+                    id_list_manifest_success,
+                    successful_single_id_list_number,
+                );
+                return Err(e);
+            }
+        };
 
         let mut changes = HashMap::new();
 
@@ -370,17 +403,30 @@ impl StatsigHttpIdListsAdapter {
                 continue;
             }
 
-            let data = self
+            let single_id_list_download_result = self
                 .fetch_individual_id_list_changes_from_network(
                     &new_metadata.url,
                     changeset.range_start,
                 )
-                .await?;
+                .await;
+
+            let raw_changeset = match single_id_list_download_result {
+                Ok(raw_changeset) => raw_changeset,
+                Err(e) => {
+                    self.log_id_lists_sync_overall_latency(
+                        sync_start_ms,
+                        id_list_manifest_success,
+                        successful_single_id_list_number,
+                    );
+                    return Err(e);
+                }
+            };
+            successful_single_id_list_number += 1;
 
             updates.insert(
                 list_name,
                 IdListUpdate {
-                    raw_changeset: Some(data),
+                    raw_changeset: Some(raw_changeset),
                     new_metadata,
                 },
             );
@@ -416,17 +462,11 @@ impl StatsigHttpIdListsAdapter {
             None,
         );
 
-        let (metric_name, metric_value) = if result.is_ok() {
-            ("individual_id_list_download_success", 1.0)
-        } else {
-            ("individual_id_list_download_failure", 1.0)
-        };
-        self.ops_stats.log(ObservabilityEvent::new_event(
-            MetricType::Increment,
-            metric_name.to_string(),
-            metric_value,
-            None,
-        ));
+        self.log_id_lists_sync_overall_latency(
+            sync_start_ms,
+            id_list_manifest_success,
+            successful_single_id_list_number,
+        );
 
         result
     }
@@ -466,6 +506,31 @@ impl StatsigHttpIdListsAdapter {
         }
         self.ops_stats.add_marker(marker, None);
     }
+
+    fn log_id_lists_sync_overall_latency(
+        &self,
+        sync_start_ms: u64,
+        id_list_manifest_success: bool,
+        successful_single_id_list_number: u64,
+    ) {
+        let latency_ms =
+            (Utc::now().timestamp_millis() as u64).saturating_sub(sync_start_ms) as f64;
+        self.ops_stats.log(ObservabilityEvent::new_event(
+            MetricType::Dist,
+            ID_LISTS_SYNC_OVERALL_LATENCY_METRIC.to_string(),
+            latency_ms,
+            Some(HashMap::from([
+                (
+                    ID_LISTS_SYNC_OVERALL_MANIFEST_SUCCESS_TAG.to_string(),
+                    id_list_manifest_success.to_string(),
+                ),
+                (
+                    ID_LISTS_SYNC_OVERALL_SUCCEED_SINGLE_ID_LIST_NUMBER_TAG.to_string(),
+                    successful_single_id_list_number.to_string(),
+                ),
+            ])),
+        ));
+    }
 }
 
 struct IdListChangeSet {

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/statsig-rust/src/specs_adapter/statsig_data_store_specs_adapter.rs

@@ -85,7 +85,7 @@ impl StatsigDataStoreSpecsAdapter {
             data: ResponseData::from_bytes(update.result.unwrap_or_default().into_bytes()),
             source: SpecsSource::Adapter("DataStore".to_string()),
             received_at: Utc::now().timestamp_millis() as u64,
-            source_api: None,
+            source_api: Some("datastore".to_string()),
         }) {
             log_w!(TAG, "Failed to send specs update to listener: {e}");
         }
@@ -122,7 +122,7 @@ impl SpecsAdapter for StatsigDataStoreSpecsAdapter {
             data: ResponseData::from_bytes(data.into_bytes()),
             source: SpecsSource::Adapter("DataStore".to_string()),
             received_at: Utc::now().timestamp_millis() as u64,
-            source_api: None,
+            source_api: Some("datastore".to_string()),
         })
     }
 

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/statsig-rust/src/specs_adapter/statsig_http_specs_adapter.rs

@@ -1,4 +1,5 @@
 use crate::networking::{NetworkClient, NetworkError, RequestArgs, 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_diagnostics::diagnostics::ContextType;
@@ -26,7 +27,7 @@ use super::SpecsInfo;
 
 pub struct NetworkResponse {
     pub data: ResponseData,
-    pub api: String,
+    pub loggable_api: String,
     pub requested_deltas: bool,
 }
 
@@ -37,6 +38,13 @@ pub const DEFAULT_SYNC_INTERVAL_MS: u32 = 10_000;
 pub const INIT_DICT_ID: &str = "null";
 
 const TAG: &str = stringify!(StatsigHttpSpecsAdapter);
+const CONFIG_SYNC_OVERALL_LATENCY_METRIC: &str = "config_sync_overall.latency";
+const CONFIG_SYNC_OVERALL_FORMAT_TAG: &str = "format";
+const CONFIG_SYNC_OVERALL_SOURCE_API_TAG: &str = "source_api";
+const CONFIG_SYNC_OVERALL_ERROR_TAG: &str = "error";
+const CONFIG_SYNC_OVERALL_NETWORK_SUCCESS_TAG: &str = "network_success";
+const CONFIG_SYNC_OVERALL_PROCESS_SUCCESS_TAG: &str = "process_success";
+
 pub struct StatsigHttpSpecsAdapter {
     listener: RwLock<Option<Arc<dyn SpecsUpdateListener>>>,
     network: NetworkClient,
@@ -51,6 +59,38 @@ pub struct StatsigHttpSpecsAdapter {
     use_deltas_next_request: AtomicBool,
 }
 
+// OB client -- START
+// These types are only for the config_sync_overall.latency observability metric added in this change.
+enum ResponseFormat {
+    Json,
+    PlainText,
+    Protobuf,
+    Unknown,
+}
+
+enum NetworkSyncOutcome {
+    Success,
+    Failure,
+}
+
+impl NetworkSyncOutcome {
+    fn as_bool(&self) -> bool {
+        matches!(self, Self::Success)
+    }
+}
+
+impl ResponseFormat {
+    fn as_str(&self) -> &str {
+        match self {
+            ResponseFormat::Json => "json",
+            ResponseFormat::PlainText => "plain_text",
+            ResponseFormat::Protobuf => "protobuf",
+            ResponseFormat::Unknown => "unknown",
+        }
+    }
+}
+// OB client -- END
+
 impl StatsigHttpSpecsAdapter {
     #[must_use]
     pub fn new(
@@ -123,7 +163,7 @@ impl StatsigHttpSpecsAdapter {
         match self.handle_specs_request(request_args).await {
             Ok(response) => Ok(NetworkResponse {
                 data: response,
-                api: get_api_from_url(&url),
+                loggable_api: get_api_from_url(&url),
                 requested_deltas,
             }),
             Err(e) => Err(e),
@@ -211,7 +251,7 @@ impl StatsigHttpSpecsAdapter {
         let response = self.handle_specs_request(request_args).await?;
         Ok(NetworkResponse {
             data: response,
-            api: get_api_from_url(&fallback_url),
+            loggable_api: get_api_from_url(&fallback_url),
             requested_deltas,
         })
     }
@@ -275,22 +315,139 @@ impl StatsigHttpSpecsAdapter {
             }
         }
 
+        let sync_start_ms = Utc::now().timestamp_millis() as u64;
         let response = self
             .fetch_specs_from_network(current_specs_info.clone(), trigger)
             .await;
-        let result = self.process_spec_data(response).await;
+        let (mut source_api, mut response_format, mut network_success) = match &response {
+            Ok(response) => (
+                response.loggable_api.clone(),
+                Self::get_response_format(&response.data),
+                NetworkSyncOutcome::Success,
+            ),
+            Err(_) => (
+                get_api_from_url(&construct_specs_url(
+                    self.specs_url.as_str(),
+                    self.sdk_key.as_str(),
+                )),
+                ResponseFormat::Unknown,
+                NetworkSyncOutcome::Failure,
+            ),
+        };
+
+        let mut result = self.process_spec_data(response).await;
 
         if result.is_err() && self.fallback_url.is_some() {
             log_d!(TAG, "Falling back to statsig api");
             let response = self
                 .handle_fallback_request(self.get_request_args(&current_specs_info, trigger))
                 .await;
-            return self.process_spec_data(response).await;
+            match &response {
+                Ok(response) => {
+                    source_api = response.loggable_api.clone();
+                    response_format = Self::get_response_format(&response.data);
+                    network_success = NetworkSyncOutcome::Success;
+                }
+                Err(_) => {
+                    // Backup request failed, so no successful network payload was returned.
+                    if let Some(fallback_url) = self.fallback_url.as_ref() {
+                        source_api = get_api_from_url(&construct_specs_url(
+                            fallback_url.as_str(),
+                            self.sdk_key.as_str(),
+                        ));
+                    }
+                    network_success = NetworkSyncOutcome::Failure;
+                }
+            }
+            result = self.process_spec_data(response).await;
         }
 
+        let process_success = !matches!(result.as_ref(), Err(StatsigErr::NetworkError(_)));
+        self.log_config_sync_overall_latency(
+            sync_start_ms,
+            &source_api,
+            response_format.as_str(),
+            network_success.as_bool(),
+            process_success,
+            result
+                .as_ref()
+                .err()
+                .map_or_else(String::new, |e| e.to_string()),
+        );
+
         result
     }
 
+    // --------- START - Observability helpers ---------
+    fn get_response_format(response_data: &ResponseData) -> ResponseFormat {
+        if Self::is_response_protobuf(response_data) {
+            return ResponseFormat::Protobuf;
+        }
+
+        let content_type = match response_data.get_header_ref("content-type") {
+            Some(content_type) => content_type.to_ascii_lowercase(),
+            None => return ResponseFormat::Unknown,
+        };
+
+        if content_type.contains("application/json") || content_type.contains("+json") {
+            return ResponseFormat::Json;
+        }
+
+        if content_type.contains("text/plain") {
+            return ResponseFormat::PlainText;
+        }
+
+        ResponseFormat::Unknown
+    }
+
+    fn is_response_protobuf(response_data: &ResponseData) -> bool {
+        let content_type = response_data.get_header_ref("content-type");
+        if content_type.map(|s| s.as_str().contains("application/octet-stream")) != Some(true) {
+            return false;
+        }
+
+        let content_encoding = response_data.get_header_ref("content-encoding");
+        content_encoding.map(|s| s.as_str().contains("statsig-br")) == Some(true)
+    }
+
+    fn log_config_sync_overall_latency(
+        &self,
+        sync_start_ms: u64,
+        source_api: &str,
+        response_format: &str,
+        network_success: bool,
+        process_success: bool,
+        error: String,
+    ) {
+        let latency_ms =
+            (Utc::now().timestamp_millis() as u64).saturating_sub(sync_start_ms) as f64;
+        self.ops_stats.log(ObservabilityEvent::new_event(
+            MetricType::Dist,
+            CONFIG_SYNC_OVERALL_LATENCY_METRIC.to_string(),
+            latency_ms,
+            Some(HashMap::from([
+                (
+                    CONFIG_SYNC_OVERALL_SOURCE_API_TAG.to_string(),
+                    get_api_from_url(source_api),
+                ),
+                (
+                    CONFIG_SYNC_OVERALL_FORMAT_TAG.to_string(),
+                    response_format.to_string(),
+                ),
+                (CONFIG_SYNC_OVERALL_ERROR_TAG.to_string(), error),
+                (
+                    CONFIG_SYNC_OVERALL_NETWORK_SUCCESS_TAG.to_string(),
+                    network_success.to_string(),
+                ),
+                (
+                    CONFIG_SYNC_OVERALL_PROCESS_SUCCESS_TAG.to_string(),
+                    process_success.to_string(),
+                ),
+            ])),
+        ));
+    }
+    // --------- END - Observability helpers ---------
+
     async fn process_spec_data(
         &self,
         response: Result<NetworkResponse, NetworkError>,
@@ -302,7 +459,7 @@ impl StatsigHttpSpecsAdapter {
             data: resp.data,
             source: SpecsSource::Network,
             received_at: Utc::now().timestamp_millis() as u64,
-            source_api: Some(resp.api),
+            source_api: Some(resp.loggable_api),
         };
 
         self.ops_stats.add_marker(
@@ -455,6 +612,7 @@ pub enum SpecsSyncTrigger {
 mod tests {
     use super::*;
     use crate::{networking::ResponseData, specs_adapter::SpecsUpdate, StatsigOptions};
+    use std::collections::HashMap;
     use std::sync::atomic::AtomicUsize;
 
     struct ChecksumFailingListener;
@@ -519,7 +677,7 @@ mod tests {
         let result = adapter
             .process_spec_data(Ok(NetworkResponse {
                 data: ResponseData::from_bytes(vec![]),
-                api: "test-api".to_string(),
+                loggable_api: "test-api".to_string(),
                 requested_deltas: true,
             }))
             .await;
@@ -553,7 +711,7 @@ mod tests {
         let first_result = adapter
             .process_spec_data(Ok(NetworkResponse {
                 data: ResponseData::from_bytes(vec![]),
-                api: "test-api".to_string(),
+                loggable_api: "test-api".to_string(),
                 requested_deltas: true,
             }))
             .await;
@@ -569,7 +727,7 @@ mod tests {
         let second_result = adapter
             .process_spec_data(Ok(NetworkResponse {
                 data: ResponseData::from_bytes(vec![]),
-                api: "test-api".to_string(),
+                loggable_api: "test-api".to_string(),
                 requested_deltas: false,
             }))
             .await;
@@ -586,4 +744,53 @@ mod tests {
             Some("true")
         );
     }
+
+    #[test]
+    fn test_get_response_format_json() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+        let data = ResponseData::from_bytes_with_headers(vec![], Some(headers));
+        assert!(matches!(
+            StatsigHttpSpecsAdapter::get_response_format(&data),
+            ResponseFormat::Json
+        ));
+    }
+
+    #[test]
+    fn test_get_response_format_plain_text() {
+        let mut headers = HashMap::new();
+        headers.insert(
+            "content-type".to_string(),
+            "text/plain; charset=utf-8".to_string(),
+        );
+        let data = ResponseData::from_bytes_with_headers(vec![], Some(headers));
+        assert!(matches!(
+            StatsigHttpSpecsAdapter::get_response_format(&data),
+            ResponseFormat::PlainText
+        ));
+    }
+
+    #[test]
+    fn test_get_response_format_protobuf() {
+        let mut headers = HashMap::new();
+        headers.insert(
+            "content-type".to_string(),
+            "application/octet-stream".to_string(),
+        );
+        headers.insert("content-encoding".to_string(), "statsig-br".to_string());
+        let data = ResponseData::from_bytes_with_headers(vec![], Some(headers));
+        assert!(matches!(
+            StatsigHttpSpecsAdapter::get_response_format(&data),
+            ResponseFormat::Protobuf
+        ));
+    }
+
+    #[test]
+    fn test_get_response_format_unknown_without_content_type() {
+        let data = ResponseData::from_bytes(vec![]);
+        assert!(matches!(
+            StatsigHttpSpecsAdapter::get_response_format(&data),
+            ResponseFormat::Unknown
+        ));
+    }
 }

{statsig_python_core-0.16.0 → statsig_python_core-0.16.1}/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.16.0";
+pub const SDK_VERSION: &str = "0.16.1";
 
 const TAG: &str = stringify!(StatsigMetadata);