statsig 1.25.2 → 1.27.0

data/lib/spec_store.rb

@@ -12,7 +12,7 @@ module Statsig
     attr_accessor :initial_config_sync_time
     attr_accessor :init_reason
 
-    def initialize(network, options, error_callback, diagnostics)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -27,9 +27,12 @@ module Statsig
         :configs => {},
         :layers => {},
         :id_lists => {},
-        :experiment_to_layer => {}
+        :experiment_to_layer => {},
+        :sdk_keys_to_app_ids => {}
       }
       @diagnostics = diagnostics
+      @error_boundary = error_boundary
+      @logger = logger
 
       @id_list_thread_pool = Concurrent::FixedThreadPool.new(
         options.idlist_threadpool_size,
@@ -39,18 +42,19 @@ module Statsig
       )
 
       unless @options.bootstrap_values.nil?
-        begin
-          if !@options.data_store.nil?
-            puts 'data_store gets priority over bootstrap_values. bootstrap_values will be ignored'
-          else
-            tracker = @diagnostics.track('bootstrap', 'process')
+        if !@options.data_store.nil?
+          puts 'data_store gets priority over bootstrap_values. bootstrap_values will be ignored'
+        else
+          tracker = @diagnostics.track('bootstrap', 'process')
+          begin
             if process_specs(options.bootstrap_values)
               @init_reason = EvaluationReason::BOOTSTRAP
             end
-            tracker.end(@init_reason == EvaluationReason::BOOTSTRAP)
+          rescue
+            puts 'the provided bootstrapValues is not a valid JSON string'
+          ensure
+            tracker.end(success: @init_reason == EvaluationReason::BOOTSTRAP)
           end
-        rescue
-          puts 'the provided bootstrapValues is not a valid JSON string'
         end
       end
 
@@ -70,8 +74,8 @@ module Statsig
         get_id_lists_from_network
       end
 
-      @config_sync_thread = sync_config_specs
-      @id_lists_sync_thread = sync_id_lists
+      @config_sync_thread = spawn_sync_config_specs_thread
+      @id_lists_sync_thread = spawn_sync_id_lists_thread
     end
 
     def is_ready_for_checks
@@ -119,34 +123,66 @@ module Statsig
       @specs[:id_lists][list_name]
     end
 
+    def has_sdk_key?(sdk_key)
+      @specs[:sdk_keys_to_app_ids].key?(sdk_key)
+    end
+
+    def get_app_id_for_sdk_key(sdk_key)
+      if sdk_key.nil?
+        return nil
+      end
+      return nil unless has_sdk_key?(sdk_key)
+      @specs[:sdk_keys_to_app_ids][sdk_key]
+    end
+
     def get_raw_specs
       @specs
     end
 
     def maybe_restart_background_threads
-      if @config_sync_thread.nil? or !@config_sync_thread.alive?
+      if @config_sync_thread.nil? || !@config_sync_thread.alive?
         @config_sync_thread = sync_config_specs
       end
-      if @id_lists_sync_thread.nil? or !@id_lists_sync_thread.alive?
+      if @id_lists_sync_thread.nil? || !@id_lists_sync_thread.alive?
         @id_lists_sync_thread = sync_id_lists
       end
     end
 
+    def sync_config_specs
+      @diagnostics.context = 'config_sync'
+      if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::CONFIG_SPECS_KEY)
+        load_config_specs_from_storage_adapter
+      else
+        download_config_specs
+      end
+      @logger.log_diagnostics_event(@diagnostics)
+    end
+
+    def sync_id_lists
+      @diagnostics.context = 'config_sync'
+      if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::ID_LISTS_KEY)
+        get_id_lists_from_adapter
+      else
+        get_id_lists_from_network
+      end
+      @logger.log_diagnostics_event(@diagnostics)
+    end
+
     private
 
     def load_config_specs_from_storage_adapter
       tracker = @diagnostics.track('data_store_config_specs', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::CONFIG_SPECS_KEY)
-      tracker.end(true)
+      tracker.end(success: true)
       return if cached_values.nil?
 
       tracker = @diagnostics.track('data_store_config_specs', 'process')
       process_specs(cached_values, from_adapter: true)
       @init_reason = EvaluationReason::DATA_ADAPTER
