oai-statsig-python-core 0.25.0rc8__tar.gz → 0.26.0__tar.gz

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/Cargo.lock

@@ -1722,7 +1722,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1737,7 +1737,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1756,6 +1756,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "log",
+ "memchr",
  "memmap2",
  "mockito",
  "more-asserts",
@@ -3011,7 +3012,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "napi",
@@ -3026,7 +3027,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3041,7 +3042,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "oai-statsig-rust",
@@ -3054,7 +3055,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.25.0-rc.8"
+version = "0.26.0"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/Cargo.toml

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

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.25.0rc8
+Version: 0.26.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-pyo3/tests/test_data_store.py

@@ -222,6 +222,12 @@ def test_data_store_usage_get(statsig_setup):
     assert gate.details.reason == "Adapter(DataStore):Recognized"
     assert gate.value == True
     assert gate.details.lcut == known_lcut
+
+    for _ in range(100):
+        if data_store.get_called_count >= 2:
+            break
+        sleep(0.05)
+
     assert data_store.get_called_count > 1
 
 

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/Cargo.toml

@@ -23,6 +23,7 @@ futures = "0.3.30"
 indexmap = { version = "2.13.0", features = ["serde"], optional = true }
 lazy_static = "1.5.0"
 log = "0.4.22"
+memchr = "2.7.4"
 parking_lot = "0.12.1"
 percent-encoding = "2.3.1"
 rand = "0.8.4"
@@ -43,7 +44,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.25.0-rc.8", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.26.0", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/comparisons/compare_strings_in_array.rs

@@ -88,7 +88,7 @@ fn compare_strings_in_array_impl(
             ConditionOperator::StrStartsWithAny => left.starts_with(right.as_str()),
             ConditionOperator::StrEndsWithAny => left.ends_with(right.as_str()),
             ConditionOperator::StrContainsAny | ConditionOperator::StrContainsNone => {
-                left.contains(right.as_str())
+                contains_substring(left, right.as_str())
             }
             _ => false, // todo: unsupported?
         };
@@ -101,6 +101,15 @@ fn compare_strings_in_array_impl(
     comparison_result
 }
 
