statsig 1.33.2 → 1.33.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7496f0ffb0bb7a06d8377193b93659d31fd2b1f1df55eb81ad061e2e0ef42167
-  data.tar.gz: 2a0b10e6e7e18a11df14667858957abfead96833ee7a9ca7b7470f22426f3160
+  metadata.gz: 6b2947b68bfada4686360dc5aab60a460129a3ca5e4c63d6f2107af68788d2a8
+  data.tar.gz: 98e56828d1f31ec18afc0a2f46dbcab90c2a976dc95ef1db9ead5060b240952f
 SHA512:
-  metadata.gz: 9bf0bdc595846b6a531d83984e2d75e0649ec6485fe971c3bbb3bc496d9ca6950d227756e88be75f0b33331d0b503248a02dec8fa72c3e398b39eb735d1e4bb2
-  data.tar.gz: 82f6ee222688547e1d264d337e7bc532ab7ac5801d112c5ecf36f0755ecd3b82e07fd57b71e50c5df0f672899fbab2f3c18e868abf0c4fe80924e7ccabfcee33
+  metadata.gz: e1f11434fb5ec030500429cdfd11146fe845568498cded4917e1f412ca50a86beb03f937febcaeceaf8523dacaa550b9024384dc58b0b3c9b2619d37041e0df0
+  data.tar.gz: d64fd8980ca648626ecdcd0095d4964aa531d24d7acaa7c07dd70013a32d0f7c5c548602e9578044c0567c0c2ac948f5dd8bd499c2178323b0ae176d0925a82c

data/lib/api_config.rb

@@ -87,39 +87,54 @@ module Statsig
 
   class APICondition
 
-    attr_accessor :type, :target_value, :operator, :field, :additional_values, :id_type
-
+    attr_accessor :type, :target_value, :operator, :field, :additional_values, :id_type, :hash
     def self.from_json(json)
-      operator = json[:operator]
-      unless operator.nil?
-        operator = operator&.downcase&.to_sym
-        unless Const::SUPPORTED_OPERATORS.include?(operator)
-          raise UnsupportedConfigException
+      hash = Statsig::HashUtils.md5(json.to_s).to_sym
+      return Statsig::Memo.for_global(:api_condition_from_json, hash) do
+        operator = json[:operator]
+        unless operator.nil?
+          operator = operator&.downcase&.to_sym
+          unless Const::SUPPORTED_OPERATORS.include?(operator)
+            raise UnsupportedConfigException
+          end
         end
-      end
 
-      type = json[:type]
-      unless type.nil?
-        type = type&.downcase&.to_sym
-        unless Const::SUPPORTED_CONDITION_TYPES.include?(type)
-          raise UnsupportedConfigException
+        type = json[:type]
+        unless type.nil?
+          type = type&.downcase&.to_sym
+          unless Const::SUPPORTED_CONDITION_TYPES.include?(type)
+            raise UnsupportedConfigException
+          end
         end
-      end
 
-      new(
-        type: json[:type],
-        target_value: json[:targetValue],
-        operator: json[:operator],
-        field: json[:field],
-        additional_values: json[:additionalValues],
-        id_type: json[:idType]
-      )
+        new(
+          type: json[:type],
+          target_value: json[:targetValue],
+          operator: json[:operator],
+          field: json[:field],
+          additional_values: json[:additionalValues],
+          id_type: json[:idType],
+          hash: hash
+        )
+      end
     end
 
     private
 
-    def initialize(type:, target_value:, operator:, field:, additional_values:, id_type:)
+    def initialize(type:, target_value:, operator:, field:, additional_values:, id_type:, hash:)
+      @hash = hash
+      
       @type = type.to_sym unless type.nil?
