statsig 1.25.2 → 1.33.0

data/lib/statsig_driver.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require 'config_result'
 require 'evaluator'
 require 'network'
@@ -10,15 +8,13 @@ require 'statsig_options'
 require 'statsig_user'
 require 'spec_store'
 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-')
@@ -31,130 +27,163 @@ 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
       @net = Statsig::Network.new(secret_key, @options)
-      @logger = Statsig::StatsigLogger.new(@net, @options)
-      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @diagnostics)
-      tracker.end('success')
+      @logger = Statsig::StatsigLogger.new(@net, @options, @err_boundary)
+      @persistent_storage_utils = Statsig::UserPersistentStorageUtils.new(@options)
+      @store = Statsig::SpecStore.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger, secret_key)
+      @evaluator = Statsig::Evaluator.new(@store, @options, @persistent_storage_utils)
+      tracker.end(success: true)
 
-      @logger.log_diagnostics_event(@diagnostics)
-    })
-    @err_boundary.logger = @logger
-  end
-
-  class CheckGateOptions < T::Struct
-    prop :log_exposure, T::Boolean, default: true
+      @logger.log_diagnostics_event(@diagnostics, 'initialize')
+    }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, gate_name: String, options: CheckGateOptions).returns(T::Boolean) }
-
-  def check_gate(user, gate_name, options = CheckGateOptions.new)
-    @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, gate_name, "gate_name")
+  def get_gate_impl(
+    user,
+    gate_name,
+    disable_log_exposure: false,
+    skip_evaluation: false,
+    disable_evaluation_details: false,
+    ignore_local_overrides: 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.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, ignore_local_overrides: ignore_local_overrides)
 
-      if res == $fetch_from_server
-        res = check_gate_fallback(user, gate_name)
-        # exposure logged by the server
-      else
-        if options.log_exposure
-          @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
-        end
-      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
 
-      res.gate_value
+  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 == 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).void }
-
-  def manually_log_gate_exposure(user, gate_name)
-    res = @evaluator.check_gate(user, gate_name)
-    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)
+  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 == true,
+          disable_evaluation_details: options&.disable_evaluation_details == true,
+          ignore_local_overrides: options&.ignore_local_overrides == true
+        ).value
+      }, caller: __method__.to_s)
+    }, recover: -> { false }, caller: __method__.to_s)
   end
 
-  class GetConfigOptions < T::Struct
-    prop :log_exposure, T::Boolean, default: true
+  def manually_log_gate_exposure(user, gate_name)
+    @err_boundary.capture(task: lambda {
+      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: GetConfigOptions).returns(DynamicConfig) }
-
-  def get_config(user, dynamic_config_name, options = GetConfigOptions.new)
+  def get_config(user, dynamic_config_name, options = nil)
     @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
-      get_config_impl(user, dynamic_config_name, options)
+      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 == true,
+          disable_evaluation_details: options&.disable_evaluation_details == true,
+          ignore_local_overrides: options&.ignore_local_overrides == true
+        )
+      }, caller: __method__.to_s)
     }, recover: -> { DynamicConfig.new(dynamic_config_name) }, caller: __method__.to_s)
   end
 
-  class GetExperimentOptions < T::Struct
-    prop :log_exposure, T::Boolean, default: true
-  end
-
-  sig { params(user: StatsigUser, experiment_name: String, options: GetExperimentOptions).returns(DynamicConfig) }
-
-  def get_experiment(user, experiment_name, options = GetExperimentOptions.new)
+  def get_experiment(user, experiment_name, options = nil)
     @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, experiment_name, "experiment_name")
-      get_config_impl(user, experiment_name, options)
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, experiment_name, "experiment_name")
+        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,
+          ignore_local_overrides: options&.ignore_local_overrides == 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)
-    res = @evaluator.get_config(user, config_name)
-    context = {'is_manual_exposure' => true}
-    @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
-  end
+    @err_boundary.capture(task: lambda {
+      res = Statsig::ConfigResult.new(name: config_name)
+      @evaluator.get_config(user, config_name, res)
 
-  class GetLayerOptions < T::Struct
-    prop :log_exposure, T::Boolean, default: true
+      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, layer_name: String, options: GetLayerOptions).returns(Layer) }
-
-  def get_layer(user, layer_name, options = GetLayerOptions.new)
+  def get_user_persisted_values(user, id_type)
     @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, layer_name, "layer_name")
+      persisted_values = @persistent_storage_utils.get_user_persisted_values(user, id_type)
+      return {} if persisted_values.nil?
 
-      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.empty?
-          return Layer.new(layer_name)
-        end
-        res = get_config_fallback(user, res.config_delegate)
-        # exposure logged by the server
-      end
-      
-      exposure_log_func = options.log_exposure ? lambda { |layer, parameter_name|
-        @logger.log_layer_exposure(user, layer, parameter_name, res)
-      } : nil
-      Layer.new(res.name, res.json_value, res.rule_id, exposure_log_func)
-    }, recover: lambda {
-      Layer.new(layer_name)
+      persisted_values
     }, caller: __method__.to_s)
   end
 
-  sig { params(user: StatsigUser, layer_name: String, parameter_name: String).void }
+  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)
+
+        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
 
   def manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
-    res = @evaluator.get_layer(user, layer_name)
-    layer = Layer.new(layer_name, res.json_value, res.rule_id)
-    context = {'is_manual_exposure' => true}
-    @logger.log_layer_exposure(user, layer, parameter_name, res, context)
+    @err_boundary.capture(task: lambda {
+      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 }
+      @logger.log_layer_exposure(user, layer, parameter_name, res, context)
+    }, caller: __method__.to_s)
   end
 
   def log_event(user, event_name, value = nil, metadata = nil)