-      tracker.end(true)
+      tracker.end(success: true)
     rescue StandardError
       # Fallback to network
-      tracker.end(false)
+      tracker.end(success: false)
       download_config_specs
     end
 
@@ -157,31 +193,33 @@ module Statsig
       @options.data_store.set(Interfaces::IDataStore::CONFIG_SPECS_KEY, specs_string)
     end
 
-    def sync_config_specs
+    def spawn_sync_config_specs_thread
+      if @options.disable_rulesets_sync
+        return nil
+      end
+
       Thread.new do
-        @diagnostics = Diagnostics.new('config_sync')
-        loop do
-          sleep @options.rulesets_sync_interval
-          if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::CONFIG_SPECS_KEY)
-            load_config_specs_from_storage_adapter
-          else
-            download_config_specs
+        @error_boundary.capture(task: lambda {
+          loop do
+            sleep @options.rulesets_sync_interval
+            sync_config_specs
           end
-        end
+        })
       end
     end
 
-    def sync_id_lists
+    def spawn_sync_id_lists_thread
+      if @options.disable_idlists_sync
+        return nil
+      end
+
       Thread.new do
-        @diagnostics = Diagnostics.new('config_sync')
-        loop do
-          sleep @id_lists_sync_interval
-          if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::ID_LISTS_KEY)
-            get_id_lists_from_adapter
-          else
-            get_id_lists_from_network
+        @error_boundary.capture(task: lambda {
+          loop do
+            sleep @id_lists_sync_interval
+            sync_id_lists
           end
-        end
+        })
       end
     end
 
@@ -195,15 +233,16 @@ module Statsig
         if e.is_a? NetworkError
           code = e.http_code
         end