+      if operator == "any_case_sensitive" || operator == "none_case_sensitive"
+        if target_value.is_a?(Array)
+            target_value = target_value.map { |item| [item.to_s, true] }.to_h
+        end
+      end
+      if operator == "any" || operator == "none"
+        if target_value.is_a?(Array)
+            target_value = target_value.map { |item| [item.to_s.downcase, true] }.to_h
+        end
+      end
       @target_value = target_value
       @operator = operator.to_sym unless operator.nil?
       @field = field

data/lib/client_initialize_helpers.rb

@@ -25,6 +25,7 @@ module Statsig
     end
 
     def self.to_response(config_name, config_spec, evaluator, user, client_sdk_key, hash_algo, include_exposures, include_local_overrides)
+    
       target_app_id = evaluator.spec_store.get_app_id_for_sdk_key(client_sdk_key)
       config_target_apps = config_spec.target_app_ids
 

data/lib/diagnostics.rb

@@ -58,7 +58,12 @@ module Statsig
       rand * 10_000 < rate_over_ten_thousand
     end
 
-    API_CALL_KEYS = %w[check_gate get_config get_experiment get_layer].freeze
+    API_CALL_KEYS = {
+      :check_gate => true,
+      :get_config => true,
+      :get_experiment => true,
+      :get_layer => true
+    }.freeze
 
     class Tracker
       def initialize(diagnostics, context, key, step, tags = {})

data/lib/error_boundary.rb

@@ -10,9 +10,9 @@ module Statsig
       @seen = Set.new
     end
 
-    def capture(task:, recover: -> {}, caller: nil)
+    def capture(recover: -> {}, caller: nil)
       begin
-        res = task.call
+        res = yield
       rescue StandardError, SystemStackError => e
         if e.is_a?(Statsig::UninitializedError) || e.is_a?(Statsig::ValueError)
           raise e
@@ -20,7 +20,7 @@ module Statsig
 
         puts '[Statsig]: An unexpected exception occurred.'
         puts e.message
-        log_exception(e, tag: caller)
+        log_exception(e, tag: caller&.to_s)
         res = recover.call
       end
       return res

data/lib/evaluation_helpers.rb

@@ -10,7 +10,6 @@ module EvaluationHelpers
   def self.match_string_in_array(array, value, ignore_case, func)
     str_value = value.to_s
     str_value_downcased = nil
-
     return false if array.nil?
 
     return array.any? do |item|
@@ -26,22 +25,15 @@ module EvaluationHelpers
   end
 
   def self.equal_string_in_array(array, value, ignore_case)
-    str_value = value.to_s
-    str_value_downcased = nil
-
     return false if array.nil?
 
-    return array.any? do |item|
-      next false if item.nil?
-      item_str = item.to_s
-
-      next false unless item_str.length == str_value.length
-
-      return true if item_str == str_value
-      next false unless ignore_case
+    str_value = value.to_s
+    str_value_downcased = nil
 
-      str_value_downcased ||= str_value.downcase
-      item_str.downcase == str_value_downcased
+    if ignore_case
+      return array.has_key?(value.to_s.downcase)
+    else
+      return array.has_key?(value.to_s)
     end
   end
 

data/lib/evaluator.rb

@@ -209,8 +209,8 @@ module Statsig
 
       if user.custom_ids.nil? == false
         evaluated_keys[:customIDs] = user.custom_ids
