statsig-python-core 0.19.1b2604130314__tar.gz → 0.19.2__tar.gz

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/Cargo.lock

@@ -2869,7 +2869,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2961,7 +2961,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "async-trait",
  "napi",
@@ -2976,7 +2976,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2991,7 +2991,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3006,6 +3006,7 @@ dependencies = [
  "file-guard",
  "flate2",
  "futures",
+ "indexmap 2.13.0",
  "lazy_static",
  "libc",
  "log",
@@ -3040,7 +3041,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3053,7 +3054,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.19.1-beta.2604130314"
+version = "0.19.2"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/Cargo.toml

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

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/PKG-INFO

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

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/statsig-pyo3/Cargo.toml

@@ -21,6 +21,7 @@ serde_json = { version = "1.0.125", features = ["float_roundtrip"] }
 statsig-rust = { path = "../statsig-rust", features = [
     "with_grpc",
     "ffi-support",
+    "ordered_user_data_maps",
 ] }
 async-trait = "0.1.81"
 serde = { version = "1.0.204", features = ["derive"] }

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/statsig-pyo3/src/pyo_utils.rs

@@ -6,7 +6,7 @@ use pyo3::types::{
 use pyo3::{Bound, Py, PyAny, PyErr, PyResult, PyTypeCheck, Python};
 use serde_json::{json, Number, Value};
 use statsig_rust::evaluation::dynamic_string::DynamicString;
-use statsig_rust::{log_e, log_w, DynamicValue};
+use statsig_rust::{log_e, log_w, DynamicValue, StatsigUserDataMap};
 use std::borrow::Cow;
 use std::collections::HashMap;
 
@@ -234,9 +234,7 @@ pub fn py_any_to_dynamic_value(value: &Bound<PyAny>) -> PyResult<DynamicValue> {
 
 // ------------------------------------------------------------------------------- [ Statsig User Creation ]
 
-pub fn opt_py_dict_ref_to_hashmap(
-    data: Option<&Bound<'_, PyDict>>,
-) -> Option<HashMap<String, DynamicValue>> {
+pub fn opt_py_dict_ref_to_hashmap(data: Option<&Bound<'_, PyDict>>) -> Option<StatsigUserDataMap> {
     let data = data?;
     Some(py_dict_ref_to_hashmap(data))
 }
@@ -278,8 +276,8 @@ fn py_any_ref_to_dynamic_value(value: &Bound<'_, PyAny>) -> Option<DynamicValue>
     None
 }
 
-fn py_dict_ref_to_hashmap(dict: &Bound<'_, PyDict>) -> HashMap<String, DynamicValue> {
-    let mut values = HashMap::with_capacity(dict.len());
+fn py_dict_ref_to_hashmap(dict: &Bound<'_, PyDict>) -> StatsigUserDataMap {
+    let mut values = StatsigUserDataMap::with_capacity(dict.len());
 
     for (key, value) in dict.iter() {
         let dynamic_val = match py_any_ref_to_dynamic_value(&value) {
@@ -389,5 +387,5 @@ fn try_as_dict<'py>(value: &'py Bound<'py, PyAny>) -> Option<HashMap<String, Dyn
 
     // SAFETY: This is what the "safe" version does internally, but its faster because we skip the Error creation
     let pydict = unsafe { value.cast_unchecked::<PyDict>() };
-    Some(py_dict_ref_to_hashmap(pydict))
+    Some(py_dict_ref_to_hashmap(pydict).into_iter().collect())
 }

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/statsig-pyo3/src/statsig_user_py.rs

@@ -6,7 +6,7 @@ use crate::{
 use pyo3::types::PyBytes;
 use pyo3::{prelude::*, types::PyDict};
 use pyo3_stub_gen::derive::*;
-use statsig_rust::{log_e, log_w, DynamicValue, StatsigUser, StatsigUserData};
+use statsig_rust::{log_e, log_w, DynamicValue, StatsigUser, StatsigUserData, StatsigUserDataMap};
 use std::{collections::HashMap, str};
 
 const TAG: &str = stringify!(StatsigUserPy);
@@ -321,7 +321,7 @@ impl StatsigUserPy {
 }
 
 fn get_map_field_ref<'a>(
-    field: &'a Option<HashMap<String, DynamicValue>>,
+    field: &'a Option<StatsigUserDataMap>,
 ) -> Option<HashMap<&'a str, Option<ValidPrimitivesPyRef<'a>>>> {
     let value = field.as_ref()?;
 

statsig_python_core-0.19.2/statsig-pyo3/tests/test_sec_expo_as_primary.py

@@ -0,0 +1,402 @@
+import json
+
+import pytest
+from pytest_httpserver import HTTPServer
+from statsig_python_core import Statsig, StatsigOptions, StatsigUser
+
+from mock_scrapi import MockScrapi
+from utils import get_test_data_resource
+
+SEC_EXPO_AS_PRIMARY_FLAG = "sec_expo_as_primary:abc123"
+SEC_EXPO_AS_PRIMARY_FLAG_BUCKET = 307
+
+
+def _create_statsig(
+    httpserver: HTTPServer, experimental_flags=None, sec_expo_number=None
+):
+    mock_scrapi = MockScrapi(httpserver)
+    dcs_content = json.loads(get_test_data_resource("eval_proj_dcs.json"))
+    if sec_expo_number is not None:
+        dcs_content.setdefault("sdk_configs", {})["sec_expo_number"] = sec_expo_number
+
+    mock_scrapi.stub(
+        "/v2/download_config_specs/secret-key.json",
+        response=json.dumps(dcs_content),
+        method="GET",
+    )
+    mock_scrapi.stub("/v1/log_event", response='{"success": true}', method="POST")
+
+    options = StatsigOptions()
+    options.specs_url = mock_scrapi.url_for_endpoint("/v2/download_config_specs")
+    options.log_event_url = mock_scrapi.url_for_endpoint("/v1/log_event")
+    options.output_log_level = "none"
+    options.experimental_flags = experimental_flags
+
+    statsig = Statsig("secret-key", options)
+    statsig.initialize().wait()
+
+    return statsig, mock_scrapi
+
+
+def _assert_exposure(event, event_name, metadata):
+    assert event["eventName"] == event_name
+    for key, value in metadata.items():
+        assert event["metadata"][key] == value
+
+
+@pytest.mark.parametrize(
+    "evaluate, expected_primary, expected_secondary_events",
+    [
+        pytest.param(
+            lambda statsig: statsig.check_gate(
+                StatsigUser("a_user_id"), "test_nested_gate_condition"
+            ),
+            (
+                "statsig::gate_exposure",
+                {
+                    "gate": "test_nested_gate_condition",
+                    "gateValue": "true",
+                    "ruleID": "6MlXHRavmo1ujM1NkZNjhQ",
+                },
+            ),
+            [
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "test_email",
+                        "gateValue": "false",
+                        "ruleID": "default",
+                    },
+                ),
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "test_environment_tier",
+                        "gateValue": "false",
+                        "ruleID": "default",
+                    },
+                ),
+            ],
+            id="gate",
+        ),
+        pytest.param(
+            lambda statsig: statsig.get_dynamic_config(
+                StatsigUser("a_user_id"), "operating_system_config"
+            ),
+            (
+                "statsig::config_exposure",
+                {
+                    "config": "operating_system_config",
+                    "ruleID": "default",
+                },
+            ),
+            [
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "test_email",
+                        "gateValue": "false",
+                        "ruleID": "default",
+                    },
+                ),
+            ],
+            id="dynamic_config",
+        ),
+        pytest.param(
+            lambda statsig: statsig.get_experiment(
+                StatsigUser("a-user", email="daniel@statsig.com"),
+                "running_exp_in_unlayered_with_holdout",
+            ),
+            (
+                "statsig::config_exposure",
+                {
+                    "config": "running_exp_in_unlayered_with_holdout",
+                    "ruleID": "5suobe8yyvznqasn9Ph1dI",
+                },
+            ),
+            [
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "global_holdout",
+                        "gateValue": "false",
+                        "ruleID": "3QoA4ncNdVGBaMt3N1KYjz:0.50:1",
+                    },
+                ),
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "exp_holdout",
+                        "gateValue": "false",
+                        "ruleID": "1rEqLOpCROaRafv7ubGgax",
+                    },
+                ),
+            ],
+            id="experiment",
+        ),
+        pytest.param(
+            lambda statsig: statsig.get_layer(
+                StatsigUser("a_user_id"), "layer_in_global_holdout"
+            ).get_string("shared_param", ""),
+            (
+                "statsig::layer_exposure",
+                {
+                    "config": "layer_in_global_holdout",
+                    "parameterName": "shared_param",
+                },
+            ),
+            [
+                (
+                    "statsig::gate_exposure",
+                    {
+                        "gate": "global_holdout",
+                        "gateValue": "false",
+                        "ruleID": "3QoA4ncNdVGBaMt3N1KYjz:0.50:1",
+                    },
+                ),
+            ],
+            id="layer",
+        ),
+    ],
+)
+def test_gate_dynamic_config_experiment_and_layer_log_secondary_exposures_as_primary(
+    httpserver: HTTPServer,
+    evaluate,
+    expected_primary,
+    expected_secondary_events,
+):
+    statsig, mock_scrapi = _create_statsig(
+        httpserver,
+        experimental_flags={SEC_EXPO_AS_PRIMARY_FLAG},
+        sec_expo_number=1000,
+    )
+
+    try:
+        evaluate(statsig)
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        assert len(events) == 1 + len(expected_secondary_events)
+
+        for event in events:
+            assert event["secondaryExposures"] == []
+
+        _assert_exposure(events[0], expected_primary[0], expected_primary[1])
+        for event, expected in zip(events[1:], expected_secondary_events):
+            _assert_exposure(event, expected[0], expected[1])
+    finally:
+        statsig.shutdown().wait()
+
+
+def test_secondary_exposures_logged_as_primary_when_flag_enabled(
+    httpserver: HTTPServer,
+):
+    statsig, mock_scrapi = _create_statsig(
+        httpserver,
+        experimental_flags={SEC_EXPO_AS_PRIMARY_FLAG},
+        sec_expo_number=1000,
+    )
+
+    try:
+        assert statsig.check_gate(
+            StatsigUser("a_user_id"), "test_nested_gate_condition"
+        )
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        assert len(events) == 3
+
+        for event in events:
+            assert event["secondaryExposures"] == []
+
+        _assert_exposure(
+            events[0],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_nested_gate_condition",
+                "gateValue": "true",
+                "ruleID": "6MlXHRavmo1ujM1NkZNjhQ",
+            },
+        )
+        _assert_exposure(
+            events[1],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_email",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+        )
+        _assert_exposure(
+            events[2],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_environment_tier",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+        )
+    finally:
+        statsig.shutdown().wait()
+
+
+def test_secondary_exposures_remain_on_primary_when_flag_not_enabled(
+    httpserver: HTTPServer,
+):
+    statsig, mock_scrapi = _create_statsig(httpserver, sec_expo_number=300)
+
+    try:
+        assert statsig.check_gate(
+            StatsigUser("a_user_id"), "test_nested_gate_condition"
+        )
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        assert len(events) == 1
+
+        _assert_exposure(
+            events[0],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_nested_gate_condition",
+                "gateValue": "true",
+                "ruleID": "6MlXHRavmo1ujM1NkZNjhQ",
+            },
+        )
+        assert events[0]["secondaryExposures"] == [
+            {
+                "gate": "test_email",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+            {
+                "gate": "test_environment_tier",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+        ]
+    finally:
+        statsig.shutdown().wait()
+
+
+def test_secondary_exposures_remain_on_primary_when_sec_expo_number_is_zero(
+    httpserver: HTTPServer,
+):
+    statsig, mock_scrapi = _create_statsig(
+        httpserver,
+        experimental_flags={SEC_EXPO_AS_PRIMARY_FLAG},
+        sec_expo_number=0,
+    )
+
+    try:
+        assert statsig.check_gate(
+            StatsigUser("a_user_id"), "test_nested_gate_condition"
+        )
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        assert len(events) == 1
+
+        _assert_exposure(
+            events[0],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_nested_gate_condition",
+                "gateValue": "true",
+                "ruleID": "6MlXHRavmo1ujM1NkZNjhQ",
+            },
+        )
+        assert events[0]["secondaryExposures"] == [
+            {
+                "gate": "test_email",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+            {
+                "gate": "test_environment_tier",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+        ]
+    finally:
+        statsig.shutdown().wait()
+
+
+def test_secondary_exposures_remain_on_primary_when_sec_expo_number_missing(
+    httpserver: HTTPServer,
+):
+    statsig, mock_scrapi = _create_statsig(
+        httpserver,
+        experimental_flags={SEC_EXPO_AS_PRIMARY_FLAG},
+    )
+
+    try:
+        assert statsig.check_gate(
+            StatsigUser("a_user_id"), "test_nested_gate_condition"
+        )
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        assert len(events) == 1
+
+        _assert_exposure(
+            events[0],
+            "statsig::gate_exposure",
+            {
+                "gate": "test_nested_gate_condition",
+                "gateValue": "true",
+                "ruleID": "6MlXHRavmo1ujM1NkZNjhQ",
+            },
+        )
+        assert events[0]["secondaryExposures"] == [
+            {
+                "gate": "test_email",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+            {
+                "gate": "test_environment_tier",
+                "gateValue": "false",
+                "ruleID": "default",
+            },
+        ]
+    finally:
+        statsig.shutdown().wait()
+
+
+@pytest.mark.parametrize(
+    "sec_expo_number, should_log_as_primary",
+    [
+        (0, False),
+        (SEC_EXPO_AS_PRIMARY_FLAG_BUCKET, False),
+        (SEC_EXPO_AS_PRIMARY_FLAG_BUCKET + 1, True),
+        (1000, True),
+    ],
+)
+def test_secondary_exposures_roll_out_from_zero_to_thousand(
+    httpserver: HTTPServer,
+    sec_expo_number,
+    should_log_as_primary,
+):
+    statsig, mock_scrapi = _create_statsig(
+        httpserver,
+        experimental_flags={SEC_EXPO_AS_PRIMARY_FLAG},
+        sec_expo_number=sec_expo_number,
+    )
+
+    try:
+        assert statsig.check_gate(
+            StatsigUser("a_user_id"), "test_nested_gate_condition"
+        )
+        statsig.flush_events().wait()
+
+        events = mock_scrapi.get_logged_events()
+        if should_log_as_primary:
+            assert len(events) == 3
+            for event in events:
+                assert event["secondaryExposures"] == []
+        else:
+            assert len(events) == 1
+            assert len(events[0]["secondaryExposures"]) == 2
+    finally:
+        statsig.shutdown().wait()

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/statsig-rust/Cargo.toml

@@ -17,6 +17,7 @@ dashmap = "6.1.0"
 file-guard = "0.2.0"
 flate2 = "1.0.35"
 futures = "0.3.30"
+indexmap = { version = "2.13.0", features = ["serde"], optional = true }
 lazy_static = "1.5.0"
 log = "0.4.22"
 parking_lot = "0.12.1"
@@ -39,7 +40,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.19.1-beta.2604130314", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.19.2", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }
@@ -76,3 +77,4 @@ with_grpc = ["sigstat-grpc"]
 testing = []
 with_zstd = []
 ffi-support = []
+ordered_user_data_maps = ["dep:indexmap"]

{statsig_python_core-0.19.1b2604130314 → statsig_python_core-0.19.2}/statsig-rust/src/console_capture/console_capture_instances.rs

@@ -8,8 +8,8 @@ use crate::console_capture::console_log_line_levels::StatsigLogLineLevel;
 use parking_lot::RwLock;
 
 use crate::{
-    log_e, observability::ops_stats::OpsStatsForInstance, user::StatsigUserLoggable, DynamicValue,
-    StatsigOptions, OPS_STATS,
+    log_e, observability::ops_stats::OpsStatsForInstance, user::user_data::UserDataMap,
+    user::StatsigUserLoggable, DynamicValue, StatsigOptions, OPS_STATS,
 };
 
 const TAG: &str = stringify!(ConsoleCaptureRegistry);
@@ -51,12 +51,12 @@ impl ConsoleCaptureInstance {
         let loggable_user = if let Some(console_capture_user) = console_capture_options.user {
             StatsigUserLoggable::new(
                 &console_capture_user.data,
-                environment.clone(),
+                to_user_data_map(environment),
                 statsig_options.global_custom_fields.clone(),
             )
         } else {
             StatsigUserLoggable::default_console_capture_user(
-                environment.clone(),
+                to_user_data_map(environment),
                 statsig_options.global_custom_fields.clone(),
             )
         };
@@ -74,6 +74,15 @@ impl ConsoleCaptureInstance {
     }
 }
 
+fn to_user_data_map(environment: &Option<HashMap<String, DynamicValue>>) -> Option<UserDataMap> {
+    environment.as_ref().map(|environment| {
+        environment
+            .iter()
+            .map(|(key, value)| (key.clone(), value.clone()))
+            .collect()
+    })
+}
+
 impl ConsoleCaptureRegistry {
     pub fn get_for_instance(
         &self,