statsig 1.25.2 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f3c8522d7d8062daf248fd667fd0d8152a4194339fde799814a5da44812eda
-  data.tar.gz: 1fd5e67d4a75ab3b5b6c92c780841252a4610e18bc13310f9b11dbb583aaf16a
+  metadata.gz: 42f5328314de8727a2baaf89da54999627a5505ad95cd5ab816877741e02dd55
+  data.tar.gz: f6af1d20f540ceae4e24c70bdc702fbd9db3acc38776b71ecc50ded6ef40f67d
 SHA512:
-  metadata.gz: 8f516ca6d221c9d789f1f358b550edeedf4203c01ead45374b97a3b81f4205d09f1c7c3e0214516cdcad314bacbdbde39a5df2053779679fe4df593c974c8300
-  data.tar.gz: a90846ef3c050c7c0b8bddbabd19ed7bff6236a15ed941f55d1a305f4c9cb5ff35f595a3d7ea4ab1560d7f7bae11c669c29d17f8041da9125524669703dc5370
+  metadata.gz: 8c4375a325bf7dd1afaa584951b31eca2fd19422301b72397729fdca89e1ef8ae9b7a979aff562889cf49fc98fcd7db3edfc022ca66eb063b2680645c90df2db
+  data.tar.gz: ab23702707825b1ed5ada0df1982d765b97b75e8d813aeeaa9f24ae31974bb0cafa58249e82cc041eaa845bea9ee7639189c8778f8e21e0908b7ec3174d41661

data/lib/client_initialize_helpers.rb

@@ -1,4 +1,7 @@
 # typed: true
+
+require_relative 'hash_utils'
+
 $empty_eval_result = {
   :gate_value => false,
   :json_value => {},
@@ -9,10 +12,12 @@ $empty_eval_result = {
 
 module ClientInitializeHelpers
   class ResponseFormatter
-    def initialize(evaluator, user)
+    def initialize(evaluator, user, hash, client_sdk_key)
       @evaluator = evaluator
       @user = user
       @specs = evaluator.spec_store.get_raw_specs
+      @hash = hash
+      @client_sdk_key = client_sdk_key
     end
 
     def get_responses(key)
@@ -24,6 +29,13 @@ module ClientInitializeHelpers
     private
 
     def to_response(config_name, config_spec)
+      target_app_id = @evaluator.spec_store.get_app_id_for_sdk_key(@client_sdk_key)
+      config_target_apps = config_spec['targetAppIDs']
+
+      unless target_app_id.nil? || config_target_apps.nil? || config_target_apps.include?(target_app_id)
+        return nil
+      end
+
       eval_result = @evaluator.eval_spec(@user, config_spec)
       if eval_result.nil?
         return nil
@@ -33,6 +45,8 @@ module ClientInitializeHelpers
         :gate_value => eval_result.gate_value,
         :json_value => eval_result.json_value,
         :rule_id => eval_result.rule_id,
+        :group_name => eval_result.group_name,
+        :id_type => eval_result.id_type,
         :config_delegate => eval_result.config_delegate,
         :is_experiment_group => eval_result.is_experiment_group,
         :secondary_exposures => eval_result.secondary_exposures,
@@ -52,10 +66,14 @@ module ClientInitializeHelpers
         end
 
         result['value'] = safe_eval_result[:gate_value]
+        result["group_name"] = safe_eval_result[:group_name]
+        result["id_type"] = safe_eval_result[:id_type]
       when 'dynamic_config'
         id_type = config_spec['idType']
         result['value'] = safe_eval_result[:json_value]
         result["group"] = safe_eval_result[:rule_id]
+        result["group_name"] = safe_eval_result[:group_name]
+        result["id_type"] = safe_eval_result[:id_type]
         result["is_device_based"] = id_type.is_a?(String) && id_type.downcase == 'stableid'
       else
         return nil
@@ -67,6 +85,7 @@ module ClientInitializeHelpers
 
       if entity_type == 'layer'
         populate_layer_fields(config_spec, safe_eval_result, result)
+        result.delete('id_type') # not exposed for layer configs in /initialize
       end
 
       hashed_name = hash_name(config_name)
@@ -126,7 +145,14 @@ module ClientInitializeHelpers
     end
 
     def hash_name(name)
-      Digest::SHA256.base64digest(name)
+      case @hash
+      when 'none'
+        return name
+      when 'sha256'
+        return Statsig::HashUtils.sha256(name)
+      when 'djb2'
+        return Statsig::HashUtils.djb2(name)
+      end
     end
   end
-end
+end

data/lib/diagnostics.rb

@@ -22,33 +22,37 @@ module Statsig
         key: String,
         action: String,
         step: T.any(String, NilClass),
-        value: T.any(String, Integer, T::Boolean, NilClass),
-        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+        tags: T::Hash[Symbol, T.untyped]
       ).void
     end
 
-    def mark(key, action, step = nil, value = nil, metadata = nil)
-      @markers.push({
-                      key: key,
-                      step: step,
-                      action: action,
-                      value: value,
-                      metadata: metadata,
-                      timestamp: (Time.now.to_f * 1000).to_i
-                    })
+    def mark(key, action, step, tags)
+      marker = {
+        key: key,
+        action: action,
+        timestamp: (Time.now.to_f * 1000).to_i
+      }
+      if !step.nil?
+        marker[:step] = step
+      end
+      tags.each do |key, val|
+        unless val.nil?
+          marker[key] = val
+        end
+      end
+      @markers.push(marker)
     end
 
     sig do
       params(
         key: String,
         step: T.any(String, NilClass),
-        value: T.any(String, Integer, T::Boolean, NilClass),
-        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+        tags: T::Hash[Symbol, T.untyped]
       ).returns(Tracker)
     end
-    def track(key, step = nil, value = nil, metadata = nil)
-      tracker = Tracker.new(self, key, step, metadata)
-      tracker.start(value)
+    def track(key, step = nil, tags = {})
+      tracker = Tracker.new(self, key, step, tags)
+      tracker.start(**tags)
       tracker
     end
 
@@ -65,6 +69,10 @@ module Statsig
       @markers.clear
     end
 
+    def self.sample(rate)
+      rand(rate).zero?
+    end
+
     class Context
       INITIALIZE = 'initialize'.freeze
       CONFIG_SYNC = 'config_sync'.freeze
@@ -81,22 +89,22 @@ module Statsig
           diagnostics: Diagnostics,
           key: String,
           step: T.any(String, NilClass),
-          metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+          tags: T::Hash[Symbol, T.untyped]
         ).void
       end
