statsig 1.25.1 → 1.26.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, init_diagnostics = nil)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -27,8 +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,
@@ -38,37 +42,36 @@ 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
-            init_diagnostics&.mark("bootstrap", "start", "load")
+        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
-            init_diagnostics&.mark("bootstrap", "end", "load", @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
 
       unless @options.data_store.nil?
-        init_diagnostics&.mark("data_store", "start", "load")
         @options.data_store.init
-        load_config_specs_from_storage_adapter(init_diagnostics: init_diagnostics)
-        init_diagnostics&.mark("data_store", "end", "load", @init_reason == EvaluationReason::DATA_ADAPTER)
+        load_config_specs_from_storage_adapter
       end
 
       if @init_reason == EvaluationReason::UNINITIALIZED
-        download_config_specs(init_diagnostics)
+        download_config_specs
       end
 
       @initial_config_sync_time = @last_config_sync_time == 0 ? -1 : @last_config_sync_time
       if !@options.data_store.nil?
-        get_id_lists_from_adapter(init_diagnostics)
+        get_id_lists_from_adapter
       else
-        get_id_lists_from_network(init_diagnostics)
+        get_id_lists_from_network
       end
 
       @config_sync_thread = sync_config_specs
@@ -120,35 +123,47 @@ 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
 
     private
 
-    def load_config_specs_from_storage_adapter(init_diagnostics: nil)
-      init_diagnostics&.mark("download_config_specs", "start", "fetch_from_adapter")
+    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)
-      init_diagnostics&.mark("download_config_specs", "end", "fetch_from_adapter", true)
+      tracker.end(success: true)
       return if cached_values.nil?
 
-      init_diagnostics&.mark("download_config_specs", "start", "process")
+      tracker = @diagnostics.track('data_store_config_specs', 'process')
       process_specs(cached_values, from_adapter: true)
       @init_reason = EvaluationReason::DATA_ADAPTER
-      init_diagnostics&.mark("download_config_specs", "end", "process", @init_reason)
+      tracker.end(success: true)
     rescue StandardError
       # Fallback to network
-      init_diagnostics&.mark("download_config_specs", "end", "fetch_from_adapter", false)
-      download_config_specs(init_diagnostics)
+      tracker.end(success: false)
+      download_config_specs
     end
 
     def save_config_specs_to_storage_adapter(specs_string)
@@ -160,32 +175,40 @@ module Statsig
 
     def sync_config_specs
       Thread.new do
-        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
+            @diagnostics = Diagnostics.new('config_sync')
+            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
+            end
+            @logger.log_diagnostics_event(@diagnostics)
           end
-        end
+        })
       end
     end
 
     def sync_id_lists
       Thread.new do
-        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
+            @diagnostics = Diagnostics.new('config_sync')
+            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
+            end
+            @logger.log_diagnostics_event(@diagnostics)
           end
-        end
+        })
       end
     end
 
-    def download_config_specs(init_diagnostics = nil)
-      init_diagnostics&.mark("download_config_specs", "start", "network_request")
+    def download_config_specs
+      tracker = @diagnostics.track('download_config_specs', 'network_request')
 
       error = nil
       begin
@@ -194,18 +217,17 @@ module Statsig
         if e.is_a? NetworkError
           code = e.http_code
         end
