statsig-python-core 0.19.2b2604150312__tar.gz → 0.19.3__tar.gz

{statsig_python_core-0.19.2b2604150312 → statsig_python_core-0.19.3}/Cargo.lock

@@ -2869,7 +2869,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2961,7 +2961,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "async-trait",
  "napi",
@@ -2976,7 +2976,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2991,7 +2991,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3041,7 +3041,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3054,7 +3054,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.19.2-beta.2604150312"
+version = "0.19.3"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.19.2b2604150312 → statsig_python_core-0.19.3}/Cargo.toml

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

{statsig_python_core-0.19.2b2604150312 → statsig_python_core-0.19.3}/PKG-INFO

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

statsig_python_core-0.19.3/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.2b2604150312 → statsig_python_core-0.19.3}/statsig-rust/Cargo.toml

@@ -40,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.2-beta.2604150312", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.19.3", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.19.2b2604150312 → statsig_python_core-0.19.3}/statsig-rust/src/event_logging/event_logger.rs

@@ -3,10 +3,12 @@ use super::{
         batch::EventBatch,
         queue::{EventQueue, QueueReconcileResult},
         queued_event::{EnqueueOperation, QueuedEvent},
+        queued_secondary_expo::EnqueueSecondaryExposureAsPrimaryOp,
     },
     exposure_sampling::ExposureSampling,
     flush_interval::FlushInterval,
     flush_type::FlushType,
+    sec_expo_as_primary_experiment::SecExpoAsPrimaryExperiment,
     statsig_event_internal::StatsigEventInternal,
 };
 use crate::{
@@ -57,6 +59,7 @@ pub struct EventLogger {
     flush_interval: FlushInterval,
     shutdown_notify: Notify,
     ops_stats: Arc<OpsStatsForInstance>,
+    sec_expo_experiment: SecExpoAsPrimaryExperiment,
     enqueue_dropped_events_count: AtomicU64,
 }
 
@@ -85,6 +88,7 @@ impl EventLogger {
             limit_flush_notify: Notify::new(),
             limit_flush_semaphore: Arc::new(Semaphore::new(MAX_LIMIT_FLUSH_TASKS)),
             ops_stats: OPS_STATS.get_for_instance(sdk_key),
+            sec_expo_experiment: SecExpoAsPrimaryExperiment::new(sdk_key, options),
             enqueue_dropped_events_count: AtomicU64::new(0),
         });
 
@@ -97,12 +101,74 @@ impl EventLogger {
             return;
         }
 
-        let decision = self.event_sampler.get_sampling_decision(&operation);
+        let sec_expo_as_primary_active = self.sec_expo_experiment.should_log_as_primary();
+        let decision = self
+            .event_sampler
+            .get_sampling_decision(&operation, sec_expo_as_primary_active);
+
+        if sec_expo_as_primary_active {
+            let should_log_parent = decision.should_log();
+            let pending_event = operation.into_queued_event(decision);
+            self.enqueue_event_with_secondary_exposures_as_primary(
+                pending_event,
+                should_log_parent,
+            );
+            return;
+        }
+
         if !decision.should_log() {
             return;
         }
 
         let pending_event = operation.into_queued_event(decision);
+        self.add_pending_event(pending_event);
+    }
+
+    fn enqueue_event_with_secondary_exposures_as_primary(
+        &self,
+        mut pending_event: QueuedEvent,
+        should_log_parent: bool,
+    ) {
+        let Some(exposure_time) = pending_event.exposure_time() else {
+            if should_log_parent {
+                self.add_pending_event(pending_event);
+            }
+            return;
+        };
+        let secondary_exposures = pending_event.take_secondary_exposures_for_primary_logging();
+        if secondary_exposures.is_empty() {
+            if should_log_parent {
+                self.add_pending_event(pending_event);
+            }
+            return;
+        }
+
+        let Some(user) = pending_event.user_for_secondary_exposures() else {
+            if should_log_parent {
+                self.add_pending_event(pending_event);
+            }
+            return;
+        };
+
+        if should_log_parent {
+            self.add_pending_event(pending_event);
+        }
+
+        for secondary_exposure in secondary_exposures {
+            let operation = EnqueueSecondaryExposureAsPrimaryOp {
+                user: user.clone(),
+                secondary_exposure,
+                exposure_time,
+            };
+
+            let decision = self.event_sampler.get_sampling_decision(&operation, false);
+            if decision.should_log() {
+                self.add_pending_event(operation.into_queued_event(decision));
+            }
+        }
+    }
+
+    fn add_pending_event(&self, pending_event: QueuedEvent) {
         match self.queue.add(pending_event) {
             QueueAddResult::Noop => (),
             QueueAddResult::NeedsFlush => self.limit_flush_notify.notify_one(),

{statsig_python_core-0.19.2b2604150312 → statsig_python_core-0.19.3}/statsig-rust/src/event_logging/event_queue/mod.rs

@@ -7,3 +7,4 @@ pub mod queued_expo;
 pub mod queued_gate_expo;
 pub mod queued_layer_param_expo;
 pub mod queued_passthrough;
+pub mod queued_secondary_expo;