+#[inline]
+fn contains_substring(haystack: &str, needle: &str) -> bool {
+    if needle.len() <= 1 {
+        return haystack.contains(needle);
+    }
+
+    memchr::memmem::find(haystack.as_bytes(), needle.as_bytes()).is_some()
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::json;
@@ -180,6 +189,61 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_str_contains_none() {
+        let value = dyn_value!("daniel@statsig.io");
+        let matching_targets = test_only_make_eval_value!(vec!["@example.com", "@statsig.io"]);
+        let missing_targets = test_only_make_eval_value!(vec!["@example.com", "@statsig.com"]);
+
+        assert!(!compare_strings_in_array(
+            (&value).into(),
+            &matching_targets,
+            ConditionOperator::StrContainsNone
+        ));
+        assert!(compare_strings_in_array(
+            (&value).into(),
+            &missing_targets,
+            ConditionOperator::StrContainsNone
+        ));
+    }
+
+    #[test]
+    fn test_substring_search_matches_std_for_utf8_and_edge_cases() {
+        let haystacks = [
+            "",
+            "a",
+            "daniel@statsig.io",
+            "café au lait",
+            "東京都",
+            "a💖b",
+            "Straße",
+            "embedded\0null",
+        ];
+        let needles = [
+            "",
+            "a",
+            "@statsig.io",
+            "@example.com",
+            "é",
+            "京",
+            "💖",
+            "ss",
+            "ß",
+            "\0",
+            "null",
+        ];
+
+        for haystack in haystacks {
+            for needle in needles {
+                assert_eq!(
+                    super::contains_substring(haystack, needle),
+                    haystack.contains(needle),
+                    "haystack={haystack:?}, needle={needle:?}"
+                );
+            }
+        }
+    }
+
     #[test]
     fn test_str_none_case_sensitive() {
         let haystack = test_only_make_eval_value!(vec!["HELLO", "WORLD"]);

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluation_types.rs

@@ -342,32 +342,18 @@ fn hash_parameter_rule_ids(parameter_rule_ids: &HashMap<InternedString, Interned
     param_rule_ids_hash.finish()
 }
 
-pub(crate) fn push_optional_version_hash_values(hash_array: &mut Vec<u64>, version: &Option<u32>) {
-    hash_array.push(version.is_some() as u64);
-    hash_array.push(version.map_or(0, u64::from));
-}
-
 fn optional_version_hash_values(version: &Option<u32>) -> [u64; 2] {
     [version.is_some() as u64, version.map_or(0, u64::from)]
 }
 
 #[cfg(test)]
 mod tests {
-    use super::push_optional_version_hash_values;
+    use super::optional_version_hash_values;
 
     #[test]
     fn optional_version_hash_values_distinguish_missing_from_zero() {
-        let mut missing = Vec::new();
-        push_optional_version_hash_values(&mut missing, &None);
-
-        let mut zero = Vec::new();
-        push_optional_version_hash_values(&mut zero, &Some(0));
-
-        let mut one = Vec::new();
-        push_optional_version_hash_values(&mut one, &Some(1));
-
-        assert_eq!(missing, vec![0, 0]);
-        assert_eq!(zero, vec![1, 0]);
-        assert_eq!(one, vec![1, 1]);
+        assert_eq!(optional_version_hash_values(&None), [0, 0]);
+        assert_eq!(optional_version_hash_values(&Some(0)), [1, 0]);
+        assert_eq!(optional_version_hash_values(&Some(1)), [1, 1]);
     }
 }

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluation_types_initialize_v2.rs

@@ -30,7 +30,7 @@ pub struct GateEvaluationInitV2 {
 
 impl GCIRHashable for GateEvaluationInitV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let hash_array = vec![
+        let hash_array = [
             name.hash,
             match self.value {
                 Some(true) => 1,
@@ -42,7 +42,7 @@ impl GCIRHashable for GateEvaluationInitV2 {
             },
             hash_secondary_exposures(&self.base.secondary_exposures),
         ];
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -62,7 +62,7 @@ pub struct DynamicConfigEvaluationInitV2 {
 
 impl GCIRHashable for DynamicConfigEvaluationInitV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let hash_array = vec![
+        let hash_array = [
             name.hash,
             self.value.hash,
             match self.base.rule_id {
@@ -72,7 +72,7 @@ impl GCIRHashable for DynamicConfigEvaluationInitV2 {
             hash_secondary_exposures(&self.base.secondary_exposures),
             if self.passed { 1 } else { 0 },
         ];
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -99,7 +99,7 @@ pub struct ExperimentEvaluationInitV2 {
 
 impl GCIRHashable for ExperimentEvaluationInitV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let hash_array = vec![
+        let hash_array = [
             name.hash,
             self.value.hash,
             match self.base.rule_id {
@@ -112,7 +112,7 @@ impl GCIRHashable for ExperimentEvaluationInitV2 {
             opt_bool_to_hashable(&self.is_user_in_experiment),
         ];
 
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -163,7 +163,7 @@ pub struct LayerEvaluationInitV2 {
 
 impl GCIRHashable for LayerEvaluationInitV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let mut hash_array = vec![
+        let hash_array = [
             name.hash,
             self.value.hash,
             match self.base.rule_id {
@@ -177,27 +177,21 @@ impl GCIRHashable for LayerEvaluationInitV2 {
             self.allocated_experiment_name
                 .as_ref()
                 .map_or(0, |n| n.hash),
+            hash_secondary_exposures(&self.undelegated_secondary_exposures),
         ];
-        let mut explicit_params_hashes = Vec::new();
-        if let Some(explicit_parameters) = &self.explicit_parameters {
-            for value in explicit_parameters.to_vec_interned() {
-                explicit_params_hashes.push(value.hash);
-            }
-        }
-        hash_array.push(hash_secondary_exposures(
-            &self.undelegated_secondary_exposures,
-        ));
 
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
 fn hash_secondary_exposures(exposures: &Option<Vec<InternedString>>) -> u64 {
-    let mut secondary_exposure_hashes = Vec::new();
-    if let Some(exposures) = exposures {
-        for exposure in exposures {
-            secondary_exposure_hashes.push(exposure.hash);
-        }
+    let Some(exposures) = exposures else {
+        return hashing::hash_u64_slice(&[]);
+    };
+
+    let mut secondary_exposure_hashes = hashing::U64HashBuilder::with_capacity(exposures.len());
+    for exposure in exposures {
+        secondary_exposure_hashes.push(exposure.hash);
     }
-    hashing::hash_one(secondary_exposure_hashes)
+    secondary_exposure_hashes.finish()
 }

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluation_types_v2.rs

@@ -3,8 +3,7 @@ use crate::gcir::gcir_formatter::GCIRHashable;
 use crate::hashing::opt_bool_to_hashable;
 use crate::interned_string::InternedString;
 use crate::{
-    evaluation::evaluation_types::{is_false, push_optional_version_hash_values},
-    specs_response::explicit_params::ExplicitParameters,
+    evaluation::evaluation_types::is_false, specs_response::explicit_params::ExplicitParameters,
 };
 use crate::{hashing, SecondaryExposure};
 use serde::{Deserialize, Serialize};
@@ -29,14 +28,16 @@ pub struct GateEvaluationV2 {
 
 impl GCIRHashable for GateEvaluationV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let mut hash_array = vec![
+        let version_hashes = optional_version_hash_values(&self.base.version);
+        let hash_array = [
             name.hash,
             self.value as u64,
             self.base.rule_id.hash,
             hash_secondary_exposures(&self.base.secondary_exposures),
+            version_hashes[0],
+            version_hashes[1],
         ];
-        push_optional_version_hash_values(&mut hash_array, &self.base.version);
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -56,15 +57,17 @@ pub struct DynamicConfigEvaluationV2 {
 
 impl GCIRHashable for DynamicConfigEvaluationV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let mut hash_array = vec![
+        let version_hashes = optional_version_hash_values(&self.base.version);
+        let hash_array = [
             name.hash,
             self.value.get_hash(),
             self.base.rule_id.hash,
             hash_secondary_exposures(&self.base.secondary_exposures),
             self.passed as u64,
+            version_hashes[0],
+            version_hashes[1],
         ];
-        push_optional_version_hash_values(&mut hash_array, &self.base.version);
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -99,26 +102,22 @@ pub struct ExperimentEvaluationV2 {
 
 impl GCIRHashable for ExperimentEvaluationV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let mut hash_array = vec![
+        let version_hashes = optional_version_hash_values(&self.base.version);
+        let hash_array = [
             name.hash,
             self.value.get_hash(),
             self.base.rule_id.hash,
             hash_secondary_exposures(&self.base.secondary_exposures),
             self.is_in_layer as u64,
+            version_hashes[0],
+            version_hashes[1],
+            hash_explicit_parameters(self.explicit_parameters.as_ref()),
+            self.group_name.as_ref().map_or(0, |g| g.hash),
+            opt_bool_to_hashable(&self.is_experiment_active),
+            opt_bool_to_hashable(&self.is_user_in_experiment),
         ];
-        push_optional_version_hash_values(&mut hash_array, &self.base.version);
-        let mut explicit_params_hashes = Vec::new();
-        if let Some(explicit_parameters) = &self.explicit_parameters {
-            for value in explicit_parameters.to_vec_interned() {
-                explicit_params_hashes.push(value.hash);
-            }
-        }
-        hash_array.push(hashing::hash_one(explicit_params_hashes));
-        hash_array.push(self.group_name.as_ref().map_or(0, |g| g.hash));
-        hash_array.push(opt_bool_to_hashable(&self.is_experiment_active));
-        hash_array.push(opt_bool_to_hashable(&self.is_user_in_experiment));
 
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
@@ -168,7 +167,8 @@ pub struct LayerEvaluationV2 {
 
 impl GCIRHashable for LayerEvaluationV2 {
     fn create_hash(&self, name: &InternedString) -> u64 {
-        let mut hash_array = vec![
+        let version_hashes = optional_version_hash_values(&self.base.version);
+        let hash_array = [
             name.hash,
             self.value.get_hash(),
             self.base.rule_id.hash,
@@ -179,29 +179,49 @@ impl GCIRHashable for LayerEvaluationV2 {
             self.allocated_experiment_name
                 .as_ref()
                 .map_or(0, |n| n.hash),
+            version_hashes[0],
+            version_hashes[1],
+            hash_explicit_parameters(Some(&self.explicit_parameters)),
+            hash_optional_interned_string_exposures(self.undelegated_secondary_exposures.as_ref()),
         ];
-        push_optional_version_hash_values(&mut hash_array, &self.base.version);
-        let mut explicit_params_hashes = Vec::new();
-        for value in self.explicit_parameters.to_vec_interned() {
-            explicit_params_hashes.push(value.hash);
-        }
-        hash_array.push(hashing::hash_one(explicit_params_hashes));
-        let mut undelegated_secondary_exposure_hashes = Vec::new();
-        if let Some(undelegated_secondary_exposures) = &self.undelegated_secondary_exposures {
-            for exposure in undelegated_secondary_exposures {
-                undelegated_secondary_exposure_hashes.push(exposure.hash);
-            }
-        }
-        hash_array.push(hashing::hash_one(undelegated_secondary_exposure_hashes));
 
-        hashing::hash_one(hash_array)
+        hashing::hash_u64_slice(&hash_array)
     }
 }
 
-fn hash_secondary_exposures(exposures: &Vec<String>) -> u64 {
-    let mut secondary_exposure_hashes = Vec::new();
+fn hash_secondary_exposures(exposures: &[String]) -> u64 {
+    let mut secondary_exposure_hashes = hashing::U64HashBuilder::with_capacity(exposures.len());
     for exposure in exposures {
         secondary_exposure_hashes.push(hashing::ahash_str(exposure));
     }
-    hashing::hash_one(secondary_exposure_hashes)
+    secondary_exposure_hashes.finish()
+}
+
+fn hash_optional_interned_string_exposures(exposures: Option<&Vec<InternedString>>) -> u64 {
+    let Some(exposures) = exposures else {
+        return hashing::hash_u64_slice(&[]);
+    };
+
+    let mut exposure_hashes = hashing::U64HashBuilder::with_capacity(exposures.len());
+    for exposure in exposures {
+        exposure_hashes.push(exposure.hash);
+    }
+    exposure_hashes.finish()
+}
+
+fn hash_explicit_parameters(explicit_parameters: Option<&ExplicitParameters>) -> u64 {
+    let Some(explicit_parameters) = explicit_parameters else {
+        return hashing::hash_u64_slice(&[]);
+    };
+
+    let mut explicit_params_hashes =
+        hashing::U64HashBuilder::with_capacity(explicit_parameters.as_slice().len());
+    for value in explicit_parameters.as_slice() {
+        explicit_params_hashes.push(value.hash);
+    }
+    explicit_params_hashes.finish()
+}
+
+fn optional_version_hash_values(version: &Option<u32>) -> [u64; 2] {
+    [version.is_some() as u64, version.map_or(0, u64::from)]
 }

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluator.rs

@@ -166,21 +166,22 @@ fn new_layer_eval<'a>(
 ) -> Result<Recognition, StatsigErr> {
     let mut has_passed_rule = false;
     let mut passed = false;
-    let mut rule_id: Option<&'a InternedString> = Some(InternedString::default_rule_id_ref());
+    let mut rule_id = Some(InternedString::default_rule_id());
     let mut delegate_name: Option<InternedString> = None;
     let mut rule_ids: HashMap<InternedString, InternedString> = HashMap::new();
     let mut value: HashMap<String, Value> = HashMap::new();
     let mut group_name: Option<InternedString> = None;
     let mut is_experiment_group = false;
+    let mut is_experiment_active = false;
     let mut explicit_parameters: Option<ExplicitParameters> = None;
     let mut secondary_exposures: Vec<SecondaryExposure> = Vec::new();
     let mut undelegated_secondary_exposures: Vec<SecondaryExposure> = Vec::new();
 
     for rule in &spec.rules {
         evaluate_rule(ctx, rule)?;
-        secondary_exposures.append(&mut ctx.result.secondary_exposures);
-        undelegated_secondary_exposures.append(&mut ctx.result.secondary_exposures);
-        ctx.result.secondary_exposures.clear();
+        let rule_secondary_exposures = std::mem::take(&mut ctx.result.secondary_exposures);
+        secondary_exposures.extend(rule_secondary_exposures.iter().cloned());
+        undelegated_secondary_exposures.extend(rule_secondary_exposures);
 
         if ctx.result.unsupported {
             return Ok(Recognition::Recognized);
@@ -217,15 +218,21 @@ fn new_layer_eval<'a>(
                 continue;
             }
 
-            update_parameter_values(&mut value, &mut rule_ids, delegate_value, &rule.id);
+            let delegate_rule_id = ctx
+                .result
+                .rule_id
+                .clone()
+                .unwrap_or_else(InternedString::default_rule_id);
+            update_parameter_values(&mut value, &mut rule_ids, delegate_value, &delegate_rule_id);
 
             secondary_exposures.append(&mut ctx.result.secondary_exposures);
             ctx.result.secondary_exposures.clear();
             passed = ctx.result.bool_value;
             delegate_name = ctx.result.config_delegate.clone();
             group_name = ctx.result.group_name.clone();
-            rule_id = Some(&rule.id);
-            is_experiment_group = rule.is_experiment_group.unwrap_or(false);
+            rule_id = Some(delegate_rule_id);
+            is_experiment_group = ctx.result.is_experiment_group;
+            is_experiment_active = ctx.result.is_experiment_active;
             explicit_parameters = ctx.result.explicit_parameters.clone();
         } else {
             passed = ctx.result.bool_value;
@@ -247,10 +254,10 @@ fn new_layer_eval<'a>(
     ctx.result.bool_value = passed;
     ctx.result.config_delegate = delegate_name;
     ctx.result.group_name = group_name;
-    ctx.result.rule_id = rule_id.cloned();
+    ctx.result.rule_id = rule_id;
     ctx.result.json_value = Some(DynamicReturnable::from_map(value));
     ctx.result.is_experiment_group = is_experiment_group;
-    ctx.result.is_experiment_active = spec.is_active.unwrap_or(false);
+    ctx.result.is_experiment_active = is_experiment_active;
     ctx.result.explicit_parameters = explicit_parameters;
     ctx.result.secondary_exposures = secondary_exposures;
     ctx.result.undelegated_secondary_exposures = Some(undelegated_secondary_exposures);

{oai_statsig_python_core-0.25.0rc8 → oai_statsig_python_core-0.26.0}/statsig-rust/src/evaluation/evaluator_context.rs

@@ -72,7 +72,7 @@ impl<'a> EvaluatorContext<'a> {
 
     pub fn reset_result(&mut self) {
         self.nested_count = 0;
-        self.result = EvaluatorResult::default();
+        self.result.clear_for_reuse();
     }
 
     pub fn finalize_evaluation(&mut self, spec: &Spec, rule: Option<&Rule>) {