statsig-python-core 0.16.2rc2602202152__tar.gz → 0.16.3__tar.gz

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/Cargo.lock

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

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/Cargo.toml

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

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/PKG-INFO

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

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-pyo3/tests/test_observability_client.py

@@ -115,12 +115,15 @@ def test_observability_client_usage(statsig_setup):
     )
     assert dist_event is not None, "distribution() should have been called"
     assert isinstance(dist_event[2], float)
-    assert dist_event[3] == {
-        "init_success": "true",
-        "store_populated": "true",
-        "source": "Network",
-        "init_source_api": f"http://{httpserver.host}:{httpserver.port}/v2",
-    }
+    tags = dist_event[3]
+    assert tags is not None
+    assert tags["init_success"] == "true"
+    assert tags["store_populated"] == "true"
+    assert tags["source"] == "Network"
+    assert tags["sdk_key"] == "secret-key"
+    assert tags["sdk_type"] == "statsig-server-core-python"
+    assert tags["sdk_version"]
+    assert tags["init_source_api"] == f"http://{httpserver.host}:{httpserver.port}/v2"
 
 
 def test_error_callback_usage():

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/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.2-rc.2602202152", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.16.3", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/id_lists_adapter/statsig_http_id_lists_adapter.rs

@@ -127,6 +127,7 @@ impl StatsigHttpIdListsAdapter {
         &self,
         list_url: &str,
         list_size: u64,
+        id_list_file_id: Option<String>,
     ) -> Result<String, StatsigErr> {
         let (headers, query_params) = if list_url.starts_with(STATSIG_CDN_URL) {
             (
@@ -149,6 +150,7 @@ impl StatsigHttpIdListsAdapter {
                 url: list_url.to_string(),
                 headers,
                 query_params,
+                id_list_file_id,
                 diagnostics_key: Some(KeyType::GetIDList),
                 ..RequestArgs::new()
             })
@@ -407,6 +409,7 @@ impl StatsigHttpIdListsAdapter {
                 .fetch_individual_id_list_changes_from_network(
                     &new_metadata.url,
                     changeset.range_start,
+                    new_metadata.file_id.clone(),
                 )
                 .await;
 

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/networking/http_types.rs

@@ -17,6 +17,7 @@ pub struct RequestArgs {
     pub retries: u32, // 1 initial + N 'retries'
     pub headers: Option<HashMap<String, String>>,
     pub query_params: Option<HashMap<String, String>>,
+    pub id_list_file_id: Option<String>, // for logging
     pub deltas_enabled: bool,
     pub accept_gzip_response: bool,
     pub timeout_ms: u64,
@@ -41,6 +42,7 @@ impl RequestArgs {
             retries: 0,
             headers: None,
             query_params: None,
+            id_list_file_id: None,
             deltas_enabled: false,
             accept_gzip_response: false,
             timeout_ms: 0,

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/networking/network_client.rs

@@ -8,7 +8,9 @@ use crate::observability::observability_client_adapter::{MetricType, Observabili
 use crate::observability::ops_stats::{OpsStatsForInstance, OPS_STATS};
 use crate::observability::ErrorBoundaryEvent;
 use crate::sdk_diagnostics::marker::{ActionType, Marker, StepType};
-use crate::utils::{is_version_segment, split_host_and_path, strip_query_and_fragment};
+use crate::utils::{
+    get_loggable_sdk_key, is_version_segment, split_host_and_path, strip_query_and_fragment,
+};
 use crate::{log_d, log_i, log_w, StatsigOptions};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -26,7 +28,6 @@ const NON_RETRY_CODES: [u16; 6] = [
 const SHUTDOWN_ERROR: &str = "Request was aborted because the client is shutting down";
 
 const MAX_REQUEST_PATH_LENGTH: usize = 64;
-const LOGGABLE_KEY_PREFIX_LENGTH: usize = 13;
 const DOWNLOAD_CONFIG_SPECS_ENDPOINT: &str = "download_config_specs";
 const GET_ID_LISTS_ENDPOINT: &str = "get_id_lists";
 const DOWNLOAD_ID_LIST_FILE_ENDPOINT: &str = "download_id_list_file";
@@ -36,6 +37,7 @@ const STATUS_CODE_TAG: &str = "status_code";
 const IS_SUCCESS_TAG: &str = "is_success";
 const SDK_KEY_TAG: &str = "sdk_key";
 const SOURCE_SERVICE_TAG: &str = "source_service";
+const ID_LIST_FILE_ID_TAG: &str = "id_list_file_id";
 
 const TAG: &str = stringify!(NetworkClient);
 
@@ -189,7 +191,7 @@ impl NetworkClient {
                 .and_then(|data| data.get_header_ref("x-statsig-region").cloned());
             let success = (200..300).contains(&status.unwrap_or(0));
             let duration_ms = request_start.elapsed().as_millis() as f64;
-            self.log_network_request_latency_to_ob(&request_args.url, status, success, duration_ms);
+            self.log_network_request_latency_to_ob(&request_args, status, success, duration_ms);
 
             if let Some(key) = request_args.diagnostics_key {
                 let mut end_marker =
@@ -294,11 +296,12 @@ impl NetworkClient {
     // ------------------------------------------------------------
     fn log_network_request_latency_to_ob(
         &self,
-        url: &str,
+        request_args: &RequestArgs,
         status: Option<u16>,
         success: bool,
         duration_ms: f64,
     ) {
+        let url = request_args.url.as_str();
         if !should_log_network_request_latency(url) {
             return;
         }
@@ -306,24 +309,45 @@ impl NetworkClient {
         let status_code = status
             .map(|code| code.to_string())
             .unwrap_or("none".to_string());
-        let (source_service, request_path) = get_source_service_and_request_path(url);
+        let tags = get_network_request_latency_tags(
+            request_args,
+            status_code,
+            success,
+            self.loggable_sdk_key.clone(),
+        );
+
         self.ops_stats.log(ObservabilityEvent::new_event(
             MetricType::Dist,
             NETWORK_REQUEST_LATENCY_METRIC.to_string(),
             duration_ms,
-            Some(HashMap::from([
-                (REQUEST_PATH_TAG.to_string(), request_path),
-                (STATUS_CODE_TAG.to_string(), status_code),
-                (IS_SUCCESS_TAG.to_string(), success.to_string()),
-                (SDK_KEY_TAG.to_string(), self.loggable_sdk_key.clone()),
-                (SOURCE_SERVICE_TAG.to_string(), source_service),
-            ])),
+            Some(tags),
         ));
     }
 }
 
-fn get_loggable_sdk_key(sdk_key: &str) -> String {
-    sdk_key.chars().take(LOGGABLE_KEY_PREFIX_LENGTH).collect()
+fn get_network_request_latency_tags(
+    request_args: &RequestArgs,
+    status_code: String,
+    success: bool,
+    loggable_sdk_key: String,
+) -> HashMap<String, String> {
+    let (source_service, request_path) = get_source_service_and_request_path(&request_args.url);
+    let mut tags = HashMap::from([
+        (REQUEST_PATH_TAG.to_string(), request_path),
+        (STATUS_CODE_TAG.to_string(), status_code),
+        (IS_SUCCESS_TAG.to_string(), success.to_string()),
+        (SDK_KEY_TAG.to_string(), loggable_sdk_key),
+        (SOURCE_SERVICE_TAG.to_string(), source_service),
+    ]);
+    if let Some(id_list_file_id) = request_args
+        .id_list_file_id
+        .as_ref()
+        .filter(|id| !id.is_empty())
+    {
+        tags.insert(ID_LIST_FILE_ID_TAG.to_string(), id_list_file_id.clone());
+    }
+
+    tags
 }
 
 fn is_latency_loggable_endpoint(endpoint: &str) -> bool {
@@ -461,8 +485,10 @@ fn get_error_message_for_status(
 #[cfg(test)]
 mod tests {
     use super::{
-        get_request_path, get_source_service_and_request_path, should_log_network_request_latency,
+        get_network_request_latency_tags, get_request_path, get_source_service_and_request_path,
+        should_log_network_request_latency, ID_LIST_FILE_ID_TAG, REQUEST_PATH_TAG,
     };
+    use crate::networking::RequestArgs;
 
     #[test]
     fn test_get_request_path_with_sample_urls() {
@@ -511,4 +537,34 @@ mod tests {
         assert_eq!(source_service, "http://127.0.0.1:12345/mock-uuid");
         assert_eq!(request_path, "/v2/download_config_specs");
     }
+
+    #[test]
+    fn test_network_latency_tags_include_id_list_file_id_only_when_present() {
+        let mut request_args = RequestArgs {
+            url: "https://api.statsigcdn.com/v1/download_id_list_file/file-123".to_string(),
+            id_list_file_id: Some("file-123".to_string()),
+            ..RequestArgs::new()
+        };
+
+        let tags = get_network_request_latency_tags(
+            &request_args,
+            "200".to_string(),
+            true,
+            "client-key-123".to_string(),
+        );
+        assert_eq!(tags.get(ID_LIST_FILE_ID_TAG), Some(&"file-123".to_string()));
+        assert_eq!(
+            tags.get(REQUEST_PATH_TAG),
+            Some(&"/v1/download_id_list_file".to_string())
+        );
+
+        request_args.id_list_file_id = Some(String::new());
+        let tags_without_id = get_network_request_latency_tags(
+            &request_args,
+            "200".to_string(),
+            true,
+            "client-key-123".to_string(),
+        );
+        assert!(!tags_without_id.contains_key(ID_LIST_FILE_ID_TAG));
+    }
 }

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/observability/ops_stats.rs

@@ -1,5 +1,6 @@
 use super::{
-    observability_client_adapter::ObservabilityEvent, sdk_errors_observer::ErrorBoundaryEvent,
+    observability_client_adapter::{MetricType, ObservabilityEvent},
+    sdk_errors_observer::ErrorBoundaryEvent,
     DiagnosticsEvent,
 };
 use crate::user::StatsigUserLoggable;
@@ -131,6 +132,18 @@ impl OpsStatsForInstance {
         self.log(OpsStatsEvent::SDKError(error));
     }
 
+    pub fn log_checksum_validation_result(&self, is_success: bool) {
+        self.log(ObservabilityEvent::new_event(
+            MetricType::Increment,
+            "deltas_checksum_validation.count".to_string(),
+            1.0,
+            Some(HashMap::from([(
+                "result".to_string(),
+                if is_success { "success" } else { "failure" }.to_string(),
+            )])),
+        ));
+    }
+
     pub fn add_marker(&self, marker: Marker, context: Option<ContextType>) {
         self.log(OpsStatsEvent::Diagnostics(DiagnosticsEvent {
             marker: Some(marker),

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/specs_response/proto_specs.rs

@@ -33,6 +33,8 @@ pub fn deserialize_protobuf(
     next_specs: &mut SpecsResponseFull,
     data: &mut ResponseData,
 ) -> Result<(), StatsigErr> {
+    let mut parsed_envelopes_count = 0;
+
     let mut reader = ProtoStreamReader::new(data);
 
     if !next_specs.is_empty() {
@@ -45,14 +47,21 @@ pub fn deserialize_protobuf(
 
     loop {
         let proto_msg_bytes = reader.read_next_delimited_proto().map_err(|e| {
+            let sample = reader.sample_current_buf();
             let err = StatsigErr::ProtobufParseError(
                 "SpecsEnvelope".to_string(),
-                format!("Error reading next delimited proto: {}", e),
+                format!(
+                    "Error reading next delimited proto: {e}
+                    \n Previous Parsed Envelope Count: {parsed_envelopes_count}
+                    \n Current Buffer Sample: {sample}"
+                ),
             );
             log_error_to_statsig_and_console!(ops_stats, TAG, err);
             err
         })?;
 
+        parsed_envelopes_count += 1;
+
         let env: pb::SpecsEnvelope =
             match prost::Message::decode_length_delimited(proto_msg_bytes.as_ref()) {
                 Ok(env) => env,
@@ -105,13 +114,17 @@ pub fn deserialize_protobuf(
             pb::SpecsEnvelopeKind::Deletions => {
                 consume_errors(ops_stats, || next_specs.handle_deletions_update(env));
             }
-            pb::SpecsEnvelopeKind::Checksums => {
-                next_specs.handle_checksums_update(env).map_err(|e| {
-                    StatsigErr::ChecksumFailure(format!(
+            pb::SpecsEnvelopeKind::Checksums => match next_specs.handle_checksums_update(env) {
+                Ok(()) => {
+                    ops_stats.log_checksum_validation_result(true);
+                }
+                Err(e) => {
+                    ops_stats.log_checksum_validation_result(false);
+                    return Err(StatsigErr::ChecksumFailure(format!(
                         "Failed to apply protobuf checksums update: {e}"
-                    ))
-                })?;
-            }
+                    )));
+                }
+            },
             pb::SpecsEnvelopeKind::CopyPrev => {
                 consume_errors(ops_stats, || {
                     next_specs.handle_copy_prev_update(current_specs)

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/specs_response/proto_stream_reader.rs

@@ -40,7 +40,10 @@ impl<'a> ProtoStreamReader<'a> {
                     self.buf.extend_from_slice(&self.scratch[..n]);
                 }
                 Err(e) => {
-                    return Err(new_parse_err(e));
+                    return Err(StatsigErr::ProtobufParseError(
+                        "BrotliDecompressorRead".to_string(),
+                        e.to_string(),
+                    ));
                 }
             }
         }
@@ -48,32 +51,49 @@ impl<'a> ProtoStreamReader<'a> {
         Ok(self.buf.split_to(required_len))
     }
 
-    fn read_length_delimiter(&mut self) -> Result<usize, StatsigErr> {
-        let len_buf = &mut [0u8; 10];
-
-        let read_len = self
-            .brotli_decompressor
-            .read(len_buf)
-            .map_err(new_parse_err)?;
+    pub fn sample_current_buf(&self) -> String {
+        let len = std::cmp::min(self.buf.len(), 100);
+        let slice = &self.buf.as_ref()[..len];
+        String::from_utf8(slice.to_vec()).unwrap_or_default()
+    }
 
-        if read_len > 0 {
-            self.buf.extend_from_slice(&len_buf[..read_len]);
+    fn read_length_delimiter(&mut self) -> Result<usize, StatsigErr> {
+        loop {
+            match prost::decode_length_delimiter(self.buf.as_ref()) {
+                Ok(data_len) => {
+                    return Ok(prost::length_delimiter_len(data_len) + data_len);
+                }
+                Err(e) if self.buf.len() >= 10 => {
+                    return Err(StatsigErr::ProtobufParseError(
+                        "DecodeLengthDelimiter".to_string(),
+                        e.to_string(),
+                    ));
+                }
+                Err(_) => {
+                    let read_len =
+                        self.brotli_decompressor
+                            .read(&mut self.scratch)
+                            .map_err(|e| {
+                                StatsigErr::ProtobufParseError(
+                                    "ReadLengthDelimiter".to_string(),
+                                    e.to_string(),
+                                )
+                            })?;
+
+                    if read_len == 0 {
+                        return Err(StatsigErr::ProtobufParseError(
+                            "ReadLengthDelimiter".to_string(),
+                            "unexpected EOF while reading length delimiter".to_string(),
+                        ));
+                    }
+
+                    self.buf.extend_from_slice(&self.scratch[..read_len]);
+                }
+            }
         }
-
-        let data_len = prost::decode_length_delimiter(self.buf.as_ref()).map_err(new_parse_err)?;
-        let required_len = prost::length_delimiter_len(data_len) + data_len;
-
-        Ok(required_len)
     }
 }
 
-fn new_parse_err<E>(err_string: E) -> StatsigErr
-where
-    E: std::fmt::Display,
-{
-    StatsigErr::ProtobufParseError("BrotliDecompressor".to_string(), err_string.to_string())
-}
-
 struct StreamBorrower<'a> {
     stream: &'a mut dyn ResponseDataStream,
 }

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/statsig.rs

@@ -57,6 +57,7 @@ use crate::statsig_type_factories::{
 };
 use crate::statsig_types::{DynamicConfig, Experiment, FeatureGate, Layer, ParameterStore};
 use crate::user::StatsigUserInternal;
+use crate::utils::get_loggable_sdk_key;
 use crate::{
     dyn_value, log_d, log_e, log_w, read_lock_or_else, ClientInitResponseOptions,
     GCIRResponseFormat, IdListsAdapter, InitializeDetails, ObservabilityClient,
@@ -2503,6 +2504,7 @@ impl Statsig {
     ) {
         let is_store_populated = specs_info.source != SpecsSource::NoValues;
         let source_str = specs_info.source.to_string();
+        let metadata = StatsigMetadata::get_metadata();
 
         let event = ObservabilityEvent::new_event(
             MetricType::Dist,
@@ -2512,6 +2514,12 @@ impl Statsig {
                 ("init_success".to_owned(), success.to_string()),
                 ("source".to_owned(), source_str.clone()),
                 ("store_populated".to_owned(), is_store_populated.to_string()),
+                (
+                    "sdk_key".to_owned(),
+                    get_loggable_sdk_key(self.sdk_key.as_str()),
+                ),
+                ("sdk_type".to_owned(), metadata.sdk_type),
+                ("sdk_version".to_owned(), metadata.sdk_version),
                 (
                     "init_source_api".to_owned(),
                     specs_info.source_api.clone().unwrap_or_default(),

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/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.2-rc.2602202152";
+pub const SDK_VERSION: &str = "0.16.3";
 
 const TAG: &str = stringify!(StatsigMetadata);
 

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/src/utils/mod.rs

@@ -28,6 +28,12 @@ pub fn try_release_unused_heap_memory() {
     // No-op only glibc supports malloc_trim function
 }
 
+const LOGGABLE_KEY_PREFIX_LENGTH: usize = 13;
+
+pub(crate) fn get_loggable_sdk_key(sdk_key: &str) -> String {
+    sdk_key.chars().take(LOGGABLE_KEY_PREFIX_LENGTH).collect()
+}
+
 pub(crate) fn split_host_and_path(url: &str) -> (String, &str) {
     if let Some((scheme, after_scheme)) = url.split_once("://") {
         let (host, path) = after_scheme.split_once('/').unwrap_or((after_scheme, ""));

{statsig_python_core-0.16.2rc2602202152 → statsig_python_core-0.16.3}/statsig-rust/tests/observability_client_usage_tests.rs

@@ -16,8 +16,16 @@ use crate::utils::helpers::load_contents;
 use utils::mock_scrapi::{Endpoint, EndpointStub, Method, MockScrapi, StubData};
 
 const SDK_KEY: &str = "secret-key";
+const LONG_SDK_KEY: &str = "secret-key-123456789";
 
 async fn setup(observability_client: &Arc<MockObservabilityClient>) -> (MockScrapi, Statsig) {
+    setup_with_sdk_key(observability_client, SDK_KEY).await
+}
+
+async fn setup_with_sdk_key(
+    observability_client: &Arc<MockObservabilityClient>,
+    sdk_key: &str,
+) -> (MockScrapi, Statsig) {
     std::env::set_var("STATSIG_RUNNING_TESTS", "true");
     let mock_scrapi = MockScrapi::new().await;
 
@@ -45,7 +53,7 @@ async fn setup(observability_client: &Arc<MockObservabilityClient>) -> (MockScra
 
     let weak_obs_client = Arc::downgrade(observability_client) as Weak<dyn ObservabilityClient>;
     let statsig = Statsig::new(
-        SDK_KEY,
+        sdk_key,
         Some(Arc::new(StatsigOptions {
             observability_client: Some(weak_obs_client),
             log_event_url: Some(mock_scrapi.url_for_endpoint(Endpoint::LogEvent)),
@@ -301,7 +309,7 @@ async fn test_sdk_initialization_dist_recorded() {
         calls: Mutex::new(Vec::new()),
     });
 
-    let (_, statsig) = setup(&obs_client).await;
+    let (_, statsig) = setup_with_sdk_key(&obs_client, LONG_SDK_KEY).await;
 
     statsig.initialize().await.unwrap();
     statsig.check_gate(&StatsigUser::with_user_id("test_user"), "test_gate");
@@ -331,6 +339,12 @@ async fn test_sdk_initialization_dist_recorded() {
     assert_eq!(tags.get("source"), Some(&"Network".to_string()));
     assert_eq!(tags.get("init_success"), Some(&"true".to_string()));
     assert_eq!(tags.get("store_populated"), Some(&"true".to_string()));
+    assert_eq!(tags.get("sdk_key"), Some(&"secret-key-12".to_string()));
+    assert_eq!(
+        tags.get("sdk_type"),
+        Some(&"statsig-server-core".to_string())
+    );
+    assert!(tags.get("sdk_version").is_some_and(|v| !v.is_empty()));
 }
 
 #[tokio::test]
@@ -670,6 +684,12 @@ async fn test_init_from_network() {
     assert_eq!(tags.get("source"), Some(&"Network".to_string()));
     assert_eq!(tags.get("init_success"), Some(&"true".to_string()));
     assert_eq!(tags.get("store_populated"), Some(&"true".to_string()));
+    assert_eq!(tags.get("sdk_key"), Some(&SDK_KEY.to_string()));
+    assert_eq!(
+        tags.get("sdk_type"),
+        Some(&"statsig-server-core".to_string())
+    );
+    assert!(tags.get("sdk_version").is_some_and(|v| !v.is_empty()));
     assert_eq!(
         tags.get("init_source_api"),
         Some(&mock_scrapi.get_server_api())