statsig-python-core 0.20.0__tar.gz → 0.20.1__tar.gz

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/Cargo.lock

@@ -2902,7 +2902,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2994,7 +2994,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "async-trait",
  "napi",
@@ -3009,7 +3009,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3024,7 +3024,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3075,7 +3075,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3088,7 +3088,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/Cargo.toml

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

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/PKG-INFO

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

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/py_src/statsig_python_core/statsig_python_core.pyi

@@ -289,6 +289,10 @@ class StatsigOptions:
     @event_logging_max_pending_batch_queue_size.setter
     def event_logging_max_pending_batch_queue_size(self, value: typing.Optional[builtins.int]) -> None: ...
     @property
+    def exposure_dedupe_max_keys(self) -> typing.Optional[builtins.int]: ...
+    @exposure_dedupe_max_keys.setter
+    def exposure_dedupe_max_keys(self, value: typing.Optional[builtins.int]) -> None: ...
+    @property
     def enable_id_lists(self) -> typing.Optional[builtins.bool]: ...
     @enable_id_lists.setter
     def enable_id_lists(self, value: typing.Optional[builtins.bool]) -> None: ...
@@ -388,7 +392,7 @@ class StatsigOptions:
     def id_lists_request_timeout_ms(self) -> typing.Optional[builtins.int]: ...
     @id_lists_request_timeout_ms.setter
     def id_lists_request_timeout_ms(self, value: typing.Optional[builtins.int]) -> None: ...