-      end
-
+      end 
+    
       {
         feature_gates: Statsig::ResponseFormatter
                          .get_responses(@spec_store.gates, self, user, client_sdk_key, hash_algo, include_local_overrides: include_local_overrides),
@@ -331,8 +331,19 @@ module Statsig
     def eval_rule(user, rule, end_result)
       pass = true
       i = 0
+
+      memo = user.get_memo
       until i >= rule.conditions.length
-        result = eval_condition(user, rule.conditions[i], end_result)
+
+        condition = rule.conditions[i]
+
+        if condition.type == :fail_gate || condition.type == :pass_gate
+          result = eval_condition(user, condition, end_result)
+        else
+          result = Memo.for(memo, :eval_rule, condition.hash) do
+            eval_condition(user, condition, end_result)
+          end
+        end
 
         pass = false if result != true
         i += 1
@@ -370,7 +381,6 @@ module Statsig
         return true
       when :fail_gate, :pass_gate
         check_gate(user, target, end_result)
-
         gate_value = end_result.gate_value
 
         unless end_result.disable_exposures
@@ -527,8 +537,7 @@ module Statsig
     def get_value_from_user(user, field)
       return nil unless field.is_a?(String)
 
-      value = get_value_from_user_field(user, field)
-      value ||= get_value_from_user_field(user, field.downcase)
+      value = get_value_from_user_field(user, field.downcase)
 
       if value.nil?
         value = user.custom[field] if user.custom.is_a?(Hash)
@@ -584,8 +593,8 @@ module Statsig
       return nil unless field.is_a?(String)
 
       ua = get_value_from_user(user, Const::USER_AGENT)
-      return nil unless ua.is_a?(String)
 
+      return nil unless ua.is_a?(String)
       case field.downcase
       when Const::OSNAME, Const::OS_NAME
         os = UAParser.parse_os(ua)

data/lib/hash_utils.rb

@@ -19,6 +19,10 @@ module Statsig
       return Digest::SHA256.base64digest(input_str)
     end
 
+    def self.md5(input_str)
+      return Digest::MD5.base64digest(input_str)
+    end
+
     def self.sortHash(input_hash)
       dictionary = input_hash.clone.sort_by { |key| key }.to_h;
       input_hash.each do |key, value|

data/lib/memo.rb

@@ -0,0 +1,23 @@
+module Statsig
+  class Memo  
+
+    @global_memo = {}
+
+    def self.for(hash, method, key)
+      method_hash = hash[method]
+      unless method_hash
+        method_hash = hash[method] = {}
+      end
+    
+      return method_hash[key] if method_hash.key?(key)
+    
+      method_hash[key] = yield
+    end
+  
+    def self.for_global(method, key)
+      return self.for(@global_memo, method, key) do
+        yield
+      end
+    end
+  end
+end

data/lib/spec_store.rb

@@ -218,12 +218,12 @@ module Statsig
       end
 
       Thread.new do
-        @error_boundary.capture(task: lambda {
+        @error_boundary.capture() do
           loop do
             sleep @options.rulesets_sync_interval
             sync_config_specs
           end
-        })
+        end
       end
     end
 
@@ -233,12 +233,12 @@ module Statsig
       end
 
       Thread.new do
-        @error_boundary.capture(task: lambda {
+        @error_boundary.capture() do
           loop do
             sleep @id_lists_sync_interval
             sync_id_lists
           end
-        })
+        end
       end
     end
 

data/lib/statsig.rb

@@ -331,6 +331,13 @@ module Statsig
     @shared_instance&.clear_config_overrides
   end
 
+  ##
+  # @param [HashTable] debug information log with exposure events
+  def self.set_debug_info(debug_info)
+    ensure_initialized
+    @shared_instance&.set_debug_info(debug_info)
+  end
+
   ##
   # Gets all evaluated values for the given user.
   # These values can then be given to a Statsig Client SDK via bootstrapping.
@@ -356,7 +363,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.33.2',
+      'sdkVersion' => '1.33.4',
       'languageVersion' => RUBY_VERSION
     }
   end

data/lib/statsig_driver.rb

@@ -11,7 +11,7 @@ require 'dynamic_config'
 require 'feature_gate'
 require 'error_boundary'
 require 'layer'
-
+require 'memo'
 require 'diagnostics'
 
 class StatsigDriver
@@ -26,7 +26,7 @@ class StatsigDriver
     end
 
     @err_boundary = Statsig::ErrorBoundary.new(secret_key)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @diagnostics = Statsig::Diagnostics.new()
       tracker = @diagnostics.track('initialize', 'overall')
       @options = options || StatsigOptions.new
@@ -40,7 +40,7 @@ class StatsigDriver
       tracker.end(success: true)
 
       @logger.log_diagnostics_event(@diagnostics, 'initialize')
