statsig 1.30.0 → 1.32.0

data/lib/statsig_driver.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require 'config_result'
 require 'evaluator'
 require 'network'
@@ -13,13 +11,11 @@ require 'dynamic_config'
 require 'feature_gate'
 require 'error_boundary'
 require 'layer'
-require 'sorbet-runtime'
+
 require 'diagnostics'
 
 class StatsigDriver
-  extend T::Sig
 
-  sig { params(secret_key: String, options: T.any(StatsigOptions, NilClass), error_callback: T.any(Method, Proc, NilClass)).void }
   def initialize(secret_key, options = nil, error_callback = nil)
     unless secret_key.start_with?('secret-')
       raise Statsig::ValueError.new('Invalid secret key provided. Provide your project secret key from the Statsig console')
@@ -31,8 +27,8 @@ class StatsigDriver
 
     @err_boundary = Statsig::ErrorBoundary.new(secret_key)
     @err_boundary.capture(task: lambda {
-      @diagnostics = Statsig::Diagnostics.new('initialize')
-      tracker = @diagnostics.track('overall')
+      @diagnostics = Statsig::Diagnostics.new()
+      tracker = @diagnostics.track('initialize', 'overall')
       @options = options || StatsigOptions.new
       @shutdown = false
       @secret_key = secret_key
@@ -43,101 +39,102 @@ class StatsigDriver
       @evaluator = Statsig::Evaluator.new(@store, @options, @persistent_storage_utils)
       tracker.end(success: true)
 
-      @logger.log_diagnostics_event(@diagnostics)
+      @logger.log_diagnostics_event(@diagnostics, 'initialize')
     }, caller: __method__.to_s)
   end
 
-  sig do
-    params(
-      user: StatsigUser,
-      gate_name: String,
-      disable_log_exposure: T::Boolean,
-      skip_evaluation: T::Boolean
-    ).returns(FeatureGate)
-  end
-  def get_gate_impl(user, gate_name, disable_log_exposure: false, skip_evaluation: false)
+  def get_gate_impl(user, gate_name, disable_log_exposure: false, skip_evaluation: false, disable_evaluation_details: false)
     if skip_evaluation
       gate = @store.get_gate(gate_name)
       return FeatureGate.new(gate_name) if gate.nil?
-      return FeatureGate.new(gate['name'], target_app_ids: gate['targetAppIDs'])
+      return FeatureGate.new(gate.name, target_app_ids: gate.target_app_ids)
     end
     user = verify_inputs(user, gate_name, 'gate_name')
 
-    res = @evaluator.check_gate(user, gate_name)
-    if res.nil?
-      res = Statsig::ConfigResult.new(gate_name)
-    end
+    res = Statsig::ConfigResult.new(name: gate_name, disable_exposures: disable_log_exposure, disable_evaluation_details: disable_evaluation_details)
+    @evaluator.check_gate(user, gate_name, res)
 
-    if res == $fetch_from_server
-      res = check_gate_fallback(user, gate_name)
-      # exposure logged by the server
-    else
-      unless disable_log_exposure
-        @logger.log_gate_exposure(
-          user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
-        )
-      end
+    unless disable_log_exposure
+      @logger.log_gate_exposure(
+        user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
+      )
     end
     FeatureGate.from_config_result(res)
   end
 
-  sig { params(user: StatsigUser, gate_name: String, options: Statsig::GetGateOptions).returns(FeatureGate) }
-  def get_gate(user, gate_name, options = Statsig::GetGateOptions.new)
+  def get_gate(user, gate_name, options = nil)
     @err_boundary.capture(task: lambda {
       run_with_diagnostics(task: lambda {
-        get_gate_impl(user, gate_name, disable_log_exposure: options.disable_log_exposure, skip_evaluation: options.skip_evaluation)
+        get_gate_impl(user, gate_name,
+                      disable_log_exposure: options&.disable_log_exposure == true,
+                      skip_evaluation: options&.skip_evaluation == true,
+                      disable_evaluation_details: options&.disable_evaluation_details == true
+        )
       }, caller: __method__.to_s)
     }, recover: -> { false }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, gate_name: String, options: Statsig::CheckGateOptions).returns(T::Boolean) }
