statsig-python-core 0.15.1b2601310133__tar.gz → 0.15.1rc2601270136__tar.gz

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/Cargo.lock

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

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/Cargo.toml

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

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/PKG-INFO

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

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/Cargo.toml

@@ -38,7 +38,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.15.1-beta.2601310133", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.15.1-rc.2601270136", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -222,7 +222,13 @@ fn test_a_param_store_json_vs_proto() {
     let mut proto_spec = get_proto_spec_param_store("test_parameter_store");
     proto_spec.remove("checksum");
 
-    let json_spec = get_json_spec("param_stores", "test_parameter_store").clone();
+    let mut json_spec = get_json_spec("param_stores", "test_parameter_store").clone();
+
+    // the 'name' field is redundant, so we didn't include it in the Protobuf schema
+    json_spec["parameters"]["bool_param"]
+        .as_object_mut()
+        .unwrap()
+        .remove("name");
 
     assert_json_diff::assert_json_matches!(proto_spec, json_spec, get_json_compare_config());
 }

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/src/specs_response/param_store_types.rs

@@ -1,6 +1,5 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use serde_with::skip_serializing_none;
 use std::collections::HashMap;
 
 use crate::{gcir::gcir_formatter::GCIRHashable, hashing, interned_string::InternedString};
@@ -32,18 +31,14 @@ impl GCIRHashable for ParameterStore {
 }
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
-#[skip_serializing_none]
 pub struct StaticValueParameter {
-    pub name: Option<String>,
     pub ref_type: String,
     pub param_type: String,
     pub value: Value,
 }
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
-#[skip_serializing_none]
 pub struct GateParameter {
-    pub name: Option<String>,
     pub ref_type: String,
     pub param_type: String,
     pub gate_name: String,
@@ -52,9 +47,7 @@ pub struct GateParameter {
 }
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
-#[skip_serializing_none]
 pub struct DynamicConfigParameter {
-    pub name: Option<String>,
     pub ref_type: String,
     pub param_type: String,
     pub config_name: String,
@@ -62,9 +55,7 @@ pub struct DynamicConfigParameter {
 }
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
-#[skip_serializing_none]
 pub struct ExperimentParameter {
-    pub name: Option<String>,
     pub ref_type: String,
     pub param_type: String,
     pub experiment_name: String,
@@ -72,9 +63,7 @@ pub struct ExperimentParameter {
 }
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
-#[skip_serializing_none]
 pub struct LayerParameter {
-    pub name: Option<String>,
     pub ref_type: String,
     pub param_type: String,
     pub layer_name: String,

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/src/specs_response/spec_types.rs

@@ -128,18 +128,6 @@ pub struct SessionReplayInfo {
     pub session_recording_privacy_settings: Option<SessionReplayPrivacySetting>,
 }
 
-#[skip_serializing_none]
-#[derive(Serialize, Deserialize, PartialEq, Debug)] /* DO_NOT_CLONE */
-pub struct AutoCaptureSettings {
-    pub disabled_events: HashMap<InternedString, bool>,
-}
-
-#[skip_serializing_none]
-#[derive(Serialize, Deserialize, PartialEq, Debug)] /* DO_NOT_CLONE */
-pub struct GCIRConfig {
-    pub remove_default_value_gates: bool,
-}
-
 // All this macro logic is to ensure that new fields that are added are automatically handled by the merge_from_partial method.
 macro_rules! flatten_struct {
     (
@@ -181,8 +169,7 @@ macro_rules! response_struct {
                 pub sdk_flags: Option<HashMap<String, bool>>,
                 pub sdk_keys_to_app_ids: Option<HashMap<String, DynamicValue>>,
                 pub session_replay_info: Option<SessionReplayInfo>,
-                pub auto_capture_settings: Option<AutoCaptureSettings>,
-                pub gcir_config: Option<GCIRConfig>,
+
                 // Add new fields here
             },
             { $( $special )* }

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/src/statsig_metadata.rs

@@ -10,7 +10,7 @@ lazy_static! {
     static ref STATSIG_METADATA: RwLock<StatsigMetadata> = RwLock::new(StatsigMetadata::new());
 }
 
-pub const SDK_VERSION: &str = "0.15.1-beta.2601310133";
+pub const SDK_VERSION: &str = "0.15.1-rc.2601270136";
 
 const TAG: &str = stringify!(StatsigMetadata);
 

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/src/statsig_options.rs

@@ -4,7 +4,6 @@ use serde::{Serialize, Serializer};
 use crate::console_capture::console_capture_options::ConsoleCaptureOptions;
 use crate::data_store_interface::{DataStoreKeyVersion, DataStoreTrait};
 use crate::evaluation::dynamic_value::DynamicValue;
-use crate::event_logging::event_logger;
 use crate::event_logging_adapter::EventLoggingAdapter;
 use crate::id_lists_adapter::IdListsAdapter;
 use crate::networking::proxy_config::ProxyConfig;
@@ -451,29 +450,6 @@ impl StatsigOptions {
             mut_ref.id_lists_sync_interval_ms = None;
         }
 
-        if bounds_check_logging_batch_size(&self.event_logging_max_queue_size) {
-            log_w!(
-                TAG,
-                "Invalid 'event_logging_max_queue_size', value cannot be lower than {} or greater than {}, received {:?}",
-                event_logger::MIN_BATCH_SIZE,
-                event_logger::MAX_BATCH_SIZE,
-                &self.event_logging_max_queue_size
-            );
-            mut_ref.event_logging_max_queue_size = None;
-        }
-
-        if bounds_check_loggging_pending_queue_size(
-            &self.event_logging_max_pending_batch_queue_size,
-        ) {
-            log_w!(
-                TAG,
-                "Invalid 'event_logging_max_pending_batch_queue_size', value cannot be lower than {}, received {:?}",
-                event_logger::MIN_PENDING_BATCH_COUNT,
-                &self.event_logging_max_pending_batch_queue_size
-            );
-            mut_ref.event_logging_max_pending_batch_queue_size = None;
-        }
-
         if should_fix_null_url(&self.specs_url) {
             log_d!(TAG, "Setting specs_url to be default url");
             mut_ref.specs_url = None;
@@ -507,18 +483,3 @@ fn should_fix_null_url(maybe_url: &Option<String>) -> bool {
 
     false
 }
-
-fn bounds_check_logging_batch_size(batch_size: &Option<u32>) -> bool {
-    if let Some(batch_size) = batch_size {
-        return *batch_size < event_logger::MIN_BATCH_SIZE
-            || *batch_size > event_logger::MAX_BATCH_SIZE;
-    }
-    false
-}
-
-fn bounds_check_loggging_pending_queue_size(queue_size: &Option<u32>) -> bool {
-    if let Some(queue_size) = queue_size {
-        return *queue_size < event_logger::MIN_PENDING_BATCH_COUNT;
-    }
-    false
-}

{statsig_python_core-0.15.1b2601310133 → statsig_python_core-0.15.1rc2601270136}/statsig-rust/tests/gate_inversion_eval_tests.rs

@@ -38,7 +38,13 @@ async fn test_fail_gate_passes_when_target_gate_does_not_exist() {
 
     assert_json_eq!(
         json!(&logging_adapter.force_get_first_event()["secondaryExposures"]),
-        json!([])
+        json!([
+            {
+                "gate": "non_existent_gate",
+                "gateValue": "false",
+                "ruleID": ""
+            }
+        ])
     );
 }
 
@@ -55,7 +61,13 @@ async fn test_fail_gate_passes_when_target_gate_name_is_empty() {
 
     assert_json_eq!(
         json!(&logging_adapter.force_get_first_event()["secondaryExposures"]),
-        json!([])
+        json!([
+            {
+                "gate": "",
+                "gateValue": "false",
+                "ruleID": ""
+            }
+        ])
     );
 }
 
@@ -72,7 +84,13 @@ async fn test_pass_gate_passes_when_target_gate_does_not_exist() {
 
     assert_json_eq!(
         json!(&logging_adapter.force_get_first_event()["secondaryExposures"]),
-        json!([])
+        json!([
+            {
+                "gate": "non_existent_gate",
+                "gateValue": "false",
+                "ruleID": ""
+            }
+        ])
     );
 }
 
@@ -89,6 +107,12 @@ async fn test_pass_gate_passes_when_target_gate_name_is_empty() {
 
     assert_json_eq!(
         json!(&logging_adapter.force_get_first_event()["secondaryExposures"]),
-        json!([])
+        json!([
+            {
+                "gate": "",
+                "gateValue": "false",
+                "ruleID": ""
+            }
+        ])
     );
 }

statsig_python_core-0.15.1rc2601270136/statsig-rust/tests/statsig_options_tests.rs

@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use statsig_rust::{Statsig, StatsigOptions};
+
+mod utils;
+
+#[test]
+fn test_statsig_options() {
+    std::env::remove_var("STATSIG_RUNNING_TESTS");
+    let mut invalid_option = StatsigOptions::new();
+    invalid_option.specs_sync_interval_ms = Some(10);
+    invalid_option.id_lists_sync_interval_ms = Some(10);
+    invalid_option.specs_url = Some("".to_string());
+    invalid_option.id_lists_url = Some("".to_string());
+    invalid_option.log_event_url = Some("".to_string());
+    let statsig = Statsig::new("secret-key", Some(Arc::new(invalid_option)));
+    assert_eq!(statsig.options.specs_sync_interval_ms, None);
+    assert_eq!(statsig.options.id_lists_sync_interval_ms, None);
+    assert_eq!(statsig.options.log_event_url, None);
+    assert_eq!(statsig.options.id_lists_url, None);
+    assert_eq!(statsig.options.specs_url, None);
+}

statsig_python_core-0.15.1b2601310133/statsig-rust/tests/statsig_options_tests.rs

@@ -1,80 +0,0 @@
-use std::sync::Arc;
-
-use serial_test::serial;
-use statsig_rust::event_logging::event_logger;
-use statsig_rust::{Statsig, StatsigOptions};
-
-mod utils;
-
-#[test]
-#[serial]
-fn test_statsig_options() {
-    std::env::remove_var("STATSIG_RUNNING_TESTS");
-    let mut invalid_option = StatsigOptions::new();
-    invalid_option.specs_sync_interval_ms = Some(10);
-    invalid_option.id_lists_sync_interval_ms = Some(10);
-    invalid_option.specs_url = Some("".to_string());
-    invalid_option.id_lists_url = Some("".to_string());
-    invalid_option.log_event_url = Some("".to_string());
-    let statsig = Statsig::new("secret-key", Some(Arc::new(invalid_option)));
-    assert_eq!(statsig.options.specs_sync_interval_ms, None);
-    assert_eq!(statsig.options.id_lists_sync_interval_ms, None);
-    assert_eq!(statsig.options.log_event_url, None);
-    assert_eq!(statsig.options.id_lists_url, None);
-    assert_eq!(statsig.options.specs_url, None);
-}
-
-#[test]
-#[serial]
-fn test_event_logging_options_validation_clears_invalid_values() {
-    std::env::remove_var("STATSIG_RUNNING_TESTS");
-
-    let mut invalid_option = StatsigOptions::new();
-    invalid_option.event_logging_max_queue_size = Some(999999999);
-    invalid_option.event_logging_max_pending_batch_queue_size = Some(0);
-
-    let statsig = Statsig::new("secret-key", Some(Arc::new(invalid_option)));
-    assert_eq!(statsig.options.event_logging_max_queue_size, None);
-    assert_eq!(
-        statsig.options.event_logging_max_pending_batch_queue_size,
-        None
-    );
-}
-
-#[test]
-#[serial]
-fn test_event_logging_options_validation_keeps_valid_values() {
-    std::env::remove_var("STATSIG_RUNNING_TESTS");
-
-    let mut valid_option = StatsigOptions::new();
-    valid_option.event_logging_max_queue_size = Some(50);
-    valid_option.event_logging_max_pending_batch_queue_size = Some(99999);
-
-    let statsig = Statsig::new("secret-key", Some(Arc::new(valid_option)));
-    assert_eq!(statsig.options.event_logging_max_queue_size, Some(50));
-    assert_eq!(
-        statsig.options.event_logging_max_pending_batch_queue_size,
-        Some(99999)
-    );
-}
-
-#[test]
-#[serial]
-fn test_event_logging_options_validation_skipped_in_test_env() {
-    std::env::set_var("STATSIG_RUNNING_TESTS", "true");
-
-    let mut options = StatsigOptions::new();
-    options.event_logging_max_queue_size = Some(event_logger::MIN_BATCH_SIZE - 1);
-    options.event_logging_max_pending_batch_queue_size =
-        Some(event_logger::DEFAULT_PENDING_BATCH_COUNT_MAX - 1);
-
-    let statsig = Statsig::new("secret-key", Some(Arc::new(options)));
-    assert_eq!(
-        statsig.options.event_logging_max_queue_size,
-        Some(event_logger::MIN_BATCH_SIZE - 1)
-    );
-    assert_eq!(
-        statsig.options.event_logging_max_pending_batch_queue_size,
-        Some(event_logger::DEFAULT_PENDING_BATCH_COUNT_MAX - 1)
-    );
-}