-        tracker.end(code)
+        tracker.end(statusCode: code, success: e.nil?, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
 
         if e.nil?
           unless response.nil?
             tracker = @diagnostics.track('download_config_specs', 'process')
+
             if process_specs(response.body.to_s)
               @init_reason = EvaluationReason::NETWORK
             end
-            tracker.end(@init_reason == EvaluationReason::NETWORK)
+            tracker.end(success: @init_reason == EvaluationReason::NETWORK)
 
             @rules_updated_callback.call(response.body.to_s, @last_config_sync_time) unless response.body.nil? or @rules_updated_callback.nil?
           end
@@ -241,6 +280,7 @@ module Statsig
       specs_json['feature_gates'].each { |gate| new_gates[gate['name']] = gate }
       specs_json['dynamic_configs'].each { |config| new_configs[config['name']] = config }
       specs_json['layer_configs'].each { |layer| new_layers[layer['name']] = layer }
+      specs_json['diagnostics']&.each { |key, value| @diagnostics.sample_rates[key] = value }
 
       if specs_json['layers'].is_a?(Hash)
         specs_json['layers'].each { |layer_name, experiments|
@@ -252,6 +292,7 @@ module Statsig
       @specs[:configs] = new_configs
       @specs[:layers] = new_layers
       @specs[:experiment_to_layer] = new_exp_to_layer
+      @specs[:sdk_keys_to_app_ids] = specs_json['sdk_keys_to_app_ids'] || {}
 
       unless from_adapter
         save_config_specs_to_storage_adapter(specs_string)
@@ -264,12 +305,12 @@ module Statsig
       cached_values = @options.data_store.get(Interfaces::IDataStore::ID_LISTS_KEY)
       return if cached_values.nil?
 
-      tracker.end(true)
+      tracker.end(success: true)
       id_lists = JSON.parse(cached_values)
       process_id_lists(id_lists, from_adapter: true)
     rescue StandardError
       # Fallback to network
-      tracker.end(false)
+      tracker.end(success: false)
       get_id_lists_from_network
     end
 
@@ -287,8 +328,9 @@ module Statsig
       if e.is_a? NetworkError
         code = e.http_code
       end
-      tracker.end(code)
-      if !e.nil? || response.nil?
+      success = e.nil? && !response.nil?
+      tracker.end(statusCode: code, success: success, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
+      if !success
         return
       end
 
@@ -311,11 +353,11 @@ module Statsig
       tracker = @diagnostics.track(
         from_adapter ? 'data_store_id_lists' : 'get_id_list_sources',
         'process',
-        new_id_lists.length
+        { idListCount: new_id_lists.length }
       )
 
       if new_id_lists.empty?
-        tracker.end
+        tracker.end(success: true)
         return
       end
 
@@ -366,17 +408,17 @@ module Statsig
       end
 
       result = Concurrent::Promise.all?(*tasks).execute.wait(@id_lists_sync_interval)
-      tracker.end(result.state == :fulfilled)
+      tracker.end(success: result.state == :fulfilled)
     end
 
     def get_single_id_list_from_adapter(list)
-      tracker = @diagnostics.track('data_store_id_list', 'fetch', nil, { url: list.url })
+      tracker = @diagnostics.track('data_store_id_list', 'fetch', { url: list.url })
       cached_values = @options.data_store.get("#{Interfaces::IDataStore::ID_LISTS_KEY}::#{list.name}")
-      tracker.end(true)
+      tracker.end(success: true)
       content = cached_values.to_s
       process_single_id_list(list, content, from_adapter: true)
     rescue StandardError
-      tracker.end(false)
+      tracker.end(success: false)
       nil
     end
 
@@ -389,10 +431,10 @@ module Statsig
     def download_single_id_list(list)
       nil unless list.is_a? IDList
       http = HTTP.headers({ 'Range' => "bytes=#{list&.size || 0}-" }).accept(:json)
+      tracker = @diagnostics.track('get_id_list', 'network_request', { url: list.url })
       begin
-        tracker = @diagnostics.track('get_id_list', 'network_request', nil, { url: list.url })
         res = http.get(list.url)
-        tracker.end(res.status.code)
+        tracker.end(statusCode: res.status.code, success: res.status.success?)
         nil unless res.status.success?
         content_length = Integer(res['content-length'])
         nil if content_length.nil? || content_length <= 0
@@ -400,6 +442,7 @@ module Statsig
         success = process_single_id_list(list, content, content_length)
         save_single_id_list_to_adapter(list.name, content) unless success.nil? || !success
       rescue
+        tracker.end(success: false)
         nil
       end
     end
@@ -407,10 +450,10 @@ module Statsig
     def process_single_id_list(list, content, content_length = nil, from_adapter: false)
       false unless list.is_a? IDList
       begin
-        tracker = @diagnostics.track(from_adapter ? 'data_store_id_list' : 'get_id_list', 'process', nil, { url: list.url })
+        tracker = @diagnostics.track(from_adapter ? 'data_store_id_list' : 'get_id_list', 'process', { url: list.url })
         unless content.is_a?(String) && (content[0] == '-' || content[0] == '+')
           @specs[:id_lists].delete(list.name)
-          tracker.end(false)
+          tracker.end(success: false)
           return false
         end
         ids_clone = list.ids # clone the list, operate on the new list, and swap out the old list, so the operation is thread-safe
@@ -432,12 +475,13 @@ module Statsig
                     else
                       list.size + content_length
                     end
-        tracker.end(true)
+        tracker.end(success: true)
         return true
       rescue
-        tracker.end(false)
+        tracker.end(success: false)
         return false
       end
     end
+
   end
 end

data/lib/statsig.rb

@@ -176,6 +176,16 @@ module Statsig
     @shared_instance&.log_event(user, event_name, value, metadata)
   end
 
+  def self.sync_rulesets
+    ensure_initialized
+    @shared_instance&.manually_sync_rulesets
+  end
+
+  def self.sync_idlists
+    ensure_initialized
+    @shared_instance&.manually_sync_idlists
+  end
+
   sig { void }
   ##
   # Stops all Statsig activity and flushes any pending events.
@@ -208,17 +218,19 @@ module Statsig
     @shared_instance&.override_config(config_name, config_value)
   end
 
-  sig { params(user: StatsigUser).returns(T.any(T::Hash[String, T.untyped], NilClass)) }
+  sig { params(user: StatsigUser, hash: String, client_sdk_key: T.any(String, NilClass)).returns(T.any(T::Hash[String, T.untyped], NilClass)) }
   ##
   # Gets all evaluated values for the given user.
   # These values can then be given to a Statsig Client SDK via bootstrapping.
   #
   # @param user A StatsigUser object used for the evaluation
+  # @param hash The type of hashing algorithm to use ('sha256', 'djb2', 'none')
+  # @param client_sdk_key A optional client sdk key to be used for the evaluation
   #
   # @note See Ruby Documentation: https://docs.statsig.com/server/rubySDK)
-  def self.get_client_initialize_response(user)
+  def self.get_client_initialize_response(user, hash: 'sha256', client_sdk_key: nil)
     ensure_initialized
-    @shared_instance&.get_client_initialize_response(user)
+    @shared_instance&.get_client_initialize_response(user, hash, client_sdk_key)
   end
 
   sig { returns(T::Hash[String, String]) }
@@ -227,7 +239,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.25.2',
+      'sdkVersion' => '1.27.0',
     }
   end
 

data/lib/statsig_driver.rb

@@ -37,13 +37,12 @@ class StatsigDriver
       @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)
+      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger)
+      tracker.end(success: true)
 
       @logger.log_diagnostics_event(@diagnostics)