-  def check_gate(user, gate_name, options = Statsig::CheckGateOptions.new)
+  def check_gate(user, gate_name, options = nil)
     @err_boundary.capture(task: lambda {
       run_with_diagnostics(task: lambda {
-        get_gate_impl(user, gate_name, disable_log_exposure: options.disable_log_exposure).value
+        get_gate_impl(
+          user,
+          gate_name,
+          disable_log_exposure: options&.disable_log_exposure == true,
+          disable_evaluation_details: options&.disable_evaluation_details == true
+        ).value
       }, caller: __method__.to_s)
     }, recover: -> { false }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, gate_name: String).void }
   def manually_log_gate_exposure(user, gate_name)
     @err_boundary.capture(task: lambda {
-      res = @evaluator.check_gate(user, gate_name)
-      context = { 'is_manual_exposure' => true }
+      res = Statsig::ConfigResult.new(name: gate_name)
+      @evaluator.check_gate(user, gate_name, res)
+      context = { :is_manual_exposure => true }
       @logger.log_gate_exposure(user, gate_name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
     })
   end
 
-  sig { params(user: StatsigUser, dynamic_config_name: String, options: Statsig::GetConfigOptions).returns(DynamicConfig) }
-  def get_config(user, dynamic_config_name, options = Statsig::GetConfigOptions.new)
+  def get_config(user, dynamic_config_name, options = nil)
     @err_boundary.capture(task: lambda {
       run_with_diagnostics(task: lambda {
         user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
-        get_config_impl(user, dynamic_config_name, options.disable_log_exposure)
+        get_config_impl(
+          user,
+          dynamic_config_name,
+          options&.disable_log_exposure == true,
+          disable_evaluation_details: options&.disable_evaluation_details == true
+        )
       }, caller: __method__.to_s)
     }, recover: -> { DynamicConfig.new(dynamic_config_name) }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, experiment_name: String, options: Statsig::GetExperimentOptions).returns(DynamicConfig) }
-  def get_experiment(user, experiment_name, options = Statsig::GetExperimentOptions.new)
+  def get_experiment(user, experiment_name, options = nil)
     @err_boundary.capture(task: lambda {
       run_with_diagnostics(task: lambda {
         user = verify_inputs(user, experiment_name, "experiment_name")
-        get_config_impl(user, experiment_name, options.disable_log_exposure, user_persisted_values: options.user_persisted_values)
+        get_config_impl(
+          user,
+          experiment_name,
+          options&.disable_log_exposure == true,
+          user_persisted_values: options&.user_persisted_values,
+          disable_evaluation_details: options&.disable_evaluation_details == true
+        )
       }, caller: __method__.to_s)
     }, recover: -> { DynamicConfig.new(experiment_name) }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, config_name: String).void }
   def manually_log_config_exposure(user, config_name)
     @err_boundary.capture(task: lambda {
-      res = @evaluator.get_config(user, config_name)
-      context = { 'is_manual_exposure' => true }
+      res = Statsig::ConfigResult.new(name: config_name)
+      @evaluator.get_config(user, config_name, res)
+
+      context = { :is_manual_exposure => true }
       @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
     }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, id_type: String).returns(Statsig::UserPersistedValues) }
   def get_user_persisted_values(user, id_type)
     @err_boundary.capture(task: lambda {
       persisted_values = @persistent_storage_utils.get_user_persisted_values(user, id_type)
@@ -147,39 +144,34 @@ class StatsigDriver
     }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, layer_name: String, options: Statsig::GetLayerOptions).returns(Layer) }