-        init_diagnostics&.mark("download_config_specs", "end", "network_request", code)
+        tracker.end(statusCode: code, success: e.nil?, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
 
         if e.nil?
           unless response.nil?
-            init_diagnostics&.mark("download_config_specs", "start", "process")
-
+            tracker = @diagnostics.track('download_config_specs', 'process')
             if process_specs(response.body.to_s)
               @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
+            tracker.end(success: @init_reason == EvaluationReason::NETWORK)
 
-            init_diagnostics&.mark("download_config_specs", "end", "process", @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
 
           nil
@@ -252,6 +274,9 @@ 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'] || {}
+
+      specs_json['diagnostics']
 
       unless from_adapter
         save_config_specs_to_storage_adapter(specs_string)
@@ -259,18 +284,18 @@ module Statsig
       true
     end
 
-    def get_id_lists_from_adapter(init_diagnostics = nil)
-      init_diagnostics&.mark("get_id_lists", "start", "fetch_from_adapter")
+    def get_id_lists_from_adapter
+      tracker = @diagnostics.track('data_store_id_lists', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::ID_LISTS_KEY)
       return if cached_values.nil?
 
-      init_diagnostics&.mark("get_id_lists", "end", "fetch_from_adapter", true)
+      tracker.end(success: true)
       id_lists = JSON.parse(cached_values)
-      process_id_lists(id_lists, init_diagnostics, from_adapter: true)
+      process_id_lists(id_lists, from_adapter: true)
     rescue StandardError
       # Fallback to network
-      init_diagnostics&.mark("get_id_lists", "end", "fetch_from_adapter", false)
-      get_id_lists_from_network(init_diagnostics)
+      tracker.end(success: false)
+      get_id_lists_from_network
     end
 
     def save_id_lists_to_adapter(id_lists_raw_json)
@@ -280,36 +305,46 @@ module Statsig
       @options.data_store.set(Interfaces::IDataStore::ID_LISTS_KEY, id_lists_raw_json)
     end
 
-    def get_id_lists_from_network(init_diagnostics = nil)
-      init_diagnostics&.mark("get_id_lists", "start", "network_request")
+    def get_id_lists_from_network
+      tracker = @diagnostics.track('get_id_list_sources', 'network_request')
       response, e = @network.post_helper('get_id_lists', JSON.generate({ 'statsigMetadata' => Statsig.get_statsig_metadata }))
-      if !e.nil? || response.nil?
+      code = response&.status.to_i
+      if e.is_a? NetworkError
+        code = e.http_code
+      end
+      success = e.nil? && !response.nil?
+      tracker.end(statusCode: code, success: success, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
+      if !success
         return
       end
-      init_diagnostics&.mark("get_id_lists", "end", "network_request", response.status.to_i)
 
       begin
         server_id_lists = JSON.parse(response)
-        process_id_lists(server_id_lists, init_diagnostics)
+        process_id_lists(server_id_lists)
         save_id_lists_to_adapter(response.body.to_s)
       rescue
         # Ignored, will try again
       end
     end
 
-    def process_id_lists(new_id_lists, init_diagnostics, from_adapter: false)
+    def process_id_lists(new_id_lists, from_adapter: false)
       local_id_lists = @specs[:id_lists]
       if !new_id_lists.is_a?(Hash) || !local_id_lists.is_a?(Hash)
         return
       end
       tasks = []
 
-      if new_id_lists.length == 0
+      tracker = @diagnostics.track(
+        from_adapter ? 'data_store_id_lists' : 'get_id_list_sources',
+        'process',
+        { idListCount: new_id_lists.length }
+      )
+
+      if new_id_lists.empty?
+        tracker.end(success: true)
         return
       end
 
-      init_diagnostics&.mark("get_id_lists", "start", "process", new_id_lists.length)
-
       delete_lists = []
       local_id_lists.each do |list_name, list|
         unless new_id_lists.key? list_name
@@ -357,14 +392,17 @@ module Statsig
       end
 
       result = Concurrent::Promise.all?(*tasks).execute.wait(@id_lists_sync_interval)
-      init_diagnostics&.mark("get_id_lists", "end", "process", 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', { url: list.url })
       cached_values = @options.data_store.get("#{Interfaces::IDataStore::ID_LISTS_KEY}::#{list.name}")
+      tracker.end(success: true)
       content = cached_values.to_s
-      process_single_id_list(list, content)
+      process_single_id_list(list, content, from_adapter: true)
     rescue StandardError
+      tracker.end(success: false)
       nil
     end
 
@@ -377,8 +415,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
         res = http.get(list.url)
+        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
@@ -386,15 +426,18 @@ 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
 
-    def process_single_id_list(list, content, content_length = nil)
+    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', { url: list.url })
         unless content.is_a?(String) && (content[0] == '-' || content[0] == '+')
           @specs[:id_lists].delete(list.name)
+          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
@@ -416,8 +459,10 @@ module Statsig
                     else
                       list.size + content_length
                     end
+        tracker.end(success: true)
         return true
       rescue
+        tracker.end(success: false)
         return false
       end
     end

data/lib/statsig.rb

@@ -208,17 +208,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 +229,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.25.1',
+      'sdkVersion' => '1.26.0',
     }
   end