-    }, caller: __method__.to_s)
+    end
   end
 
   def get_gate_impl(
@@ -56,34 +56,38 @@ class StatsigDriver
       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')
+    return Statsig::Memo.for(user.get_memo(), :get_gate_impl, gate_name) do
 
-    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)
+      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)
 
-    unless disable_log_exposure
+      unless disable_log_exposure
       @logger.log_gate_exposure(
-        user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
-      )
+          user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
+        )
+      end
+      FeatureGate.from_config_result(res)
     end
-    FeatureGate.from_config_result(res)
   end
 
+
   def get_gate(user, gate_name, options = nil)
-    @err_boundary.capture(task: lambda {
-      run_with_diagnostics(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> {false}) do
+      run_with_diagnostics(caller: :get_gate) do
         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
+    end
   end
 
   def check_gate(user, gate_name, options = nil)
-    @err_boundary.capture(task: lambda {
-      run_with_diagnostics(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> {false}) do
+      run_with_diagnostics(caller: :check_gate) do 
         get_gate_impl(
           user,
           gate_name,
@@ -91,22 +95,22 @@ class StatsigDriver
           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
+    end
   end
 
   def manually_log_gate_exposure(user, gate_name)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       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
   end
 
   def get_config(user, dynamic_config_name, options = nil)
-    @err_boundary.capture(task: lambda {
-      run_with_diagnostics(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> { DynamicConfig.new(dynamic_config_name) }) do
+      run_with_diagnostics(caller: :get_config) do
         user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
         get_config_impl(
           user,
@@ -115,13 +119,13 @@ class StatsigDriver
           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
+    end
   end
 
   def get_experiment(user, experiment_name, options = nil)
-    @err_boundary.capture(task: lambda {
-      run_with_diagnostics(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> { DynamicConfig.new(experiment_name) }) do
+      run_with_diagnostics(caller: :get_experiment) do
         user = verify_inputs(user, experiment_name, "experiment_name")
         get_config_impl(
           user,
@@ -131,63 +135,65 @@ class StatsigDriver
           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
+    end
   end
 
   def manually_log_config_exposure(user, config_name)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       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
   end
 
   def get_user_persisted_values(user, id_type)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__,) do
       persisted_values = @persistent_storage_utils.get_user_persisted_values(user, id_type)
       return {} if persisted_values.nil?
 
       persisted_values
-    }, caller: __method__.to_s)
+    end
   end
 
   def get_layer(user, layer_name, options = nil)
-    @err_boundary.capture(task: lambda {
-      run_with_diagnostics(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> { Layer.new(layer_name) }) do
+      run_with_diagnostics(caller: :get_layer) do
         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)
+        Statsig::Memo.for(user.get_memo(), :get_layer, layer_name) do
+          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)
+        end
+      end
+    end
   end
 
   def manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       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
   end
 
   def log_event(user, event_name, value = nil, metadata = nil)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       if !user.nil? && !user.instance_of?(StatsigUser)
         raise Statsig::ValueError.new('Must provide a valid StatsigUser or nil')
       end
@@ -200,93 +206,99 @@ class StatsigDriver
       event.value = value
       event.metadata = metadata
       @logger.log_event(event)
-    }, caller: __method__.to_s)
+    end
   end
 
   def manually_sync_rulesets
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.spec_store.sync_config_specs
-    }, caller: __method__.to_s)
+    end
   end
 
   def manually_sync_idlists
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.spec_store.sync_id_lists
-    }, caller: __method__.to_s)
+    end
   end
 
   def list_gates
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.list_gates
-    }, caller: __method__.to_s)
+    end
   end
 
   def list_configs
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.list_configs
-    }, caller: __method__.to_s)
+    end
   end
 
   def list_experiments
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.list_experiments
-    }, caller: __method__.to_s)
+    end
   end
 
   def list_autotunes
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.list_autotunes
-    }, caller: __method__.to_s)
+    end
   end
 
   def list_layers
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.list_layers
-    }, caller: __method__.to_s)
+    end
   end
 
   def shutdown
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @shutdown = true
       @logger.shutdown
       @evaluator.shutdown
