oai-statsig-python-core 0.24.1__tar.gz → 0.24.2rc4__tar.gz

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/Cargo.lock

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

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/Cargo.toml

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

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/PKG-INFO

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

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/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.1", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.24.2-rc.4", 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.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/networking/http_types.rs

@@ -204,7 +204,7 @@ impl ResponseData {
         Ok(buf)
     }
 
-    fn rewind(&mut self) -> Result<(), StatsigErr> {
+    pub(crate) fn rewind(&mut self) -> Result<(), StatsigErr> {
         self.stream
             .rewind()
             .map_err(|e| StatsigErr::SerializationError(e.to_string()))

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/networking/network_client.rs

@@ -92,10 +92,10 @@ impl NetworkClient {
                     opts.disable_network.unwrap_or(false),
                     opts.proxy_config.clone(),
                     ca_cert_pem,
-                    opts.log_event_connection_reuse.unwrap_or(false),
+                    opts.log_event_connection_reuse.unwrap_or(true),
                 )
             })
-            .unwrap_or((false, None, None, false));
+            .unwrap_or((false, None, None, true));
 
         let sdk_instance_id = options
             .map(|opts| opts.get_sdk_instance_id(sdk_key))
@@ -549,10 +549,28 @@ fn get_error_message_for_status(
 mod tests {
     use super::{
         get_network_error_extra_tags, get_network_request_latency_tags, get_request_path,
-        get_source_service_and_request_path, should_log_network_request_latency, DELTAS_USED_TAG,
-        ID_LIST_FILE_ID_TAG, REQUEST_PATH_TAG, STATUS_CODE_TAG,
+        get_source_service_and_request_path, should_log_network_request_latency, NetworkClient,
+        DELTAS_USED_TAG, ID_LIST_FILE_ID_TAG, REQUEST_PATH_TAG, STATUS_CODE_TAG,
     };
     use crate::networking::{NetworkError, RequestArgs};
+    use crate::StatsigOptions;
+
+    #[test]
+    fn test_log_event_connection_reuse_defaults_to_true() {
+        assert!(NetworkClient::new("secret-test", None, None).log_event_connection_reuse);
+        assert!(
+            NetworkClient::new("secret-test", None, Some(&StatsigOptions::default()))
+                .log_event_connection_reuse
+        );
+
+        let options = StatsigOptions {
+            log_event_connection_reuse: Some(false),
+            ..StatsigOptions::default()
+        };
+        assert!(
+            !NetworkClient::new("secret-test", None, Some(&options)).log_event_connection_reuse
+        );
+    }
 
     #[test]
     fn test_get_request_path_with_sample_urls() {

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/spec_store.rs

@@ -31,6 +31,33 @@ pub struct SpecStoreData {
 }
 
 const TAG: &str = stringify!(SpecStore);
+const RESPONSE_TYPE_TAG: &str = "response_type";
+const DELTAS_USED_HEADER: &str = "x-deltas-used";
+
+#[derive(Clone, Copy)]
+enum ConfigResponseType {
+    Delta,
+    Full,
+    NoUpdate,
+}
+
+impl ConfigResponseType {
+    fn from_applied_response_data(data: &ResponseData) -> Self {
+        if data.get_header_ref(DELTAS_USED_HEADER).is_some() {
+            Self::Delta
+        } else {
+            Self::Full
+        }
+    }
+
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Delta => "delta",
+            Self::Full => "full",
+            Self::NoUpdate => "no_update",
+        }
+    }
+}
 
 pub struct SpecStore {
     pub data: Arc<RwLock<SpecStoreData>>,
@@ -201,11 +228,17 @@ impl SpecStore {
             PrepResult::HasUpdates(next_values, response_format) => (next_values, response_format),
             PrepResult::CurrentValuesNewer => return Ok(()),
             PrepResult::NoUpdates => {
-                self.ops_stats_log_no_update(specs_update.source, specs_update.source_api);
+                self.ops_stats_log_no_update(
+                    specs_update.source,
+                    specs_update.source_api,
+                    ConfigResponseType::NoUpdate,
+                );
                 return Ok(());
             }
         };
 
+        let response_type = ConfigResponseType::from_applied_response_data(&specs_update.data);
+
         // --- Apply ---
 
         let apply_result = self
@@ -219,7 +252,7 @@ impl SpecStore {
 
         // --- Notify ---
 
-        self.specs_update_notify(response_format, specs_update, apply_result)
+        self.specs_update_notify(response_format, response_type, specs_update, apply_result)
             .map_err(|e| {
                 log_error_to_statsig_and_console!(self.ops_stats, TAG, e);
                 e
@@ -360,6 +393,7 @@ impl SpecStore {
     fn specs_update_notify(
         &self,
         response_format: SpecsFormat,
+        response_type: ConfigResponseType,
         specs_update: SpecsUpdate,
         apply_result: ApplyResult,
     ) -> Result<(), StatsigErr> {
@@ -399,6 +433,7 @@ impl SpecStore {
             &prev_source,
             source_api,
             response_format,
+            response_type,
         );
 
         Ok(())
@@ -630,7 +665,12 @@ async fn write_specs_to_data_store(
 // -------------------------------------------------------------------------------------------- [ OpsStats Helpers ]
 
 impl SpecStore {
-    fn ops_stats_log_no_update(&self, source: SpecsSource, source_api: Option<String>) {
+    fn ops_stats_log_no_update(
+        &self,
+        source: SpecsSource,
+        source_api: Option<String>,
+        response_type: ConfigResponseType,
+    ) {
         log_d!(TAG, "No Updates");
         self.ops_stats.log(ObservabilityEvent::new_event(
             MetricType::Increment,
@@ -639,6 +679,10 @@ impl SpecStore {
             Some(HashMap::from([
                 ("source".to_string(), source.to_string()),
                 ("source_api".to_string(), source_api.unwrap_or_default()),
+                (
+                    RESPONSE_TYPE_TAG.to_string(),
+                    response_type.as_str().to_string(),
+                ),
             ])),
         ));
     }
@@ -652,6 +696,7 @@ impl SpecStore {
         prev_source: &SpecsSource,
         source_api: Option<String>,
         response_format: SpecsFormat,
+        response_type: ConfigResponseType,
     ) {
         let delay = (Utc::now().timestamp_millis() as u64).saturating_sub(lcut);
         log_d!(TAG, "Updated ({:?})", source);
@@ -674,6 +719,10 @@ impl SpecStore {
                     "response_format".to_string(),
                     Into::<&str>::into(&response_format).to_string(),
                 ),
+                (
+                    RESPONSE_TYPE_TAG.to_string(),
+                    response_type.as_str().to_string(),
+                ),
             ])),
         ));
     }
@@ -758,3 +807,31 @@ impl IdListsUpdateListener for SpecStore {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{ConfigResponseType, DELTAS_USED_HEADER};
+    use crate::networking::ResponseData;
+    use std::collections::HashMap;
+
+    #[test]
+    fn applied_response_type_uses_delta_header() {
+        let delta_data = ResponseData::from_bytes_with_headers(
+            Vec::new(),
+            Some(HashMap::from([(
+                DELTAS_USED_HEADER.to_string(),
+                "true".to_string(),
+            )])),
+        );
+        let full_data = ResponseData::from_bytes(Vec::new());
+
+        assert_eq!(
+            ConfigResponseType::from_applied_response_data(&delta_data).as_str(),
+            "delta"
+        );
+        assert_eq!(
+            ConfigResponseType::from_applied_response_data(&full_data).as_str(),
+            "full"
+        );
+    }
+}

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/specs_adapter/config_spec_background_sync_metrics.rs

@@ -14,6 +14,7 @@ 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";
 const CONFIG_SYNC_OVERALL_DELTAS_USED_TAG: &str = "deltas_used";
+const CONFIG_SYNC_OVERALL_RESPONSE_TYPE_TAG: &str = "response_type";
 
 #[allow(clippy::too_many_arguments)]
 pub fn log_config_sync_overall_latency(
@@ -25,6 +26,7 @@ pub fn log_config_sync_overall_latency(
     process_success: bool,
     error: String,
     deltas_used: bool,
+    response_type: &str,
 ) {
     let latency_ms = (Utc::now().timestamp_millis() as u64).saturating_sub(sync_start_ms) as f64;
     ops_stats.log(ObservabilityEvent::new_event(
@@ -57,6 +59,10 @@ pub fn log_config_sync_overall_latency(
                 CONFIG_SYNC_OVERALL_DELTAS_USED_TAG.to_string(),
                 deltas_used.to_string(),
             ),
+            (
+                CONFIG_SYNC_OVERALL_RESPONSE_TYPE_TAG.to_string(),
+                response_type.to_string(),
+            ),
         ])),
     ));
 }

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/specs_adapter/statsig_data_store_specs_adapter.rs

@@ -325,6 +325,7 @@ impl StatsigDataStoreSpecsAdapter {
                 .err()
                 .map_or_else(String::new, |e| e.to_string()),
             false,
+            "datastore",
         );
     }
 

{oai_statsig_python_core-0.24.1 → oai_statsig_python_core-0.24.2rc4}/statsig-rust/src/specs_adapter/statsig_http_specs_adapter.rs

@@ -6,6 +6,7 @@ use crate::observability::sdk_errors_observer::ErrorBoundaryEvent;
 use crate::sdk_diagnostics::diagnostics::ContextType;
 use crate::sdk_diagnostics::marker::{ActionType, KeyType, Marker, StepType};
 use crate::specs_adapter::{SpecsAdapter, SpecsUpdate, SpecsUpdateListener};
+use crate::specs_response::spec_types::SpecsResponseNoUpdates;
 use crate::statsig_err::StatsigErr;
 use crate::statsig_metadata::StatsigMetadata;
 use crate::utils::get_api_from_url;
@@ -69,6 +70,50 @@ impl NetworkSyncOutcome {
         matches!(self, Self::Success)
     }
 }
+
+enum ConfigSyncResponseType {
+    Delta,
+    Full,
+    NoUpdate,
+    NetworkError,
+}
+
+impl ConfigSyncResponseType {
+    fn from_response_data(data: &mut ResponseData) -> Self {
+        if is_true_header(data, "x-cache-hit") {
+            return Self::NoUpdate;
+        }
+
+        if data.get_header_ref("x-deltas-used").is_some() {
+            return Self::Delta;
+        }
+
+        let response_type = match data.deserialize_into::<SpecsResponseNoUpdates>() {
+            Ok(response) if !response.has_updates => Self::NoUpdate,
+            _ => Self::Full,
+        };
+        let _ = data.rewind();
+        response_type
+    }
+
+    fn as_str(&self) -> &'static str {
+        match self {
+            Self::Delta => "delta",
+            Self::Full => "full",
+            Self::NoUpdate => "no_update",
+            Self::NetworkError => "network_error",
+        }
+    }
+}
+
+fn is_true_header(data: &ResponseData, key: &str) -> bool {
+    data.get_header_ref(key)
+        .is_some_and(|value| value.eq_ignore_ascii_case("true"))
+}
+
+fn is_process_success(result: &Result<(), StatsigErr>) -> bool {
+    result.is_ok()
+}
 // OB client -- END
 
 impl StatsigHttpSpecsAdapter {
@@ -332,9 +377,14 @@ impl StatsigHttpSpecsAdapter {
 
         let sync_start_ms = Utc::now().timestamp_millis() as u64;
         let mut deltas_used = self.use_deltas_next_request.load(Ordering::SeqCst);
-        let response = self
+        let mut response = self
             .fetch_specs_from_network(current_specs_info.clone(), trigger)
             .await;
+        let mut response_type = response
+            .as_mut()
+            .map_or(ConfigSyncResponseType::NetworkError, |response| {
+                ConfigSyncResponseType::from_response_data(&mut response.data)
+            });
         let (mut source_api, mut response_format, mut network_success) = match &response {
             Ok(response) => (
                 response.loggable_api.clone(),
@@ -360,7 +410,12 @@ impl StatsigHttpSpecsAdapter {
             log_d!(TAG, "Falling back to DCS CDN");
             let fallback_args = self.get_request_args(&current_specs_info, trigger);
             deltas_used = fallback_args.deltas_enabled;
-            let response = self.handle_fallback_request(fallback_args).await;
+            let mut response = self.handle_fallback_request(fallback_args).await;
+            response_type = response
+                .as_mut()
+                .map_or(ConfigSyncResponseType::NetworkError, |response| {
+                    ConfigSyncResponseType::from_response_data(&mut response.data)
+                });
             match &response {
                 Ok(response) => {
                     source_api = response.loggable_api.clone();
@@ -382,7 +437,7 @@ impl StatsigHttpSpecsAdapter {
             result = self.process_spec_data(response).await;
         }
 
-        let process_success = !matches!(result.as_ref(), Err(StatsigErr::NetworkError(_)));
+        let process_success = is_process_success(&result);
         log_config_sync_overall_latency(
             &self.ops_stats,
             sync_start_ms,
@@ -395,6 +450,7 @@ impl StatsigHttpSpecsAdapter {
                 .err()
                 .map_or_else(String::new, |e| e.to_string()),
             deltas_used,
+            response_type.as_str(),
         );
 
         result
@@ -698,6 +754,16 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_checksum_failure_is_not_process_success() {
+        let result = Err(StatsigErr::ChecksumFailure(
+            "simulated checksum failure".to_string(),
+        ));
+
+        assert!(!is_process_success(&result));
+        assert!(is_process_success(&Ok(())));
+    }
+
     #[test]
     fn test_fallback_uses_openai_cdn_for_non_default_specs_url() {
         let options = StatsigOptions {
@@ -713,6 +779,67 @@ mod tests {
         assert_eq!(adapter.fallback_url.as_deref(), Some(DEFAULT_SPECS_URL));
     }
 
+    #[test]
+    fn test_config_sync_response_type_delta() {
+        let mut headers = HashMap::new();
+        headers.insert("x-deltas-used".to_string(), "true".to_string());
+        let mut data = ResponseData::from_bytes_with_headers(
+            b"{\"has_updates\": false}".to_vec(),
+            Some(headers),
+        );
+
+        let response_type = ConfigSyncResponseType::from_response_data(&mut data);
+
+        assert_eq!(response_type.as_str(), "delta");
+    }
+
+    #[test]
+    fn test_config_sync_response_type_no_update() {
+        let mut data = ResponseData::from_bytes(b"{\"has_updates\": false}".to_vec());
+
+        let response_type = ConfigSyncResponseType::from_response_data(&mut data);
+
+        assert_eq!(response_type.as_str(), "no_update");
+        let response = data.deserialize_into::<SpecsResponseNoUpdates>().unwrap();
+        assert!(!response.has_updates);
+    }
+
+    #[test]
+    fn test_config_sync_response_type_no_update_with_delta_header() {
+        let mut headers = HashMap::new();
+        headers.insert("x-cache-hit".to_string(), "true".to_string());
+        headers.insert("x-deltas-used".to_string(), "true".to_string());
+        let mut data = ResponseData::from_bytes_with_headers(
+            b"{\"has_updates\": false}".to_vec(),
+            Some(headers),
+        );
+
+        let response_type = ConfigSyncResponseType::from_response_data(&mut data);
+
+        assert_eq!(response_type.as_str(), "no_update");
+    }
+
+    #[test]
+    fn test_config_sync_response_type_full() {
+        let mut data = ResponseData::from_bytes(b"{\"has_updates\": true}".to_vec());
+
+        let response_type = ConfigSyncResponseType::from_response_data(&mut data);
+
+        assert_eq!(response_type.as_str(), "full");
+    }
+
+    #[test]
+    fn test_config_sync_response_type_full_for_non_json_payload() {
+        let mut data = ResponseData::from_bytes(vec![0, 1, 2]);
+
+        let response_type = ConfigSyncResponseType::from_response_data(&mut data);
+
+        assert_eq!(response_type.as_str(), "full");
+        let mut first_byte = [1];
+        data.get_stream_mut().read_exact(&mut first_byte).unwrap();
+        assert_eq!(first_byte, [0]);
+    }
+
     #[test]
     fn test_get_response_format_json() {
         let mut headers = HashMap::new();