-    def __new__(cls, specs_url: typing.Optional[builtins.str] = None, specs_sync_interval_ms: typing.Optional[builtins.int] = None, init_timeout_ms: typing.Optional[builtins.int] = None, log_event_url: typing.Optional[builtins.str] = None, disable_all_logging: typing.Optional[builtins.bool] = None, disable_network: typing.Optional[builtins.bool] = None, log_event_connection_reuse: typing.Optional[builtins.bool] = None, event_logging_flush_interval_ms: typing.Optional[builtins.int] = None, event_logging_max_queue_size: typing.Optional[builtins.int] = None, event_logging_max_pending_batch_queue_size: typing.Optional[builtins.int] = None, enable_id_lists: typing.Optional[builtins.bool] = None, enable_dcs_deltas: typing.Optional[builtins.bool] = None, wait_for_user_agent_init: typing.Optional[builtins.bool] = None, wait_for_country_lookup_init: typing.Optional[builtins.bool] = None, disable_country_lookup: typing.Optional[builtins.bool] = None, id_lists_url: typing.Optional[builtins.str] = None, download_id_list_file_api: typing.Optional[builtins.str] = None, id_lists_sync_interval_ms: typing.Optional[builtins.int] = None, fallback_to_statsig_api: typing.Optional[builtins.bool] = None, environment: typing.Optional[builtins.str] = None, service_name: typing.Optional[builtins.str] = None, output_log_level: typing.Optional[builtins.str] = None, global_custom_fields: typing.Optional[typing.Mapping[builtins.str, typing.Union[builtins.str, builtins.int, builtins.float, builtins.bool, typing.List[typing.Optional[typing.Union[builtins.str, builtins.int, builtins.float, builtins.bool]]]]]] = None, observability_client: typing.Optional[ObservabilityClientBase] = None, data_store: typing.Optional[DataStoreBase] = None, data_store_key_schema_version: typing.Optional[builtins.str] = None, persistent_storage: typing.Optional[PersistentStorageBaseClass] = None, config_compression_mode: typing.Optional[builtins.str] = None, proxy_config: typing.Optional[ProxyConfig] = None, output_logger_provider: typing.Optional[OutputLoggerProviderBase] = None, spec_adapter_configs: typing.Optional[list] = None, use_third_party_ua_parser: typing.Optional[builtins.bool] = None, disable_disk_access: typing.Optional[builtins.bool] = None, experimental_flags: typing.Optional[builtins.set[builtins.str]] = None, id_lists_request_timeout_ms: typing.Optional[builtins.int] = None) -> StatsigOptions: ...
+    def __new__(cls, specs_url: typing.Optional[builtins.str] = None, specs_sync_interval_ms: typing.Optional[builtins.int] = None, init_timeout_ms: typing.Optional[builtins.int] = None, log_event_url: typing.Optional[builtins.str] = None, disable_all_logging: typing.Optional[builtins.bool] = None, disable_network: typing.Optional[builtins.bool] = None, log_event_connection_reuse: typing.Optional[builtins.bool] = None, event_logging_flush_interval_ms: typing.Optional[builtins.int] = None, event_logging_max_queue_size: typing.Optional[builtins.int] = None, event_logging_max_pending_batch_queue_size: typing.Optional[builtins.int] = None, enable_id_lists: typing.Optional[builtins.bool] = None, enable_dcs_deltas: typing.Optional[builtins.bool] = None, wait_for_user_agent_init: typing.Optional[builtins.bool] = None, wait_for_country_lookup_init: typing.Optional[builtins.bool] = None, disable_country_lookup: typing.Optional[builtins.bool] = None, id_lists_url: typing.Optional[builtins.str] = None, download_id_list_file_api: typing.Optional[builtins.str] = None, id_lists_sync_interval_ms: typing.Optional[builtins.int] = None, fallback_to_statsig_api: typing.Optional[builtins.bool] = None, environment: typing.Optional[builtins.str] = None, service_name: typing.Optional[builtins.str] = None, output_log_level: typing.Optional[builtins.str] = None, global_custom_fields: typing.Optional[typing.Mapping[builtins.str, typing.Union[builtins.str, builtins.int, builtins.float, builtins.bool, typing.List[typing.Optional[typing.Union[builtins.str, builtins.int, builtins.float, builtins.bool]]]]]] = None, observability_client: typing.Optional[ObservabilityClientBase] = None, data_store: typing.Optional[DataStoreBase] = None, data_store_key_schema_version: typing.Optional[builtins.str] = None, persistent_storage: typing.Optional[PersistentStorageBaseClass] = None, config_compression_mode: typing.Optional[builtins.str] = None, proxy_config: typing.Optional[ProxyConfig] = None, output_logger_provider: typing.Optional[OutputLoggerProviderBase] = None, spec_adapter_configs: typing.Optional[list] = None, use_third_party_ua_parser: typing.Optional[builtins.bool] = None, disable_disk_access: typing.Optional[builtins.bool] = None, experimental_flags: typing.Optional[builtins.set[builtins.str]] = None, id_lists_request_timeout_ms: typing.Optional[builtins.int] = None, exposure_dedupe_max_keys: typing.Optional[builtins.int] = None) -> StatsigOptions: ...
 
 @typing.final
 class StatsigUser:

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-pyo3/src/pyo_utils.rs