-      def initialize(diagnostics, key, step, metadata)
+      def initialize(diagnostics, key, step, tags = {})
         @diagnostics = diagnostics
         @key = key
         @step = step
-        @metadata = metadata
+        @tags = tags
       end
 
-      def start(value = nil)
-        @diagnostics.mark(@key, 'start', @step, value, @metadata)
+      def start(**tags)
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags))
       end
 
-      def end(value = nil)
-        @diagnostics.mark(@key, 'end', @step, value, @metadata)
+      def end(**tags)
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags))
       end
     end
   end

data/lib/error_boundary.rb

@@ -9,70 +9,56 @@ module Statsig
   class ErrorBoundary
     extend T::Sig
 
-    sig { returns(T.any(StatsigLogger, NilClass)) }
-    attr_accessor :logger
-
     sig { params(sdk_key: String).void }
     def initialize(sdk_key)
       @sdk_key = sdk_key
       @seen = Set.new
     end
 
-    def sample_diagnostics
-      rand(10_000).zero?
-    end
-
     def capture(task:, recover: -> {}, caller: nil)
-      if !caller.nil? && Diagnostics::API_CALL_KEYS.include?(caller) && sample_diagnostics
-        diagnostics = Diagnostics.new('api_call')
-        tracker = diagnostics.track(caller)
-      end
       begin
         res = task.call
-        tracker&.end(true)
       rescue StandardError => e
-        tracker&.end(false)
-        if e.is_a?(Statsig::UninitializedError) or e.is_a?(Statsig::ValueError)
+        if e.is_a?(Statsig::UninitializedError) || e.is_a?(Statsig::ValueError)
           raise e
         end
+
         puts '[Statsig]: An unexpected exception occurred.'