-    })
-    @err_boundary.logger = @logger
+    }, caller: __method__.to_s)
   end
 
   class CheckGateOptions < T::Struct
@@ -54,32 +53,36 @@ class StatsigDriver
 
   def check_gate(user, gate_name, options = CheckGateOptions.new)
     @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, gate_name, "gate_name")
+      run_with_diagnostics(task: lambda {
+        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 = @evaluator.check_gate(user, gate_name)
+        if res.nil?
+          res = Statsig::ConfigResult.new(gate_name)
+        end
 
-      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)
+        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
-      end
 
-      res.gate_value
+        res.gate_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)
-    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)
+    @err_boundary.capture(task: lambda {
+      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)
+    })
   end
 
   class GetConfigOptions < T::Struct
@@ -90,8 +93,10 @@ class StatsigDriver
 
   def get_config(user, dynamic_config_name, options = GetConfigOptions.new)
     @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)
+      }, caller: __method__.to_s)
     }, recover: -> { DynamicConfig.new(dynamic_config_name) }, caller: __method__.to_s)
   end
 
@@ -103,17 +108,21 @@ class StatsigDriver
 
   def get_experiment(user, experiment_name, options = GetExperimentOptions.new)
     @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)
+      }, 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)
+    @err_boundary.capture(task: lambda {
+      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)
+    }, caller: __method__.to_s)
   end
 
   class GetLayerOptions < T::Struct
@@ -124,37 +133,39 @@ class StatsigDriver
 
   def get_layer(user, layer_name, options = GetLayerOptions.new)
     @err_boundary.capture(task: lambda {
-      user = verify_inputs(user, layer_name, "layer_name")
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, layer_name, "layer_name")
 
-      res = @evaluator.get_layer(user, layer_name)
-      if res.nil?
-        res = Statsig::ConfigResult.new(layer_name)
-      end
+        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)
+        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
-        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)
-    }, caller: __method__.to_s)
+
+        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)
+      }, 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)
-    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 = @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)
+    }, caller: __method__.to_s)
   end
 
   def log_event(user, event_name, value = nil, metadata = nil)
@@ -171,7 +182,19 @@ 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 shutdown
@@ -179,29 +202,30 @@ 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 override_config(config_name, config_value)
     @err_boundary.capture(task: lambda {
       @evaluator.override_config(config_name, config_value)
-    })
+    }, caller: __method__.to_s)
   end
 
   # @param [StatsigUser] user
+  # @param [String | nil] client_sdk_key
   # @return [Hash]
-  def get_client_initialize_response(user)
+  def get_client_initialize_response(user, hash, client_sdk_key)
     @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)
+    }, recover: -> { nil }, caller: __method__.to_s)
   end
 
   def maybe_restart_background_threads
@@ -212,11 +236,29 @@ class StatsigDriver
     @err_boundary.capture(task: lambda {
       @evaluator.maybe_restart_background_threads
       @logger.maybe_restart_background_threads
-    })
+    }, caller: __method__.to_s)
   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('api_call')
+      tracker = diagnostics.track(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)
+    end
+    return res
+  end
+
   sig { params(user: StatsigUser, config_name: String, variable_name: String).returns(StatsigUser) }
 
   def verify_inputs(user, config_name, variable_name)

data/lib/statsig_errors.rb

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