-    }, caller: __method__.to_s)
+    end
   end
 
   def override_gate(gate_name, gate_value)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.override_gate(gate_name, gate_value)
-    }, caller: __method__.to_s)
+    end
   end
 
   def remove_gate_override(gate_name)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.remove_gate_override(gate_name)
-    }, caller: __method__.to_s)
+    end
   end
 
   def clear_gate_overrides
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.clear_gate_overrides
-    }, caller: __method__.to_s)
+    end
   end
 
   def override_config(config_name, config_value)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.override_config(config_name, config_value)
-    }, caller: __method__.to_s)
+    end
   end
 
   def remove_config_override(config_name)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.remove_config_override(config_name)
-    }, caller: __method__.to_s)
+    end
   end
 
   def clear_config_overrides
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.clear_config_overrides
-    }, caller: __method__.to_s)
+    end
+  end
+
+  def set_debug_info(debug_info)
+    @err_boundary.capture(caller: __method__) do
+      @logger.set_debug_info(debug_info)
+    end
   end
 
   # @param [StatsigUser] user
@@ -294,11 +306,11 @@ class StatsigDriver
   # @param [Boolean] include_local_overrides
   # @return [Hash]
   def get_client_initialize_response(user, hash, client_sdk_key, include_local_overrides)
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__, recover: -> { nil }) do
       validate_user(user)
       normalize_user(user)
       @evaluator.get_client_initialize_response(user, hash, client_sdk_key, include_local_overrides)
-    }, recover: -> { nil }, caller: __method__.to_s)
+    end
   end
 
   def maybe_restart_background_threads
@@ -306,22 +318,24 @@ class StatsigDriver
       return
     end
 
-    @err_boundary.capture(task: lambda {
+    @err_boundary.capture(caller: __method__) do
       @evaluator.maybe_restart_background_threads
       @logger.maybe_restart_background_threads
-    }, caller: __method__.to_s)
+    end
   end
 
   private
 
-  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)
+  def run_with_diagnostics(caller:)
+    if !Statsig::Diagnostics::API_CALL_KEYS[caller] || !Statsig::Diagnostics.sample(1)
+      return yield
     end
+
+    diagnostics = Statsig::Diagnostics.new()
+    tracker = diagnostics.track('api_call', caller.to_s)
+
     begin
-      res = task.call
+      res = yield
       tracker&.end(success: true)
     rescue StandardError => e
       tracker&.end(success: false)
@@ -334,28 +348,35 @@ class StatsigDriver
 
   def verify_inputs(user, config_name, variable_name)
     validate_user(user)
+    user = Statsig::Memo.for(user.get_memo(), :verify_inputs, 0) do
+      user = normalize_user(user)
+      check_shutdown
+      maybe_restart_background_threads
+      user
+    end
+
     if !config_name.is_a?(String) || config_name.empty?
       raise Statsig::ValueError.new("Invalid #{variable_name} provided")
     end
 
-    check_shutdown
-    maybe_restart_background_threads
-    normalize_user(user)
+    user
   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)
+    return Statsig::Memo.for(user.get_memo(), :get_config_impl, config_name) do
+      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)
 
-    unless 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)
+      DynamicConfig.new(res.name, res.json_value, res.rule_id, res.group_name, res.id_type, res.evaluation_details)
+    end
   end
 
   def validate_user(user)

data/lib/statsig_event.rb

@@ -15,7 +15,9 @@ class StatsigEvent
 
   def user=(value)
     if value.is_a?(StatsigUser)
-      @user = value.serialize(true)
+      @user = Statsig::Memo.for(value.get_memo(), :serialize, 0) do
+        value.serialize(true)
+      end
     end
   end
 

data/lib/statsig_logger.rb

