statsig-python-core 0.15.1rc2601270136__tar.gz → 0.15.2rc2602030138__tar.gz

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/Cargo.lock

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

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/Cargo.toml

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

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.15.1rc2601270136
+Version: 0.15.2rc2602030138
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/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.15.1-rc.2601270136", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.15.2-rc.2602030138", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/evaluation/cmab_evaluator.rs

@@ -185,13 +185,15 @@ fn get_passes_targeting<'a>(ctx: &mut EvaluatorContext<'a>, cmab: &'a CMABConfig
         Err(_) => false,
     };
 
-    let expo = SecondaryExposure {
-        gate: targeting_gate_name.clone(),
-        gate_value: InternedString::from_bool(result),
-        rule_id: ctx.result.rule_id.clone().unwrap_or_default(),
-    };
+    if !&targeting_gate_name.starts_with("segment:") {
+        let expo = SecondaryExposure {
+            gate: targeting_gate_name.clone(),
+            gate_value: InternedString::from_bool(result),
+            rule_id: ctx.result.rule_id.clone().unwrap_or_default(),
+        };
 
-    ctx.result.secondary_exposures.push(expo);
+        ctx.result.secondary_exposures.push(expo);
+    }
 
     result
 }

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/evaluation/comparisons/compare_str_with_regex.rs

@@ -1,15 +1,26 @@
-use crate::{evaluation::evaluator_value::MemoizedEvaluatorValue, unwrap_or_return, DynamicValue};
+use crate::{
+    evaluation::evaluator_value::MemoizedEvaluatorValue, log_w, unwrap_or_return, DynamicValue,
+};
+
+const TAG: &str = "CompareStrWithRegex";
 
 pub(crate) fn compare_str_with_regex(
     value: &DynamicValue,
     regex_value: &MemoizedEvaluatorValue,
 ) -> bool {
     let value_str = unwrap_or_return!(&value.string_value, false);
-    if let Some(regex) = &regex_value.regex_value {
-        return regex.is_match(&value_str.value).unwrap_or(false);
-    }
-
-    false
+    let regex = match &regex_value.regex_value {
+        Some(regex) => regex,
+        None => {
+            log_w!(
+                TAG,
+                "No regex value found. 'str_matches' operators require a call to EvaluatorValue::compile_regex() on the target value."
+            );
+            return false;
+        }
+    };
+
+    regex.is_match(&value_str.value).unwrap_or(false)
 }
 
 #[cfg(test)]

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/evaluation/evaluator.rs