-  def get_layer(user, layer_name, options = Statsig::GetLayerOptions.new)
+  def get_layer(user, layer_name, options = nil)
     @err_boundary.capture(task: lambda {
       run_with_diagnostics(task: lambda {
         user = verify_inputs(user, layer_name, "layer_name")
+        exposures_disabled = options&.disable_log_exposure == true
+        res = Statsig::ConfigResult.new(
+          name: layer_name,
+          disable_exposures: exposures_disabled,
+          disable_evaluation_details: options&.disable_evaluation_details == true
+        )
+        @evaluator.get_layer(user, layer_name, res)
 
-        res = @evaluator.get_layer(user, layer_name)
-        if res.nil?
-          res = Statsig::ConfigResult.new(layer_name)
-        end
-
-        if res == $fetch_from_server
-          if res.config_delegate.nil?
-            return Layer.new(layer_name)
-          end
-          res = get_config_fallback(user, res.config_delegate)
-          # exposure logged by the server
-        end
-
-        exposure_log_func = !options.disable_log_exposure ? lambda { |layer, parameter_name|
+        exposure_log_func = !exposures_disabled ? lambda { |layer, parameter_name|
           @logger.log_layer_exposure(user, layer, parameter_name, res)
         } : nil
+
         Layer.new(res.name, res.json_value, res.rule_id, res.group_name, res.config_delegate, exposure_log_func)
       }, caller: __method__.to_s)
     }, recover: lambda { Layer.new(layer_name) }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, layer_name: String, parameter_name: String).void }
   def manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
     @err_boundary.capture(task: lambda {
-      res = @evaluator.get_layer(user, layer_name)
+      res = Statsig::ConfigResult.new(name: layer_name)
+      @evaluator.get_layer(user, layer_name, res)
+
       layer = Layer.new(layer_name, res.json_value, res.rule_id, res.group_name, res.config_delegate)
-      context = { 'is_manual_exposure' => true }
+      context = { :is_manual_exposure => true }
       @logger.log_layer_exposure(user, layer, parameter_name, res, context)
     }, caller: __method__.to_s)
   end
@@ -213,35 +205,30 @@ class StatsigDriver
     }, caller: __method__.to_s)
   end
 
-  sig { returns(T::Array[String]) }
   def list_gates
     @err_boundary.capture(task: lambda {
       @evaluator.list_gates
     }, caller: __method__.to_s)
   end
 
-  sig { returns(T::Array[String]) }
   def list_configs
     @err_boundary.capture(task: lambda {
       @evaluator.list_configs
     }, caller: __method__.to_s)
   end
 
-  sig { returns(T::Array[String]) }
   def list_experiments
     @err_boundary.capture(task: lambda {
       @evaluator.list_experiments
     }, caller: __method__.to_s)
   end
 
-  sig { returns(T::Array[String]) }
   def list_autotunes
     @err_boundary.capture(task: lambda {
       @evaluator.list_autotunes
     }, caller: __method__.to_s)
   end
 