-        log_exception(e)
+        log_exception(e, tag: caller)
         res = recover.call
       end
-      @logger&.log_diagnostics_event(diagnostics)
       return res
     end
 
     private
 
-    def log_exception(exception)
-      begin
-        name = exception.class.name
-        if @seen.include?(name)
-          return
-        end
-
-        @seen << name
-        meta = Statsig.get_statsig_metadata
-        http = HTTP.headers(
-          {
-            'STATSIG-API-KEY' => @sdk_key,
-            'STATSIG-SDK-TYPE' => meta['sdkType'],
-            'STATSIG-SDK-VERSION' => meta['sdkVersion'],
-            'Content-Type' => 'application/json; charset=UTF-8'
-          }).accept(:json)
-        body = {
-          'exception' => name,
-          'info' => {
-            'trace' => exception.backtrace.to_s,
-            'message' => exception.message
-          }.to_s,
-          'statsigMetadata' => meta
-        }
-        http.post($endpoint, body: JSON.generate(body))
-      rescue
+    def log_exception(exception, tag: nil)
+      name = exception.class.name
+      if @seen.include?(name)
         return
       end
+
+      @seen << name
+      meta = Statsig.get_statsig_metadata
+      http = HTTP.headers(
+        {
+          'STATSIG-API-KEY' => @sdk_key,
+          'STATSIG-SDK-TYPE' => meta['sdkType'],
+          'STATSIG-SDK-VERSION' => meta['sdkVersion'],
+          'Content-Type' => 'application/json; charset=UTF-8'
+        }).accept(:json)
+      body = {
+        'exception' => name,
+        'info' => {
+          'trace' => exception.backtrace.to_s,
+          'message' => exception.message
+        }.to_s,
+        'statsigMetadata' => meta,
+        'tag' => tag
+      }
+      http.post($endpoint, body: JSON.generate(body))
+    rescue StandardError
+      return
     end
   end
-end
+end

data/lib/evaluator.rb

@@ -17,8 +17,8 @@ module Statsig
   class Evaluator
     attr_accessor :spec_store
 
-    def initialize(network, options, error_callback, diagnostics)
-      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger)
+      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics, error_boundary, logger)
       UAParser.initialize_async
       CountryLookup.initialize_async
 
@@ -98,12 +98,12 @@ module Statsig
       eval_spec(user, @spec_store.get_layer(layer_name))
     end
 
-    def get_client_initialize_response(user)
+    def get_client_initialize_response(user, hash, client_sdk_key)
       if @spec_store.is_ready_for_checks == false
         return nil
       end
 
-      formatter = ClientInitializeHelpers::ResponseFormatter.new(self, user)
+      formatter = ClientInitializeHelpers::ResponseFormatter.new(self, user, hash, client_sdk_key)
 
       evaluated_keys = {}
       if user.user_id.nil? == false
@@ -123,6 +123,7 @@ module Statsig
         "generator" => "statsig-ruby-sdk",
         "evaluated_keys" => evaluated_keys,
         "time" => 0,
+        "hash_used" => hash
       }
     end
 
@@ -199,7 +200,7 @@ module Statsig
           @spec_store.initial_config_sync_time,
           @spec_store.init_reason
         ),
-        group_name: nil,
+        group_name: 'default',
         id_type: config['idType']
       )
     end

data/lib/hash_utils.rb

@@ -0,0 +1,17 @@
+module Statsig
+  class HashUtils
+    def self.djb2(input_str)
+      hash = 0
+      input_str.each_char.each do |c|
+        hash = (hash << 5) - hash + c.ord
+        hash &= hash
+      end
+      hash &= 0xFFFFFFFF # Convert to unsigned 32-bit integer
+      return hash.to_s
+    end
+
+    def self.sha256(input_str)
+      return Digest::SHA256.base64digest(input_str)
+    end
+  end
+end

data/lib/network.rb

@@ -5,8 +5,9 @@ require 'json'
 require 'securerandom'
 require 'sorbet-runtime'
 require 'uri_helper'
+require 'connection_pool'
 
-$retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
+RETRY_CODES = [408, 500, 502, 503, 504, 522, 524, 599].freeze
 
 module Statsig
   class NetworkError < StandardError