@@ -619,13 +619,18 @@ fn evaluate_nested_gate<'a>(
         .unwrap_or(InternedString::empty_ref());
 
     match ctx.nested_gate_memo.get(gate_name) {
-        Some((previous_bool, previous_rule_id)) => {
+        Some((previous_bool, previous_rule_id, previous_secondary_exposures)) => {
             ctx.result.bool_value = *previous_bool;
             ctx.result.rule_id = previous_rule_id.clone();
+            ctx.result
+                .secondary_exposures
+                .extend_from_slice(previous_secondary_exposures);
         }
         None => {
             ctx.prep_for_nested_evaluation()?;
 
+            let mut current_exposures = std::mem::take(&mut ctx.result.secondary_exposures);
+
             let _ = Evaluator::evaluate(ctx, gate_name.as_str(), &SpecType::Gate)?;
 
             if ctx.result.unsupported {
@@ -635,13 +640,27 @@ fn evaluate_nested_gate<'a>(
             if !gate_name.as_str().is_empty() {
                 ctx.nested_gate_memo.insert(
                     gate_name.clone(),
-                    (ctx.result.bool_value, ctx.result.rule_id.clone()),
+                    (
+                        ctx.result.bool_value,
+                        ctx.result.rule_id.clone(),
+                        ctx.result.secondary_exposures.clone(),
+                    ),
                 );
             }
+
+            std::mem::swap(&mut ctx.result.secondary_exposures, &mut current_exposures);
+            ctx.result
+                .secondary_exposures
+                .extend_from_slice(&current_exposures);
         }
     }
 
-    if !&gate_name.starts_with("segment:") {
+    let is_empty_rule_id = match &ctx.result.rule_id {
+        Some(id) => id.as_str().is_empty(),
+        None => true,
+    };
+
+    if !&gate_name.starts_with("segment:") && !is_empty_rule_id {
         let res = &ctx.result;
         let expo = SecondaryExposure {
             gate: gate_name.clone(),

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/evaluation/evaluator_context.rs

@@ -9,12 +9,13 @@ use crate::interned_string::InternedString;
 use crate::specs_response::spec_types::{Rule, Spec, SpecsResponseFull};
 use crate::user::StatsigUserInternal;
 use crate::StatsigErr::StackOverflowError;
-use crate::{OverrideAdapter, Statsig, StatsigErr};
+use crate::{OverrideAdapter, SecondaryExposure, Statsig, StatsigErr};
 
 const MAX_RECURSIVE_DEPTH: u16 = 300;
 
-// (gate_name, (bool_value, rule_id))
-type NestedGateMemo = HashMap<InternedString, (bool, Option<InternedString>)>;
+// (gate_name, (bool_value, rule_id, secondary_exposures))
+type NestedGateMemo =
+    HashMap<InternedString, (bool, Option<InternedString>, Vec<SecondaryExposure>)>;
 
 pub enum IdListResolution<'a> {
     MapLookup(&'a HashMap<String, IdList>),

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/event_logging/event_logger.rs

@@ -27,10 +27,15 @@ use std::{
 };
 use tokio::sync::{Notify, Semaphore};
 
+pub const MIN_BATCH_SIZE: u32 = 10;
+pub const MAX_BATCH_SIZE: u32 = 2000;
+
+pub const MIN_PENDING_BATCH_COUNT: u32 = 1;
+pub const DEFAULT_PENDING_BATCH_COUNT_MAX: u32 = 100;
+
 const BG_LOOP_TAG: &str = "EVT_LOG_BG_LOOP";
 const LIMIT_FLUSH_TAG: &str = "EVT_LOG_LIMIT_FLUSH";
-const DEFAULT_BATCH_SIZE: u32 = 2000;
-const DEFAULT_PENDING_BATCH_MAX: u32 = 100;
+const DEFAULT_BATCH_SIZE: u32 = MAX_BATCH_SIZE;
 const MAX_LIMIT_FLUSH_TASKS: usize = 5;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -69,7 +74,7 @@ impl EventLogger {
                     .unwrap_or(DEFAULT_BATCH_SIZE),
                 options
                     .event_logging_max_pending_batch_queue_size
-                    .unwrap_or(DEFAULT_PENDING_BATCH_MAX),
+                    .unwrap_or(DEFAULT_PENDING_BATCH_COUNT_MAX),
             ),
             event_sampler: ExposureSampling::new(sdk_key),
             flush_interval: FlushInterval::new(),

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/gcir/param_stores_processor.rs

@@ -6,7 +6,7 @@ use crate::{
     hashing,
     specs_response::param_store_types::{
         DynamicConfigParameter, ExperimentParameter, GateParameter, LayerParameter, Parameter,
-        ParameterStore,
+        ParameterStore, StaticValueParameter,
     },
     ClientInitResponseOptions, HashAlgorithm,
 };
@@ -73,12 +73,19 @@ fn get_parameters_from_store(
     let mut parameters: HashMap<String, Parameter> = HashMap::new();
     for (param_name, param) in &store.parameters {
         match param {
-            Parameter::StaticValue(_static_value) => {
-                parameters.insert(param_name.clone(), param.clone());
+            Parameter::StaticValue(static_value) => {
+                let new_param = StaticValueParameter {
+                    name: param_name.clone().into(),
+                    param_type: static_value.param_type.clone(),
+                    ref_type: static_value.ref_type.clone(),
+                    value: static_value.value.clone(),
+                };
+                parameters.insert(param_name.clone(), Parameter::StaticValue(new_param));
             }
 
             Parameter::Gate(gate) => {
                 let new_param = GateParameter {
+                    name: param_name.clone().into(),
                     ref_type: gate.ref_type.clone(),
                     param_type: gate.param_type.clone(),
                     gate_name: context.hashing.hash(&gate.gate_name, hash_used),
@@ -90,6 +97,7 @@ fn get_parameters_from_store(
 
             Parameter::DynamicConfig(dynamic_config) => {
                 let new_param = DynamicConfigParameter {
+                    name: param_name.clone().into(),
                     ref_type: dynamic_config.ref_type.clone(),
                     param_type: dynamic_config.param_type.clone(),
                     config_name: context.hashing.hash(&dynamic_config.config_name, hash_used),
@@ -100,6 +108,7 @@ fn get_parameters_from_store(
 
             Parameter::Experiment(experiment) => {
                 let new_param = ExperimentParameter {
+                    name: param_name.clone().into(),
                     ref_type: experiment.ref_type.clone(),
                     param_type: experiment.param_type.clone(),
                     experiment_name: context.hashing.hash(&experiment.experiment_name, hash_used),
@@ -110,6 +119,7 @@ fn get_parameters_from_store(
 
             Parameter::Layer(layer) => {
                 let new_param = LayerParameter {
+                    name: param_name.clone().into(),
                     ref_type: layer.ref_type.clone(),
                     param_type: layer.param_type.clone(),
                     layer_name: context.hashing.hash(&layer.layer_name, hash_used),

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/id_lists_adapter/id_lists_adapter_trait.rs

@@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct IdListMetadata {
+    #[serde(alias = "key")]
     pub name: String,
     pub url: String,
 

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/id_lists_adapter/statsig_http_id_lists_adapter.rs

@@ -1,6 +1,7 @@
 use super::IdListMetadata;
 use crate::id_lists_adapter::{IdListUpdate, IdListsAdapter, IdListsUpdateListener};
 use crate::networking::{NetworkClient, NetworkError, RequestArgs, Response, 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;
@@ -85,35 +86,33 @@ impl StatsigHttpIdListsAdapter {
             ..RequestArgs::new()
         };
 
-        let initial_err = if self.is_cdn_url() {
-            match self.network.get(request_args.clone()).await {
-                Ok(response) => return self.parse_response(response.data),
-                Err(e) => e,
-            }
+        let result = if self.is_cdn_url() {
+            self.network.get(request_args.clone()).await
         } else {
-            match self.network.post(request_args.clone(), None).await {
-                Ok(response) => return self.parse_response(response.data),
-                Err(e) => e,
-            }
+            self.network.post(request_args.clone(), None).await
         };
 
-        if !matches!(initial_err, NetworkError::RetriesExhausted(_, _, _, _)) {
-            return Err(StatsigErr::NetworkError(initial_err));
-        }
+        let result = match result {
+            Ok(response) => self.parse_response(response.data),
+            Err(initial_err) => {
+                self.handle_manifest_network_error(request_args, initial_err)
+                    .await
+            }
+        };
 
-        // attempt fallback
-        let mut fallback_err = None;
-        if let Some(fallback_url) = &self.fallback_url {
-            fallback_err = match self
-                .handle_fallback_request(fallback_url, request_args)
-                .await
-            {
-                Ok(response) => return self.parse_response(response.data),
-                Err(e) => Some(e),
-            };
-        }
+        let (metric_name, metric_value) = if result.is_ok() {
+            ("id_list_manifest_download_success", 1.0)
+        } else {
+            ("id_list_manifest_download_failure", 1.0)
+        };
+        self.ops_stats.log(ObservabilityEvent::new_event(
+            MetricType::Increment,
+            metric_name.to_string(),
+            metric_value,
+            None,
+        ));
 
-        Err(fallback_err.unwrap_or(StatsigErr::NetworkError(initial_err)))
+        result
     }
 
     async fn fetch_individual_id_list_changes_from_network(
@@ -142,23 +141,54 @@ impl StatsigHttpIdListsAdapter {
                 url: list_url.to_string(),
                 headers,
                 query_params,
+                diagnostics_key: Some(KeyType::GetIDList),
                 ..RequestArgs::new()
             })
-            .await
-            .map_err(StatsigErr::NetworkError)?;
+            .await;
+
+        let response = match response {
+            Ok(response) => response,
+            Err(err) => {
+                return Err(StatsigErr::NetworkError(err));
+            }
+        };
+
+        self.add_diagnostics_start_marker(
+            KeyType::GetIDList,
+            StepType::Process,
+            None,
+            Some(list_url.to_string()),
+        );
 
         let mut response_body = match response.data {
             Some(data) => data,
             None => {
                 let msg = "No ID List changes from network".to_string();
+                self.add_diagnostics_end_marker(
+                    KeyType::GetIDList,
+                    StepType::Process,
+                    false,
+                    None,
+                    Some(list_url.to_string()),
+                );
                 return Err(StatsigErr::JsonParseError("IdList".to_string(), msg));
             }
         };
 
-        response_body.read_to_string().map_err(|err| {
+        let result = response_body.read_to_string().map_err(|err| {
             let msg = format!("Failed to parse ID List changes: {err:?}");
             StatsigErr::JsonParseError("IdList".to_string(), msg)
-        })
+        });
+
+        self.add_diagnostics_end_marker(
+            KeyType::GetIDList,
+            StepType::Process,
+            result.is_ok(),
+            None,
+            Some(list_url.to_string()),
+        );
+
+        result
     }
 
     async fn handle_fallback_request(
@@ -177,6 +207,28 @@ impl StatsigHttpIdListsAdapter {
         }
     }
 
+    async fn handle_manifest_network_error(
+        &self,
+        request_args: RequestArgs,
+        initial_err: NetworkError,
+    ) -> Result<IdListsResponse, StatsigErr> {
+        if !matches!(initial_err, NetworkError::RetriesExhausted(_, _, _, _)) {
+            return Err(StatsigErr::NetworkError(initial_err));
+        }
+
+        if let Some(fallback_url) = &self.fallback_url {
+            return match self
+                .handle_fallback_request(fallback_url, request_args)
+                .await
+            {
+                Ok(response) => self.parse_response(response.data),
+                Err(e) => Err(e),
+            };
+        }
+
+        Err(StatsigErr::NetworkError(initial_err))
+    }
+
     async fn run_background_sync(weak_self: &Weak<Self>) {
         let strong_self = match weak_self.upgrade() {
             Some(s) => s,
@@ -268,13 +320,10 @@ impl StatsigHttpIdListsAdapter {
 
         let mut changes = HashMap::new();
 
-        self.ops_stats.add_marker(
-            Marker::new(
-                KeyType::GetIDListSources,
-                ActionType::Start,
-                Some(StepType::Process),
-            )
-            .with_id_list_count(new_manifest.len()),
+        self.add_diagnostics_start_marker(
+            KeyType::GetIDListSources,
+            StepType::Process,
+            Some(new_manifest.len()),
             None,
         );
 
@@ -356,18 +405,64 @@ impl StatsigHttpIdListsAdapter {
             }
         };
 
-        self.ops_stats.add_marker(
-            Marker::new(
-                KeyType::GetIDListSources,
-                ActionType::End,
-                Some(StepType::Process),
-            )
-            .with_is_success(result.is_ok()),
+        self.add_diagnostics_end_marker(
+            KeyType::GetIDListSources,
+            StepType::Process,
+            result.is_ok(),
+            None,
             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,
+        ));
+
         result
     }
+
+    // ---- Helper functions for monioring ID List ----
+    fn add_diagnostics_start_marker(
+        &self,
+        key: KeyType,
+        step: StepType,
+        id_list_count: Option<usize>,
+        url: Option<String>,
+    ) {
+        let mut marker = Marker::new(key, ActionType::Start, Some(step));
+        if let Some(count) = id_list_count {
+            marker = marker.with_id_list_count(count);
+        }
+        if let Some(url) = url {
+            marker = marker.with_url(url);
+        }
+        self.ops_stats.add_marker(marker, None);
+    }
+
+    fn add_diagnostics_end_marker(
+        &self,
+        key: KeyType,
+        step: StepType,
+        success: bool,
+        status_code: Option<u16>,
+        url: Option<String>,
+    ) {
+        let mut marker = Marker::new(key, ActionType::End, Some(step)).with_is_success(success);
+        if let Some(status_code) = status_code {
+            marker = marker.with_status_code(status_code);
+        }
+        if let Some(url) = url {
+            marker = marker.with_url(url);
+        }
+        self.ops_stats.add_marker(marker, None);
+    }
 }
 
 struct IdListChangeSet {
@@ -384,7 +479,10 @@ impl IdListsAdapter for StatsigHttpIdListsAdapter {
         listener: Arc<dyn IdListsUpdateListener + Send + Sync>,
     ) -> Result<(), StatsigErr> {
         self.set_listener(listener);
-        self.sync_id_lists().await?;
+        self.ops_stats
+            .set_diagnostics_context(ContextType::Initialize);
+        let result = self.sync_id_lists().await;
+        result?;
         Ok(())
     }
 

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/override_adapter/statsig_local_override_adapter.rs

@@ -232,6 +232,7 @@ impl OverrideAdapter for StatsigLocalOverrideAdapter {
                     ref_type: "static".to_string(),
                     param_type: infer_param_type(&param_value).to_string(),
                     value: param_value,
+                    name: None,
                 }),
             };
             parameters.insert(param_name, parameter);

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/spec_store.rs

@@ -506,7 +506,10 @@ impl IdListsUpdateListener for SpecStore {
                 .map(|(key, list)| (key.clone(), list.metadata.clone()))
                 .collect(),
             None => {
-                log_e!(TAG, "Failed to acquire read lock: Failed to lock data");
+                let err = StatsigErr::LockFailure(
+                    "Failed to acquire read lock for id list metadata".to_string(),
+                );
+                log_error_to_statsig_and_console!(self.ops_stats, TAG, err);
                 HashMap::new()
             }
         }
@@ -519,7 +522,10 @@ impl IdListsUpdateListener for SpecStore {
         let mut data = match self.data.try_write_for(Duration::from_secs(5)) {
             Some(data) => data,
             None => {
-                log_e!(TAG, "Failed to acquire write lock: Failed to lock data");
+                let err = StatsigErr::LockFailure(
+                    "Failed to acquire write lock for id list updates".to_string(),
+                );
+                log_error_to_statsig_and_console!(self.ops_stats, TAG, err);
                 return;
             }
         };

{statsig_python_core-0.15.1rc2601270136 → statsig_python_core-0.15.2rc2602030138}/statsig-rust/src/specs_response/__tests__/proto_specs_vs_json_tests.rs

@@ -4,6 +4,7 @@ use assert_json_diff::{CompareMode, Config, NumericMode};
 use serde_json::{json, Value};
 
 use crate::{
+    interned_str,
     interned_string::InternedString,
     networking::ResponseData,
     observability::ops_stats::OpsStatsForInstance,
@@ -222,15 +223,36 @@ fn test_a_param_store_json_vs_proto() {
     let mut proto_spec = get_proto_spec_param_store("test_parameter_store");
     proto_spec.remove("checksum");
 
-    let mut json_spec = get_json_spec("param_stores", "test_parameter_store").clone();
+    let json_spec = get_json_spec("param_stores", "test_parameter_store").clone();
 
-    // the 'name' field is redundant, so we didn't include it in the Protobuf schema
-    json_spec["parameters"]["bool_param"]
-        .as_object_mut()
+    assert_json_diff::assert_json_matches!(proto_spec, json_spec, get_json_compare_config());
+}
+
+#[test]
+fn test_regex_compilation() {
+    let proto_specs = get_deserialized_specs(EVAL_PROJ_PROTO_BYTES);
+    let json_specs = serde_json::from_slice::<SpecsResponseFull>(EVAL_PROJ_JSON_BYTES).unwrap();
+
+    // str_matches condition for test_string_comparisons gate
+    let key = interned_str!("998446160");
+    let proto_condition = proto_specs.condition_map.get(&key).unwrap();
+    let json_condition = json_specs.condition_map.get(&key).unwrap();
+
+    assert!(proto_condition
+        .target_value
+        .as_ref()
         .unwrap()
-        .remove("name");
+        .as_ref()
+        .regex_value
+        .is_some());
 
-    assert_json_diff::assert_json_matches!(proto_spec, json_spec, get_json_compare_config());
+    assert!(json_condition
+        .target_value
+        .as_ref()
+        .unwrap()
+        .as_ref()
+        .regex_value
+        .is_some());
 }
 
 fn deserialize_from(