-  sig { returns(T::Array[String]) }
   def list_layers
     @err_boundary.capture(task: lambda {
       @evaluator.list_layers
@@ -295,8 +282,8 @@ class StatsigDriver
   def run_with_diagnostics(task:, caller:)
     diagnostics = nil
     if Statsig::Diagnostics::API_CALL_KEYS.include?(caller) && Statsig::Diagnostics.sample(1)
-      diagnostics = Statsig::Diagnostics.new('api_call')
-      tracker = diagnostics.track(caller)
+      diagnostics = Statsig::Diagnostics.new()
+      tracker = diagnostics.track('api_call', caller)
     end
     begin
       res = task.call
@@ -305,12 +292,11 @@ class StatsigDriver
       tracker&.end(success: false)
       raise e
     ensure
-      @logger.log_diagnostics_event(diagnostics)
+      @logger.log_diagnostics_event(diagnostics, 'api_call')
     end
     return res
   end
 
-  sig { params(user: StatsigUser, config_name: String, variable_name: String).returns(StatsigUser) }
   def verify_inputs(user, config_name, variable_name)
     validate_user(user)
     if !config_name.is_a?(String) || config_name.empty?
@@ -322,27 +308,16 @@ class StatsigDriver
     normalize_user(user)
   end
 
-  sig do
-    params(
-      user: StatsigUser,
-      config_name: String,
-      disable_log_exposure: T::Boolean,
-      user_persisted_values: T.nilable(Statsig::UserPersistedValues)
-    ).returns(DynamicConfig)
-  end
-  def get_config_impl(user, config_name, disable_log_exposure, user_persisted_values: nil)
-    res = @evaluator.get_config(user, config_name, user_persisted_values: user_persisted_values)
-    if res.nil?
-      res = Statsig::ConfigResult.new(config_name)
-    end
+  def get_config_impl(user, config_name, disable_log_exposure, user_persisted_values: nil, disable_evaluation_details: false)
+    res = Statsig::ConfigResult.new(
+      name: config_name,
+      disable_exposures: disable_log_exposure,
+      disable_evaluation_details: disable_evaluation_details
+    )
+    @evaluator.get_config(user, config_name, res, user_persisted_values: user_persisted_values)
 
-    if res == $fetch_from_server
-      res = get_config_fallback(user, config_name)
-      # exposure logged by the server
-    else
-      if !disable_log_exposure
-        @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
-      end
+    unless disable_log_exposure
+      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
     end
 
     DynamicConfig.new(res.name, res.json_value, res.rule_id, res.group_name, res.id_type, res.evaluation_details)
@@ -372,34 +347,4 @@ class StatsigDriver
       puts 'SDK has been shutdown.  Updates in the Statsig Console will no longer reflect.'
     end
   end
-
-  def check_gate_fallback(user, gate_name)
-    network_result = @net.check_gate(user, gate_name)
-    if network_result.nil?
-      config_result = Statsig::ConfigResult.new(gate_name)
-      return config_result
-    end
-
-    Statsig::ConfigResult.new(
-      network_result['name'],
-      network_result['value'],
-      {},
-      network_result['rule_id'],
-    )
-  end
-
-  def get_config_fallback(user, dynamic_config_name)
-    network_result = @net.get_config(user, dynamic_config_name)
-    if network_result.nil?
-      config_result = Statsig::ConfigResult.new(dynamic_config_name)
-      return config_result
-    end
-
-    Statsig::ConfigResult.new(
-      network_result['name'],
-      false,
-      network_result['value'],
-      network_result['rule_id'],
-    )
-  end
 end

data/lib/statsig_errors.rb

@@ -1,4 +1,4 @@
-# typed: true
+
 module Statsig
   class UninitializedError < StandardError
     def initialize(msg="Must call initialize first.")

data/lib/statsig_event.rb

@@ -1,4 +1,4 @@
-# typed: true
+
 class StatsigEvent
   attr_accessor :value, :metadata, :statsig_metadata, :secondary_exposures
   attr_reader :user
@@ -21,13 +21,13 @@ class StatsigEvent
 
   def serialize
     {
-      'eventName' => @event_name,
-      'metadata' => @metadata,
-      'value' => @value,
-      'user' => @user,
-      'time' => @time,
-      'statsigMetadata' => @statsig_metadata,
-      'secondaryExposures' => @secondary_exposures
+      :eventName => @event_name,
+      :metadata => @metadata,
+      :value => @value,
+      :user => @user,
+      :time => @time,
+      :statsigMetadata => @statsig_metadata,
+      :secondaryExposures => @secondary_exposures
     }
   end
 end

data/lib/statsig_logger.rb

@@ -1,4 +1,4 @@
-# typed: true
+require 'constants'
 require 'statsig_event'
 require 'concurrent-ruby'
 
@@ -6,7 +6,7 @@ $gate_exposure_event = 'statsig::gate_exposure'
 $config_exposure_event = 'statsig::config_exposure'
 $layer_exposure_event = 'statsig::layer_exposure'
 $diagnostics_event = 'statsig::diagnostics'
-$ignored_metadata_keys = ['serverTime', 'configSyncTime', 'initTime', 'reason']
+$ignored_metadata_keys = [:serverTime, :configSyncTime, :initTime, :reason]
 module Statsig
   class StatsigLogger
     def initialize(network, options, error_boundary)
@@ -41,9 +41,9 @@ module Statsig
       event = StatsigEvent.new($gate_exposure_event)
       event.user = user
       metadata = {
-        'gate' => gate_name,
-        'gateValue' => value.to_s,
-        'ruleID' => rule_id,
+        gate: gate_name,
+        gateValue: value.to_s,
+        ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
       return false if not is_unique_exposure(user, $gate_exposure_event, metadata)
       event.metadata = metadata
@@ -59,8 +59,8 @@ module Statsig
       event = StatsigEvent.new($config_exposure_event)
       event.user = user
       metadata = {
-        'config' => config_name,
-        'ruleID' => rule_id,
+        config: config_name,
+        ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
       return false if not is_unique_exposure(user, $config_exposure_event, metadata)
       event.metadata = metadata
@@ -72,8 +72,8 @@ module Statsig
     end
 
     def log_layer_exposure(user, layer, parameter_name, config_evaluation, context = nil)
-      exposures = config_evaluation.undelegated_sec_exps
-      allocated_experiment = ''
+      exposures = config_evaluation.undelegated_sec_exps || []
+      allocated_experiment = Statsig::Const::EMPTY_STR
       is_explicit = (config_evaluation.explicit_parameters&.include? parameter_name) || false
       if is_explicit
         allocated_experiment = config_evaluation.config_delegate
@@ -83,13 +83,13 @@ module Statsig
       event = StatsigEvent.new($layer_exposure_event)
       event.user = user
       metadata = {
-        'config' => layer.name,
-        'ruleID' => layer.rule_id,
-        'allocatedExperiment' => allocated_experiment,
-        'parameterName' => parameter_name,
-        'isExplicitParameter' => String(is_explicit),
+        config: layer.name,
+        ruleID: layer.rule_id || Statsig::Const::EMPTY_STR,
+        allocatedExperiment: allocated_experiment,
+        parameterName: parameter_name,
+        isExplicitParameter: String(is_explicit)
       }
-      return false if not is_unique_exposure(user, $layer_exposure_event, metadata)
+      return false unless is_unique_exposure(user, $layer_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
 
@@ -98,18 +98,21 @@ module Statsig
       log_event(event)
     end
 
-    def log_diagnostics_event(diagnostics, user = nil)
-      return if @options.disable_diagnostics_logging
+    def log_diagnostics_event(diagnostics, context, user = nil)
       return if diagnostics.nil?
+      if @options.disable_diagnostics_logging
+        diagnostics.clear_markers(context)
+        return
+      end
 
       event = StatsigEvent.new($diagnostics_event)
       event.user = user
-      serialized = diagnostics.serialize_with_sampling
+      serialized = diagnostics.serialize_with_sampling(context)
+      diagnostics.clear_markers(context)
       return if serialized[:markers].empty?
 
       event.metadata = serialized
       log_event(event)
-      diagnostics.clear_markers
     end
 
     def periodic_flush
@@ -164,10 +167,10 @@ module Statsig
         return
       end
 
-      event.metadata['reason'] = eval_details.reason
-      event.metadata['configSyncTime'] = eval_details.config_sync_time
-      event.metadata['initTime'] = eval_details.init_time
-      event.metadata['serverTime'] = eval_details.server_time
+      event.metadata[:reason] = eval_details.reason
+      event.metadata[:configSyncTime] = eval_details.config_sync_time
+      event.metadata[:initTime] = eval_details.init_time
+      event.metadata[:serverTime] = eval_details.server_time
     end
 
     def safe_add_exposure_context(context, event)
@@ -175,8 +178,8 @@ module Statsig
         return
       end
 
-      if context['is_manual_exposure']
-        event.metadata['isManualExposure'] = 'true'
+      if context[:is_manual_exposure]
+        event.metadata[:isManualExposure] = 'true'
       end
     end
 
@@ -204,4 +207,4 @@ module Statsig
       true
     end
   end
-end
+end

data/lib/statsig_options.rb

@@ -1,142 +1,92 @@
-# typed: true
-
-require 'sorbet-runtime'
 require_relative 'interfaces/data_store'
 require_relative 'interfaces/user_persistent_storage'
 
 ##
 # Configuration options for the Statsig SDK.
 class StatsigOptions
-  extend T::Sig
 
-  sig { returns(T.any(T::Hash[String, String], NilClass)) }
   # Hash you can use to set environment variables that apply to all of your users in
   # the same session and will be used for targeting purposes.
   # eg. { "tier" => "development" }
   attr_accessor :environment
 
-  sig { returns(String) }
   # The base url used to make network calls to Statsig.
   # default: https://statsigapi.net/v1
   attr_accessor :api_url_base
 
   # The base url used specifically to call download_config_specs.
   # Takes precedence over api_url_base
-  sig { returns(String) }
   attr_accessor :api_url_download_config_specs
 
-  sig { returns(T.any(Float, Integer)) }
   # The interval (in seconds) to poll for changes to your Statsig configuration
   # default: 10s
   attr_accessor :rulesets_sync_interval
 
-  sig { returns(T.any(Float, Integer)) }
   # The interval (in seconds) to poll for changes to your id lists
   # default: 60s
   attr_accessor :idlists_sync_interval
 
   # Disable background syncing for rulesets
-  sig { returns(T::Boolean) }
   attr_accessor :disable_rulesets_sync
 
   # Disable background syncing for id lists
-  sig { returns(T::Boolean) }
   attr_accessor :disable_idlists_sync
 
-  sig { returns(T.any(Float, Integer)) }
   # How often to flush logs to Statsig
   # default: 60s
   attr_accessor :logging_interval_seconds
 
-  sig { returns(Integer) }
   # The maximum number of events to batch before flushing logs to the server
   # default: 1000
   attr_accessor :logging_max_buffer_size
 
-  sig { returns(T::Boolean) }
   # Restricts the SDK to not issue any network requests and only respond with default values (or local overrides)
   # default: false
   attr_accessor :local_mode
 
-  sig { returns(T.any(String, NilClass)) }
   # A string that represents all rules for all feature gates, dynamic configs and experiments.
   # It can be provided to bootstrap the Statsig server SDK at initialization in case your server runs
   # into network issue or Statsig is down temporarily.
   attr_accessor :bootstrap_values
 
-  sig { returns(T.any(Method, Proc, NilClass)) }
   # A callback function that will be called anytime the rulesets are updated.
   attr_accessor :rules_updated_callback
 
-  sig { returns(T.any(Statsig::Interfaces::IDataStore, NilClass)) }
   # A class that extends IDataStore. Can be used to provide values from a
   # common data store (like Redis) to initialize the Statsig SDK.
   attr_accessor :data_store
 
-  sig { returns(Integer) }
   # The number of threads allocated to syncing IDLists.
   # default: 3
   attr_accessor :idlist_threadpool_size
 
-  sig { returns(Integer) }
   # The number of threads allocated to posting event logs.
   # default: 3
   attr_accessor :logger_threadpool_size
 
-  sig { returns(T::Boolean) }
   # Should diagnostics be logged. These include performance metrics for initialize.
   # default: false
   attr_accessor :disable_diagnostics_logging
 
-  sig { returns(T::Boolean) }
   # Statsig utilizes Sorbet (https://sorbet.org) to ensure type safety of the SDK. This includes logging
   # to console when errors are detected. You can disable this logging by setting this flag to true.
   # default: false
   attr_accessor :disable_sorbet_logging_handlers
 
-  sig { returns(T.any(Integer, NilClass)) }
   # Number of seconds before a network call is timed out
   attr_accessor :network_timeout
 
-  sig { returns(Integer) }
   # Number of times to retry sending a batch of failed log events
   attr_accessor :post_logs_retry_limit
 
-  sig { returns(T.any(Method, Proc, Integer, NilClass)) }
   # The number of seconds, or a function that returns the number of seconds based on the number of retries remaining
   # which overrides the default backoff time between retries
   attr_accessor :post_logs_retry_backoff
 
-  sig { returns(T.any(Statsig::Interfaces::IUserPersistentStorage, NilClass)) }
   # A storage adapter for persisted values. Can be used for sticky bucketing users in experiments.
   # Implements Statsig::Interfaces::IUserPersistentStorage.
   attr_accessor :user_persistent_storage
 
-  sig do
-    params(
-      environment: T.any(T::Hash[String, String], NilClass),
-      api_url_base: T.nilable(String),
-      api_url_download_config_specs: T.any(String, NilClass),
-      rulesets_sync_interval: T.any(Float, Integer),
-      idlists_sync_interval: T.any(Float, Integer),
-      disable_rulesets_sync: T::Boolean,
-      disable_idlists_sync: T::Boolean,
-      logging_interval_seconds: T.any(Float, Integer),
-      logging_max_buffer_size: Integer,
-      local_mode: T::Boolean,
-      bootstrap_values: T.any(String, NilClass),
-      rules_updated_callback: T.any(Method, Proc, NilClass),
-      data_store: T.any(Statsig::Interfaces::IDataStore, NilClass),
-      idlist_threadpool_size: Integer,
-      logger_threadpool_size: Integer,
-      disable_diagnostics_logging: T::Boolean,
-      disable_sorbet_logging_handlers: T::Boolean,
-      network_timeout: T.any(Integer, NilClass),
-      post_logs_retry_limit: Integer,
-      post_logs_retry_backoff: T.any(Method, Proc, Integer, NilClass),
-      user_persistent_storage: T.any(Statsig::Interfaces::IUserPersistentStorage, NilClass)
-    ).void
-  end
   def initialize(
     environment = nil,
     api_url_base = nil,