@@ -33,29 +34,36 @@ module Statsig
       @post_logs_retry_backoff = options.post_logs_retry_backoff
       @post_logs_retry_limit = options.post_logs_retry_limit
       @session_id = SecureRandom.uuid
+      @connection_pool = ConnectionPool.new(size: 3) do
+        meta = Statsig.get_statsig_metadata
+        client = HTTP.headers(
+          {
+            'STATSIG-API-KEY' => @server_secret,
+            'STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s,
+            'STATSIG-SERVER-SESSION-ID' => @session_id,
+            'Content-Type' => 'application/json; charset=UTF-8',
+            'STATSIG-SDK-TYPE' => meta['sdkType'],
+            'STATSIG-SDK-VERSION' => meta['sdkVersion']
+          }
+        ).accept(:json)
+        if @timeout
+          client = client.timeout(@timeout)
+        end
+
+        client
+      end
     end
 
-    sig { params(endpoint: String, body: String, retries: Integer, backoff: Integer)
-            .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)]) }
+    sig do
+      params(endpoint: String, body: String, retries: Integer, backoff: Integer)
+        .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)])
+    end
 
     def post_helper(endpoint, body, retries = 0, backoff = 1)
       if @local_mode
         return nil, nil
       end
 
-      meta = Statsig.get_statsig_metadata
-      http = HTTP.headers(
-        {
-          "STATSIG-API-KEY" => @server_secret,
-          "STATSIG-CLIENT-TIME" => (Time.now.to_f * 1000).to_i.to_s,
-          "STATSIG-SERVER-SESSION-ID" => @session_id,
-          "Content-Type" => "application/json; charset=UTF-8",
-          "STATSIG-SDK-TYPE" => meta['sdkType'],
-          "STATSIG-SDK-VERSION" => meta['sdkVersion'],
-        }).accept(:json)
-      if @timeout
-        http = http.timeout(@timeout)
-      end
       backoff_adjusted = backoff > 10 ? backoff += Random.rand(10) : backoff # to deter overlap
       if @post_logs_retry_backoff
         if @post_logs_retry_backoff.is_a? Integer
@@ -66,48 +74,53 @@ module Statsig
       end
       url = URIHelper.build_url(endpoint)
       begin
-        res = http.post(url, body: body)
+        res = @connection_pool.with do |conn|
+          conn.headers('STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s).post(url, body: body)
+        end
       rescue StandardError => e
         ## network error retry
-        return nil, e unless retries > 0
+        return nil, e unless retries.positive?
+
         sleep backoff_adjusted
         return post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
       end
       return res, nil if res.status.success?
-      return nil, NetworkError.new("Got an exception when making request to #{url}: #{res.to_s}", res.status.to_i) unless retries > 0 && $retry_codes.include?(res.code)
+
+      unless retries.positive? && RETRY_CODES.include?(res.code)
+        return res, NetworkError.new("Got an exception when making request to #{url}: #{res.to_s}",
+                                     res.status.to_i)
+      end
+
       ## status code retry
       sleep backoff_adjusted
       post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
     end
 
     def check_gate(user, gate_name)
-      begin
-        request_body = JSON.generate({ 'user' => user&.serialize(false), 'gateName' => gate_name })
-        response, _ = post_helper('check_gate', request_body)
-        return JSON.parse(response.body) unless response.nil?
-        false
-      rescue
-        return false
-      end
+      request_body = JSON.generate({ 'user' => user&.serialize(false), 'gateName' => gate_name })
+      response, = post_helper('check_gate', request_body)
+      return JSON.parse(response.body) unless response.nil?
+
+      false
+    rescue StandardError
+      false
     end
 
     def get_config(user, dynamic_config_name)
-      begin
-        request_body = JSON.generate({ 'user' => user&.serialize(false), 'configName' => dynamic_config_name })
-        response, _ = post_helper('get_config', request_body)
-        return JSON.parse(response.body) unless response.nil?
-        nil
-      rescue
-        return nil
-      end
+      request_body = JSON.generate({ 'user' => user&.serialize(false), 'configName' => dynamic_config_name })
+      response, = post_helper('get_config', request_body)
+      return JSON.parse(response.body) unless response.nil?
+
+      nil
+    rescue StandardError
+      nil
     end
 
     def post_logs(events)
-      begin
-        json_body = JSON.generate({ 'events' => events, 'statsigMetadata' => Statsig.get_statsig_metadata })
-        post_helper('log_event', json_body, @post_logs_retry_limit)
-      rescue
-      end
+      json_body = JSON.generate({ 'events' => events, 'statsigMetadata' => Statsig.get_statsig_metadata })
+      post_helper('log_event', json_body, @post_logs_retry_limit)
+    rescue StandardError
+
     end
   end
-end
+end

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
 
@@ -119,15 +123,27 @@ 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
@@ -137,16 +153,16 @@ module Statsig
     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
 
@@ -159,29 +175,35 @@ module Statsig
 
     def sync_config_specs
       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
+            @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
-        @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
+            @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
 
@@ -195,7 +217,7 @@ 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?
@@ -203,7 +225,7 @@ module Statsig
             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
@@ -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)
@@ -264,12 +289,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 +312,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 +337,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 +392,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 +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
-        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 +426,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 +434,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,10 +459,10 @@ 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

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.2',
+      'sdkVersion' => '1.26.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,7 @@ class StatsigDriver
       event.value = value
       event.metadata = metadata
       @logger.log_event(event)