@@ -28,6 +28,7 @@ module Statsig
       @deduper = Concurrent::Set.new()
       @interval = 0
       @flush_mutex = Mutex.new
+      @debug_info = nil
     end
 
     def log_event(event)
@@ -45,6 +46,9 @@ module Statsig
         gateValue: value.to_s,
         ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
+      if @debug_info != nil
+        metadata[:debugInfo] = @debug_info
+      end
       return false if not is_unique_exposure(user, $gate_exposure_event, metadata)
       event.metadata = metadata
 
@@ -62,6 +66,9 @@ module Statsig
         config: config_name,
         ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
+      if @debug_info != nil
+        metadata[:debugInfo] = @debug_info
+      end
       return false if not is_unique_exposure(user, $config_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
@@ -89,6 +96,9 @@ module Statsig
         parameterName: parameter_name,
         isExplicitParameter: String(is_explicit)
       }
+      if @debug_info != nil
+        metadata[:debugInfo] = @debug_info
+      end
       return false unless is_unique_exposure(user, $layer_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
@@ -117,14 +127,14 @@ module Statsig
 
     def periodic_flush
       Thread.new do
-        @error_boundary.capture(task: lambda {
+        @error_boundary.capture() do
           loop do
             sleep @options.logging_interval_seconds
             flush_async
             @interval += 1
             @deduper.clear if @interval % 2 == 0
           end
-        })
+        end
       end
     end
 
@@ -160,6 +170,10 @@ module Statsig
       end
     end
 
+    def set_debug_info(debug_info)
+      @debug_info = debug_info
+    end
+
     private
 
     def safe_add_eval_details(eval_details, event)
@@ -186,21 +200,15 @@ module Statsig
     def is_unique_exposure(user, event_name, metadata)
       return true if user.nil?
       @deduper.clear if @deduper.size > 10000
-      custom_id_key = ''
-      if user.custom_ids.is_a?(Hash)
-        custom_id_key = user.custom_ids.values.join(',')
-      end
+
+      user_key = user.user_key
 
       metadata_key = ''
       if metadata.is_a?(Hash)
         metadata_key = metadata.reject { |key, _| $ignored_metadata_keys.include?(key) }.values.join(',')
       end
-
-      user_id_key = ''
-      unless user.user_id.nil?
-        user_id_key = user.user_id
-      end
-      key = [user_id_key, custom_id_key, event_name, metadata_key].join(',')
+     
+      key = [user_key, event_name, metadata_key].join(',')
 
       return false if @deduper.include?(key)
       @deduper.add(key)

data/lib/statsig_user.rb

@@ -1,39 +1,78 @@
 require 'json'
 require 'constants'
-
 ##
 #  The user object to be evaluated against your Statsig configurations (gates/experiments/dynamic configs).
 class StatsigUser
 
   # An identifier for this user. Evaluated against the User ID criteria. (https://docs.statsig.com/feature-gates/conditions#userid)
-  attr_accessor :user_id
+  attr_reader :user_id
+  def user_id=(value)
+    value_changed()
+    @user_id = value
+  end
 
   # An identifier for this user. Evaluated against the Email criteria. (https://docs.statsig.com/feature-gates/conditions#email)
-  attr_accessor :email
+  attr_reader :email
+  def email=(value)
+    value_changed()
+    @email = value
+  end
 
   # An IP address associated with this user. Evaluated against the IP Address criteria. (https://docs.statsig.com/feature-gates/conditions#ip)
-  attr_accessor :ip
+  attr_reader :ip
+  def ip=(value)
+    value_changed()
+    @ip = value
+  end
 
   # A user agent string associated with this user. Evaluated against Browser Version and Name (https://docs.statsig.com/feature-gates/conditions#browser-version)
-  attr_accessor :user_agent
+  attr_reader :user_agent
+  def user_agent=(value)
+    value_changed()
+    @user_agent = value
+  end
 
   # The country code associated with this user (e.g New Zealand => NZ). Evaluated against the Country criteria. (https://docs.statsig.com/feature-gates/conditions#country)
-  attr_accessor :country
+  attr_reader :country
+  def country=(value)
+    value_changed()
+    @country = value
+  end
 
   # An locale for this user.
-  attr_accessor :locale
+  attr_reader :locale
+  def locale=(value)
+    value_changed()
+    @locale = value
+  end
 
   # The current app version the user is interacting with. Evaluated against the App Version criteria. (https://docs.statsig.com/feature-gates/conditions#app-version)
-  attr_accessor :app_version
+  attr_reader :app_version
+  def app_version=(value)
+    value_changed()
+    @app_version = value
+  end
 
   # A Hash you can use to set environment variables that apply to this user. e.g. { "tier" => "development" }
-  attr_accessor :statsig_environment
+  attr_reader :statsig_environment
+  def statsig_environment=(value)
+    value_changed()
+    @statsig_environment = value
+  end
 
   # Any Custom IDs to associated with the user. (See https://docs.statsig.com/guides/experiment-on-custom-id-types)
-  attr_accessor :custom_ids
+  attr_reader :custom_ids
+  def custom_ids=(value)
+    value_changed()
+    @custom_ids = value
+  end
 
   # Any value you wish to use in evaluation, but do not want logged with events, can be stored in this field.
-  attr_accessor :private_attributes
+  attr_reader :private_attributes
+  def private_attributes=(value)
+    value_changed()
+    @private_attributes = value
+  end
 
   def custom
     @custom
@@ -41,9 +80,12 @@ class StatsigUser
 
   # Any custom fields for this user. Evaluated against the Custom criteria. (https://docs.statsig.com/feature-gates/conditions#custom)
   def custom=(value)
+    value_changed()
     @custom = value.is_a?(Hash) ? value : Hash.new
   end
 
+  attr_accessor :memo_timeout
+
   def initialize(user_hash)
     the_hash = user_hash
     begin
@@ -63,6 +105,9 @@ class StatsigUser
     @private_attributes = from_hash(the_hash, [:private_attributes, :privateAttributes], Hash)
     @custom_ids = from_hash(the_hash, [:custom_ids, :customIDs], Hash)
     @statsig_environment = from_hash(the_hash, [:statsig_environment, :statsigEnvironment], Hash)
+    @memo = {}
+    @dirty = true
+    @memo_timeout = 2
   end
 
   def serialize(for_logging)
@@ -138,7 +183,45 @@ class StatsigUser
     @user_id
   end
 
+  def get_memo
+    current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  
+    if @dirty || current_time - (@memo_access_time ||= current_time) > @memo_timeout
+      if @memo.size() > 0
+        @memo.clear
+      end
+      @dirty = false
+      @memo_access_time = current_time
+    end
+  
+    @memo
+  end
+
+  def clear_memo
+    @memo.clear
+    @dirty = false
+    @memo_access_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def user_key
+    unless !@dirty && defined? @_user_key
+      custom_id_key = ''
+      if self.custom_ids.is_a?(Hash)
+        custom_id_key = self.custom_ids.values.join(',')
+      end
+      user_id_key = ''
+      unless self.user_id.nil?
+        user_id_key = self.user_id.to_s
+      end
+      @_user_key = user_id_key + ',' + custom_id_key.to_s
+    end
+    @_user_key
+  end
+
   private
+  def value_changed
+    @dirty = true
+  end 
 
   # Pulls fields from the user hash via Symbols and Strings
   def from_hash(user_hash, keys, type)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.33.2
+  version: 1.33.4
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-05 00:00:00.000000000 Z
+date: 2024-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -310,6 +310,7 @@ files:
 - lib/interfaces/data_store.rb
 - lib/interfaces/user_persistent_storage.rb
 - lib/layer.rb
+- lib/memo.rb
 - lib/network.rb
 - lib/spec_store.rb
 - lib/statsig.rb