@@ -171,7 +200,49 @@ class StatsigDriver
       event.value = value
       event.metadata = metadata
       @logger.log_event(event)
-    })
+    }, caller: __method__.to_s)
+  end
+
+  def manually_sync_rulesets
+    @err_boundary.capture(task: lambda {
+      @evaluator.spec_store.sync_config_specs
+    }, caller: __method__.to_s)
+  end
+
+  def manually_sync_idlists
+    @err_boundary.capture(task: lambda {
+      @evaluator.spec_store.sync_id_lists
+    }, caller: __method__.to_s)
+  end
+
+  def list_gates
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_gates
+    }, caller: __method__.to_s)
+  end
+
+  def list_configs
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_configs
+    }, caller: __method__.to_s)
+  end
+
+  def list_experiments
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_experiments
+    }, caller: __method__.to_s)
+  end
+
+  def list_autotunes
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_autotunes
+    }, caller: __method__.to_s)
+  end
+
+  def list_layers
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_layers
+    }, caller: __method__.to_s)
   end
 
   def shutdown
@@ -179,29 +250,55 @@ class StatsigDriver
       @shutdown = true
       @logger.shutdown
       @evaluator.shutdown
-    })
+    }, caller: __method__.to_s)
   end
 
   def override_gate(gate_name, gate_value)
     @err_boundary.capture(task: lambda {
       @evaluator.override_gate(gate_name, gate_value)
-    })
+    }, caller: __method__.to_s)
+  end
+
+  def remove_gate_override(gate_name)
+    @err_boundary.capture(task: lambda {
+      @evaluator.remove_gate_override(gate_name)
+    }, caller: __method__.to_s)
+  end
+
+  def clear_gate_overrides
+    @err_boundary.capture(task: lambda {
+      @evaluator.clear_gate_overrides
+    }, caller: __method__.to_s)
   end
 
   def override_config(config_name, config_value)
     @err_boundary.capture(task: lambda {
       @evaluator.override_config(config_name, config_value)
-    })
+    }, caller: __method__.to_s)
+  end
+
+  def remove_config_override(config_name)
+    @err_boundary.capture(task: lambda {
+      @evaluator.remove_config_override(config_name)
+    }, caller: __method__.to_s)
+  end
+
+  def clear_config_overrides
+    @err_boundary.capture(task: lambda {
+      @evaluator.clear_config_overrides
+    }, caller: __method__.to_s)
   end
 
   # @param [StatsigUser] user
+  # @param [String | nil] client_sdk_key
+  # @param [Boolean] include_local_overrides
   # @return [Hash]
-  def get_client_initialize_response(user)
+  def get_client_initialize_response(user, hash, client_sdk_key, include_local_overrides)
     @err_boundary.capture(task: lambda {
       validate_user(user)
       normalize_user(user)
-      @evaluator.get_client_initialize_response(user)
-    }, recover: -> { nil })
+      @evaluator.get_client_initialize_response(user, hash, client_sdk_key, include_local_overrides)
+    }, recover: -> { nil }, caller: __method__.to_s)
   end
 
   def maybe_restart_background_threads
@@ -212,12 +309,28 @@ class StatsigDriver
     @err_boundary.capture(task: lambda {
       @evaluator.maybe_restart_background_threads
       @logger.maybe_restart_background_threads
-    })
+    }, caller: __method__.to_s)
   end
 
   private
 
-  sig { params(user: StatsigUser, config_name: String, variable_name: String).returns(StatsigUser) }
+  def run_with_diagnostics(task:, caller:)
+    diagnostics = nil
+    if Statsig::Diagnostics::API_CALL_KEYS.include?(caller) && Statsig::Diagnostics.sample(1)
+      diagnostics = Statsig::Diagnostics.new()
+      tracker = diagnostics.track('api_call', caller)
+    end
+    begin
+      res = task.call
+      tracker&.end(success: true)
+    rescue StandardError => e
+      tracker&.end(success: false)
+      raise e
+    ensure
+      @logger.log_diagnostics_event(diagnostics, 'api_call')
+    end
+    return res
+  end
 
   def verify_inputs(user, config_name, variable_name)
     validate_user(user)
@@ -230,22 +343,19 @@ class StatsigDriver
     normalize_user(user)
   end
 
-  def get_config_impl(user, config_name, options)
-    res = @evaluator.get_config(user, config_name)
-    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, ignore_local_overrides: 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, ignore_local_overrides: ignore_local_overrides)
 
-    if res == $fetch_from_server
-      res = get_config_fallback(user, config_name)
-      # exposure logged by the server
-    else
-      if options.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)
+    DynamicConfig.new(res.name, res.json_value, res.rule_id, res.group_name, res.id_type, res.evaluation_details)
   end
 
   def validate_user(user)
@@ -261,7 +371,7 @@ class StatsigDriver
   end
 
   def normalize_user(user)
-    if !@options&.environment.nil?
+    if user.statsig_environment.nil? && !@options&.environment.nil?
       user.statsig_environment = @options.environment
     end
     user
@@ -272,34 +382,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,3 +1,4 @@
+
 module Statsig
   class UninitializedError < StandardError
     def initialize(msg="Must call initialize first.")
@@ -8,4 +9,10 @@ module Statsig
   class ValueError < StandardError
 
   end
+
+  class InvalidSDKKeyResponse < StandardError
+    def initialize(msg="Incorrect SDK Key used to generate response.")
+      super
+    end
+  end
 end

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