-    })
+    }, caller: __method__.to_s)
   end
 
   def shutdown
@@ -179,29 +190,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 +224,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(10_000)
+      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.")

data/lib/statsig_logger.rb

@@ -9,7 +9,7 @@ $diagnostics_event = 'statsig::diagnostics'
 $ignored_metadata_keys = ['serverTime', 'configSyncTime', 'initTime', 'reason']
 module Statsig
   class StatsigLogger
-    def initialize(network, options)
+    def initialize(network, options, error_boundary)
       @network = network
       @events = []
       @options = options
@@ -23,9 +23,11 @@ module Statsig
         fallback_policy: :discard
       )
 
+      @error_boundary = error_boundary
       @background_flush = periodic_flush
       @deduper = Concurrent::Set.new()
       @interval = 0
+      @flush_mutex = Mutex.new
     end
 
     def log_event(event)
@@ -109,12 +111,14 @@ module Statsig
 
     def periodic_flush
       Thread.new do
-        loop do
-          sleep @options.logging_interval_seconds
-          flush_async
-          @interval += 1
-          @deduper.clear if @interval % 2 == 0
-        end
+        @error_boundary.capture(task: lambda {
+          loop do
+            sleep @options.logging_interval_seconds
+            flush_async
+            @interval += 1
+            @deduper.clear if @interval % 2 == 0
+          end
+        })
       end
     end
 
@@ -132,18 +136,20 @@ module Statsig
     end
 
     def flush
-      if @events.length == 0
-        return
-      end
-      events_clone = @events
-      @events = []
-      flush_events = events_clone.map { |e| e.serialize }
+      @flush_mutex.synchronize do
+        if @events.length.zero?
+          return
+        end
 
-      @network.post_logs(flush_events)
+        events_clone = @events
+        @events = []
+        flush_events = events_clone.map { |e| e.serialize }
+        @network.post_logs(flush_events)
+      end
     end
 
     def maybe_restart_background_threads
-      if @background_flush.nil? or !@background_flush.alive?
+      if @background_flush.nil? || !@background_flush.alive?
         @background_flush = periodic_flush
       end
     end

data/lib/ua_parser.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'user_agent_parser'
 
 module UAParser

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.25.2
+  version: 1.26.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-20 00:00:00.000000000 Z
+date: 2023-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.14.0
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: minitest-suite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: spy
   requirement: !ruby/object:Gem::Requirement
@@ -226,6 +254,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
 - !ruby/object:Gem::Dependency
   name: ip3country
   requirement: !ruby/object:Gem::Requirement
@@ -282,6 +330,7 @@ files:
 - lib/evaluation_details.rb
 - lib/evaluation_helpers.rb
 - lib/evaluator.rb
+- lib/hash_utils.rb
 - lib/id_list.rb
 - lib/interfaces/data_store.rb
 - lib/layer.rb