@@ -65,10 +65,7 @@ pub fn map_to_py_dict(py: Python, map: &HashMap<String, Value>) -> Py<PyAny> {
 pub fn py_list_to_list(py_list: &Bound<PyList>) -> PyResult<Vec<String>> {
     let mut converted_list = Vec::new();
     for value in py_list {
-        match value.extract::<String>() {
-            Ok(s) => converted_list.push(s),
-            Err(e) => return Err(e),
-        }
+        converted_list.push(value.extract::<String>()?);
     }
     Ok(converted_list)
 }

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-pyo3/src/statsig_options_py.rs

@@ -180,6 +180,8 @@ pub struct StatsigOptionsPy {
     #[pyo3(get, set)]
     pub event_logging_max_pending_batch_queue_size: Option<u32>,
     #[pyo3(get, set)]
+    pub exposure_dedupe_max_keys: Option<u32>,
+    #[pyo3(get, set)]
     pub enable_id_lists: Option<bool>,
     #[pyo3(get, set)]
     pub enable_dcs_deltas: Option<bool>,
@@ -272,6 +274,7 @@ impl StatsigOptionsPy {
         disable_disk_access=None,
         experimental_flags=None,
         id_lists_request_timeout_ms=None,
+        exposure_dedupe_max_keys=None,
     ))]
     #[allow(clippy::too_many_arguments)]
     pub fn new(
@@ -310,6 +313,7 @@ impl StatsigOptionsPy {
         disable_disk_access: Option<bool>,
         experimental_flags: Option<HashSet<String>>,
         id_lists_request_timeout_ms: Option<u64>,
+        exposure_dedupe_max_keys: Option<u32>,
     ) -> Self {
         Self {
             specs_url,
@@ -321,6 +325,7 @@ impl StatsigOptionsPy {
             event_logging_flush_interval_ms,
             event_logging_max_queue_size,
             event_logging_max_pending_batch_queue_size,
+            exposure_dedupe_max_keys,
             enable_id_lists,
             enable_dcs_deltas,
             wait_for_user_agent_init,
@@ -410,7 +415,7 @@ fn create_inner_statsig_options(
         event_logging_flush_interval_ms: None,
         event_logging_max_queue_size: opts.event_logging_max_queue_size,
         event_logging_max_pending_batch_queue_size: opts.event_logging_max_pending_batch_queue_size,
-        exposure_dedupe_max_keys: None,
+        exposure_dedupe_max_keys: opts.exposure_dedupe_max_keys,
         enable_id_lists: opts.enable_id_lists,
         enable_dcs_deltas: opts.enable_dcs_deltas,
         id_lists_url: opts.id_lists_url.clone(),

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-pyo3/src/statsig_persistent_storage_override_adapter_py.rs

@@ -169,12 +169,8 @@ fn convert_py_lists_to_secondary_exposures(
 ) -> PyResult<Vec<SecondaryExposure>> {
     let mut exposures = Vec::new();
     for item in py_list {
-        match item.extract::<Bound<PyDict>>() {
-            Ok(e) => {
-                exposures.push(convert_py_dict_to_secondary_exposure(&e)?);
-            }
-            Err(e) => return Err(e.into()),
-        }
+        let e = item.extract::<Bound<PyDict>>()?;
+        exposures.push(convert_py_dict_to_secondary_exposure(&e)?);
     }
 
     Ok(exposures)

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-pyo3/src/statsig_types_py.rs

@@ -311,6 +311,8 @@ impl From<&ExperimentEvaluationOptionsPy> for ExperimentEvaluationOptions {
             disable_exposure_logging: val.disable_exposure_logging,
             // For performance consideration, conversion to user persisted values use convert_dict_to_user_persisted_values()
             user_persisted_values: None,
+            // enforce_overrides / enforce_targeting are wired up in a follow-up binding sub-issue.
+            ..Default::default()
         }
     }
 }
@@ -321,6 +323,8 @@ impl From<&LayerEvaluationOptionsPy> for LayerEvaluationOptions {
             disable_exposure_logging: val.disable_exposure_logging,
             // For performance consideration, conversion to user persisted values use convert_dict_to_user_persisted_values()
             user_persisted_values: None,
+            // enforce_overrides / enforce_targeting are wired up in a follow-up binding sub-issue.
+            ..Default::default()
         }
     }
 }

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-pyo3/tests/test_statsig_options.py

@@ -45,6 +45,44 @@ def test_full_statsig_options():
     assert options.service_name == "statsig-python-service"
 
 
+def test_exposure_dedupe_max_keys_defaults_to_none():
+    options = StatsigOptions()
+    assert options.exposure_dedupe_max_keys is None
+
+
+def test_exposure_dedupe_max_keys_round_trips():
+    # Settable via constructor and as an attribute; the getter reads the same
+    # field forwarded to the core StatsigOptions.
+    options = StatsigOptions(exposure_dedupe_max_keys=250_000)
+    assert options.exposure_dedupe_max_keys == 250_000
+
+    options.exposure_dedupe_max_keys = 5
+    assert options.exposure_dedupe_max_keys == 5
+
+
+def test_exposure_dedupe_max_keys_appended_without_breaking_positional_args():
+    # exposure_dedupe_max_keys is appended AFTER the pre-existing constructor
+    # params, so existing positional calls keep binding to the same options and
+    # the new field defaults to None. The 11th positional arg is enable_id_lists;
+    # if the new param had been inserted mid-list, `True` would bind to it here.
+    options = StatsigOptions(
+        "https://cdn.statsig.com/v1",  # specs_url
+        None,  # specs_sync_interval_ms
+        None,  # init_timeout_ms
+        None,  # log_event_url
+        None,  # disable_all_logging
+        None,  # disable_network
+        None,  # log_event_connection_reuse
+        None,  # event_logging_flush_interval_ms
+        None,  # event_logging_max_queue_size
+        None,  # event_logging_max_pending_batch_queue_size
+        True,  # enable_id_lists
+    )
+    assert options.specs_url == "https://cdn.statsig.com/v1"
+    assert options.enable_id_lists is True
+    assert options.exposure_dedupe_max_keys is None
+
+
 def _assert_no_tls(config):
     assert config.adapter_type == "network_grpc_websocket"
     assert config.specs_url == "grpc://localhost:50051"

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/Cargo.toml

@@ -41,7 +41,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.20.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.20.1", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

statsig_python_core-0.20.1/statsig-rust/examples/eval_contention_bench.rs

@@ -0,0 +1,155 @@
+// Pure-Rust eval contention bench (S2SDK-140 follow-up).
+//
+// Java-harness profiling of the heavy-gate workload showed ~50% of CPU time
+// in futex/sched_yield - lock churn on the eval hot path - but the native
+// frames had no symbols. This bench removes the JVM/JNI entirely (which also
+// removes InstanceRegistry from the path) so we can (a) see if the thread-
+// scaling collapse reproduces in pure Rust and (b) profile with symbols.
+//
+// Isolation knobs:
+//   BENCH_THREADS      comma list of thread counts to sweep   (default 1,4,16,64)
+//   BENCH_GATE         gate to evaluate                        (default test_many_rules)
+//   BENCH_MANY_GATES   >0: cycle syn_gate_NNNN names to spread the
+//                      non_exposed_checks DashMap across shards (default 0)
+//   BENCH_DURATION_SEC seconds per measurement                 (default 10)
+//   BENCH_DCS_FILE     specs payload                           (default ../grammarly-load-repro/dcs_payload_big.json)
+//   BENCH_EXPOSURES    "1": log exposures instead of the non-exposure path
+//   BENCH_REUSE_USER   evals per fresh user                    (default 40)
+//
+// Run: cargo run --release --example eval_contention_bench
+//
+// Comparing `same gate` vs `BENCH_MANY_GATES=3000` isolates single-key
+// contention on non_exposed_checks; profiling with symbols (samply/sample)
+// attributes the rest (spec_store RwLock vs eval compute).
+
+use statsig_rust::{
+    hashing::djb2, FeatureGateEvaluationOptions, Statsig, StatsigLocalFileSpecsAdapter,
+    StatsigOptions, StatsigUser, StatsigUserBuilder,
+};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+fn env(name: &str, default: &str) -> String {
+    std::env::var(name).unwrap_or_else(|_| default.to_string())
+}
+
+fn make_user(idx: u64) -> StatsigUser {
+    StatsigUserBuilder::new_with_user_id(format!("user_{idx}"))
+        .email(Some(format!("u{}@example.com", idx % 1000)))
+        .custom_ids(Some(HashMap::from([(
+            "companyID".to_string(),
+            format!("c{}", idx % 500),
+        )])))
+        .country(Some("US".to_string()))
+        .locale(Some("en_US".to_string()))
+        .app_version(Some(format!("5.2.{}", idx % 90)))
+        .custom_from_str_map(Some(HashMap::from([
+            ("plan".to_string(), "premium".to_string()),
+            ("cohort".to_string(), format!("c{}", idx % 20)),
+            ("platform".to_string(), "mac".to_string()),
+            ("abGroup".to_string(), format!("g{}", idx % 8)),
+        ])))
+        .build()
+}
+
+#[tokio::main]
+async fn main() {
+    let dcs_file = env(
+        "BENCH_DCS_FILE",
+        "../../grammarly-load-repro/dcs_payload_big.json",
+    );
+    let gate = env("BENCH_GATE", "test_many_rules");
+    let many_gates: u64 = env("BENCH_MANY_GATES", "0").parse().unwrap();
+    let duration_sec: u64 = env("BENCH_DURATION_SEC", "10").parse().unwrap();
+    let reuse_user: u64 = env("BENCH_REUSE_USER", "40").parse().unwrap();
+    let log_exposures = env("BENCH_EXPOSURES", "0") == "1";
+    let thread_counts: Vec<usize> = env("BENCH_THREADS", "1,4,16,64")
+        .split(',')
+        .map(|s| s.trim().parse().unwrap())
+        .collect();
+
+    let sdk_key = "secret-bench-key";
+
+    // StatsigLocalFileSpecsAdapter reads {dir}/{djb2(key)}_specs.json.
+    // Per-process dir so concurrent bench runs don't clobber each other's specs.
+    let dir = std::env::temp_dir().join(format!("statsig_eval_bench_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let specs_path = dir.join(format!("{}_specs.json", djb2(sdk_key)));
+    std::fs::copy(&dcs_file, &specs_path)
+        .unwrap_or_else(|e| panic!("copy {dcs_file} -> {specs_path:?}: {e}"));
+
+    let adapter = Arc::new(StatsigLocalFileSpecsAdapter::new(
+        sdk_key,
+        dir.to_str().unwrap(),
+        None,
+        false,
+        true, // disable_network
+    ));
+
+    let options = StatsigOptions {
+        specs_adapter: Some(adapter.clone()),
+        disable_network: Some(true),
+        ..Default::default()
+    };
+
+    let statsig = Arc::new(Statsig::new(sdk_key, Some(Arc::new(options))));
+    statsig.initialize().await.expect("initialize");
+    adapter.resync_from_file().expect("resync specs from file");
+
+    let probe = make_user(0);
+    println!(
+        "probe check_gate({gate}) = {} (exposures={log_exposures}, manyGates={many_gates})",
+        statsig.check_gate(&probe, &gate)
+    );
+
+    for &threads in &thread_counts {
+        let stop = Arc::new(AtomicBool::new(false));
+        let total_ops = Arc::new(AtomicU64::new(0));
+        let mut handles = Vec::new();
+
+        for t in 0..threads {
+            let statsig = statsig.clone();
+            let stop = stop.clone();
+            let total_ops = total_ops.clone();
+            let gate = gate.clone();
+            handles.push(std::thread::spawn(move || {
+                let opts = FeatureGateEvaluationOptions {
+                    disable_exposure_logging: !log_exposures,
+                };
+                let mut ops: u64 = 0;
+                let mut user = make_user(t as u64);
+                while !stop.load(Ordering::Relaxed) {
+                    ops += 1;
+                    if ops % reuse_user == 0 {
+                        user = make_user((t as u64) << 32 | ops);
+                    }
+                    let gate_name = if many_gates > 0 {
+                        format!("syn_gate_{:04}", ops % many_gates)
+                    } else {
+                        gate.clone()
+                    };
+                    statsig.check_gate_with_options(&user, &gate_name, opts.clone());
+                }
+                total_ops.fetch_add(ops, Ordering::Relaxed);
+            }));
+        }
+
+        let start = Instant::now();
+        std::thread::sleep(Duration::from_secs(duration_sec));
+        stop.store(true, Ordering::Relaxed);
+        for h in handles {
+            h.join().unwrap();
+        }
+        let elapsed = start.elapsed().as_secs_f64();
+        let ops = total_ops.load(Ordering::Relaxed);
+        println!(
+            "threads={threads:>3}  total={ops:>12}  qps={:>12.0}  per-thread qps={:>10.0}",
+            ops as f64 / elapsed,
+            ops as f64 / elapsed / threads as f64
+        );
+    }
+
+    statsig.shutdown().await.ok();
+}

statsig_python_core-0.20.1/statsig-rust/examples/intern_contention_bench.rs

@@ -0,0 +1,63 @@
+// Micro-bench: is InternedString get+drop the eval-path serializer?
+//
+// Every evaluation does InternedString::from_str_ref(spec_name) (evaluator.rs)
+// and later drops it (release_string). Both operations touch global interned
+// storage. This bench isolates exactly that pair, same hot key on all threads,
+// mirroring a hot gate at high QPS.
+//
+//   BENCH_THREADS   comma list (default 1,4,16,64)
+//   BENCH_DURATION_SEC (default 5)
+//
+// Run: cargo run --release --example intern_contention_bench
+
+use statsig_rust::interned_string::InternedString;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+fn main() {
+    let thread_counts: Vec<usize> = std::env::var("BENCH_THREADS")
+        .unwrap_or_else(|_| "1,4,16,64".into())
+        .split(',')
+        .map(|s| s.trim().parse().unwrap())
+        .collect();
+    let duration_sec: u64 = std::env::var("BENCH_DURATION_SEC")
+        .unwrap_or_else(|_| "5".into())
+        .parse()
+        .unwrap();
+
+    for &threads in &thread_counts {
+        let stop = Arc::new(AtomicBool::new(false));
+        let total = Arc::new(AtomicU64::new(0));
+        let mut handles = Vec::new();
+        for _ in 0..threads {
+            let stop = stop.clone();
+            let total = total.clone();
+            handles.push(std::thread::spawn(move || {
+                let mut ops = 0u64;
+                while !stop.load(Ordering::Relaxed) {
+                    // The exact per-eval pair: intern the (hot) spec name,
+                    // then drop it (which calls release_string).
+                    let s = InternedString::from_str_ref("test_many_rules");
+                    std::hint::black_box(&s);
+                    drop(s);
+                    ops += 1;
+                }
+                total.fetch_add(ops, Ordering::Relaxed);
+            }));
+        }
+        let start = Instant::now();
+        std::thread::sleep(Duration::from_secs(duration_sec));
+        stop.store(true, Ordering::Relaxed);
+        for h in handles {
+            h.join().unwrap();
+        }
+        let el = start.elapsed().as_secs_f64();
+        let ops = total.load(Ordering::Relaxed);
+        println!(
+            "threads={threads:>3}  intern+drop/sec={:>12.0}  per-thread={:>11.0}",
+            ops as f64 / el,
+            ops as f64 / el / threads as f64
+        );
+    }
+}

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/src/evaluation/__tests__/dynamic_returnable_tests.rs

@@ -27,27 +27,38 @@ fn test_jsonify_bool_two_ways() {
 #[test]
 #[serial]
 fn test_memoization_from_json_object() {
+    // Baseline-relative: eviction is amortized, so other tests' dropped values
+    // may still be in the store until a sweep runs.
+    InternedStore::run_maintenance();
+    let before = get_memo_len();
+
     let raw = r#"{"once":{"key":"value"},"twice":{"key":"value"}}"#;
 
     let deserialized: HashMap<String, DynamicReturnable> = serde_json::from_str(raw).unwrap();
 
-    assert_eq!(get_memo_len(), 1);
+    assert_eq!(get_memo_len(), before + 1);
 
     drop(deserialized);
+    InternedStore::run_maintenance();
 
-    assert_eq!(get_memo_len(), 0);
+    assert_eq!(get_memo_len(), before);
 }
 
 #[test]
 #[serial]
 fn test_memoization_from_json_bool() {
+    // Compare against a baseline instead of asserting an empty store: eviction
+    // is amortized now, so other tests' dropped values may not be swept yet.
+    InternedStore::run_maintenance();
+    let before = get_memo_len();
+
     let raw = r#"{"once":true,"twice":true}"#;
 
     let deserialized: HashMap<String, DynamicReturnable> = serde_json::from_str(raw).unwrap();
     let value = deserialized.get("once").unwrap();
     assert_eq!(value.get_bool(), Some(true));
 
-    assert_eq!(get_memo_len(), 0, "Bools are not memoized");
+    assert_eq!(get_memo_len(), before, "Bools are not memoized");
 }
 
 fn get_memo_len() -> usize {

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/src/evaluation/country_lookup.rs

@@ -128,12 +128,12 @@ impl CountryLookup {
             return None;
         }
 
-        let ip = match user.get_user_value(&Some(DynamicString::from(IP.to_string()))) {
-            Some(v) => match &v.string_value {
+        let ip = {
+            let v = user.get_user_value(&Some(DynamicString::from(IP.to_string())))?;
+            match &v.string_value {
                 Some(s) => &s.value,
                 _ => return None,
-            },
-            None => return None,
+            }
         };
 
         Self::lookup(ip, evaluator_context)

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/src/evaluation/dynamic_returnable.rs

@@ -138,6 +138,11 @@ impl Serialize for DynamicReturnable {
 
 impl Drop for DynamicReturnable {
     fn drop(&mut self) {
+        // Only JsonPointer values live in the mutable store; other variants
+        // (Null/Bool/Static/Archived) have nothing to release.
+        if !matches!(self.value, DynamicReturnableValue::JsonPointer(_)) {
+            return;
+        }
         self.value = DynamicReturnableValue::Null;
         InternedStore::release_returnable(self.hash);
     }

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/src/evaluation/evaluator.rs

@@ -58,6 +58,14 @@ impl Evaluator {
     ) -> Result<Recognition, StatsigErr> {
         let spec_name_intern = InternedString::from_str_ref(spec_name);
 
+        // Persistent-assignment enforceTargeting / enforceOverrides re-run a
+        // top-level evaluation restricted to the targeting-only / override-only
+        // rules of the spec. In that mode we bypass overrides / config mapping /
+        // CMAB and only consider the matching subset of `spec.rules`. Nested
+        // evaluations (nested_count > 0) always see the full rule set.
+        let filter_active =
+            ctx.nested_count == 0 && (ctx.only_evaluate_targeting || ctx.only_evaluate_overrides);
+
         let opt_spec = match spec_type {
             SpecType::Gate => ctx.specs_data.feature_gates.get(&spec_name_intern),
             SpecType::DynamicConfig => ctx.specs_data.dynamic_configs.get(&spec_name_intern),
@@ -69,16 +77,18 @@ impl Evaluator {
         }
         .map(|sp| sp.as_spec_ref());
 
-        if try_apply_override(ctx, spec_name, spec_type, opt_spec) {
-            return Ok(Recognition::Recognized);
-        }
+        if !filter_active {
+            if try_apply_override(ctx, spec_name, spec_type, opt_spec) {
+                return Ok(Recognition::Recognized);
+            }
 
-        if try_apply_config_mapping(ctx, spec_name, spec_type, opt_spec) {
-            return Ok(Recognition::Recognized);
-        }
+            if try_apply_config_mapping(ctx, spec_name, spec_type, opt_spec) {
+                return Ok(Recognition::Recognized);
+            }
 
-        if evaluate_cmab(ctx, spec_name, spec_type) {
-            return Ok(Recognition::Recognized);
+            if evaluate_cmab(ctx, spec_name, spec_type) {
+                return Ok(Recognition::Recognized);
+            }
         }
 
         let spec = unwrap_or_return!(opt_spec, Ok(Recognition::Unrecognized));
@@ -113,7 +123,21 @@ impl Evaluator {
             return new_layer_eval(ctx, spec);
         }
 
+        // In filtered mode, an empty subset means the user is not gated out of
+        // targeting / is not overridden. Mirror the legacy Java server SDK by
+        // returning a false evaluation rather than falling through to the
+        // spec's default value.
+        if filter_active && !spec_has_filtered_rule(ctx, spec) {
+            ctx.result.bool_value = false;
+            ctx.finalize_evaluation(spec, None);
+            return Ok(Recognition::Recognized);
+        }
+
         for rule in &spec.rules {
+            if filter_active && !rule_matches_filter(ctx, rule) {
+                continue;
+            }
+
             evaluate_rule(ctx, rule)?;
 
             if ctx.result.unsupported {
@@ -175,7 +199,19 @@ fn new_layer_eval<'a>(
     let mut secondary_exposures: Vec<SecondaryExposure> = Vec::new();
     let mut undelegated_secondary_exposures: Vec<SecondaryExposure> = Vec::new();
 
+    let filter_active =
+        ctx.nested_count == 0 && (ctx.only_evaluate_targeting || ctx.only_evaluate_overrides);
+    if filter_active && !spec_has_filtered_rule(ctx, spec) {
+        ctx.result.bool_value = false;
+        ctx.finalize_evaluation(spec, None);
+        return Ok(Recognition::Recognized);
+    }
+
     for rule in &spec.rules {
+        if filter_active && !rule_matches_filter(ctx, rule) {
+            continue;
+        }
+
         evaluate_rule(ctx, rule)?;
         secondary_exposures.append(&mut ctx.result.secondary_exposures);
         undelegated_secondary_exposures.append(&mut ctx.result.secondary_exposures);
@@ -258,6 +294,15 @@ fn new_layer_eval<'a>(
     Ok(Recognition::Recognized)
 }
 
+fn rule_matches_filter(ctx: &EvaluatorContext, rule: &Rule) -> bool {
+    (ctx.only_evaluate_targeting && rule.is_targeting_rule())
+        || (ctx.only_evaluate_overrides && rule.is_override_rule())
+}
+
+fn spec_has_filtered_rule(ctx: &EvaluatorContext, spec: &Spec) -> bool {
+    spec.rules.iter().any(|rule| rule_matches_filter(ctx, rule))
+}
+
 fn update_parameter_values(
     value: &mut HashMap<String, Value>,
     rule_ids: &mut HashMap<InternedString, InternedString>,
@@ -602,6 +647,8 @@ fn evaluate_experiment_group<'a>(
         ExperimentEvaluationOptions {
             disable_exposure_logging: ctx.disable_exposure_logging,
             user_persisted_values: None,
+            enforce_overrides: false,
+            enforce_targeting: false,
         },
     );
     res.group_name

{statsig_python_core-0.20.0 → statsig_python_core-0.20.1}/statsig-rust/src/evaluation/evaluator_context.rs

@@ -36,6 +36,11 @@ pub struct EvaluatorContext<'a> {
     pub statsig: Option<&'a Statsig>,
     pub disable_exposure_logging: bool,
     pub gcir_hashes: Vec<u64>,
+    // When set, a top-level evaluation only considers the corresponding subset of
+    // rules (targeting-only / override-only). Used by persistent-assignment
+    // enforceTargeting / enforceOverrides to decide whether a sticky value still holds.
+    pub only_evaluate_targeting: bool,
+    pub only_evaluate_overrides: bool,
 }
 
 impl<'a> EvaluatorContext<'a> {
@@ -67,6 +72,8 @@ impl<'a> EvaluatorContext<'a> {
             statsig,
             disable_exposure_logging,
             gcir_hashes: Vec::new(),
+            only_evaluate_targeting: false,
+            only_evaluate_overrides: false,
         }
     }