statsig 2.0.1 → 2.8.1

data/lib/network.rb

@@ -1,10 +1,9 @@
+require 'connection_pool'
 require 'http'
 require 'json'
 require 'securerandom'
 require 'zlib'
 
-require 'connection_pool'
-
 RETRY_CODES = [408, 500, 502, 503, 504, 522, 524, 599].freeze
 
 module Statsig
@@ -53,7 +52,11 @@ module Statsig
 
     def download_config_specs(since_time)
       url = @options.download_config_specs_url
-      get("#{url}#{@server_secret}.json?sinceTime=#{since_time}")
+      dcs_url = "#{url}#{@server_secret}.json"
+      if since_time.positive?
+        dcs_url += "?sinceTime=#{since_time}"
+      end
+      get(dcs_url)
     end
 
     def post_logs(events, error_boundary)
@@ -64,6 +67,10 @@ module Statsig
       gzip << json_body
 
       response, e = post(url, gzip.close.string, @post_logs_retry_limit, 1, true, event_count)
+
+      # Consume response body to ensure connection can be closed.
+      response&.flush
+
       unless e == nil
         message = "Failed to log #{event_count} events after #{@post_logs_retry_limit} retries"
         puts "[Statsig]: #{message}"

data/lib/sdk_configs.rb

@@ -0,0 +1,37 @@
+require 'concurrent-ruby'
+
+module Statsig
+  class SDKConfigs
+    def initialize
+      @configs = Concurrent::Hash.new
+      @flags = Concurrent::Hash.new
+    end
+
+    def set_flags(new_flags)
+      @flags = new_flags || Concurrent::Hash.new
+    end
+
+    def set_configs(new_configs)
+      @configs = new_configs || Concurrent::Hash.new
+    end
+
+    def on(flag)
+      @flags[flag.to_sym] == true
+    end
+
+    def get_config_num_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(Numeric) ? value.to_f : nil
+    end
+
+    def get_config_string_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(String) ? value : nil
+    end
+
+    def get_config_int_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(Integer) ? value : nil
+    end
+  end
+end

data/lib/spec_store.rb

@@ -1,10 +1,10 @@
+require 'concurrent-ruby'
 require 'net/http'
 require 'uri'
-require 'evaluation_details'
-require 'id_list'
-require 'concurrent-ruby'
-require 'hash_utils'
-require 'api_config'
+require_relative 'api_config'
+require_relative 'evaluation_details'
+require_relative 'hash_utils'
+require_relative 'id_list'
 
 module Statsig
   class SpecStore
@@ -19,8 +19,11 @@ module Statsig
     attr_accessor :sdk_keys_to_app_ids
     attr_accessor :hashed_sdk_keys_to_app_ids
     attr_accessor :unsupported_configs
+    attr_accessor :cmab_configs
+    attr_accessor :overrides
+    attr_accessor :override_rules
 
-    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key, sdk_config)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -33,16 +36,22 @@ module Statsig
       @gates = {}
       @configs = {}
       @layers = {}
+      @cmab_configs = {}
       @condition_map = {}
       @id_lists = {}
       @experiment_to_layer = {}
       @sdk_keys_to_app_ids = {}
       @hashed_sdk_keys_to_app_ids = {}
+      @overrides = {}
+      @override_rules = {}
       @diagnostics = diagnostics
       @error_boundary = error_boundary
       @logger = logger
       @secret_key = secret_key
       @unsupported_configs = Set.new
+      @sdk_configs = sdk_config
+
+      startTime = (Time.now.to_f * 1000).to_i
 
       @id_list_thread_pool = Concurrent::FixedThreadPool.new(
         options.idlist_threadpool_size,
@@ -57,7 +66,7 @@ module Statsig
         else
           tracker = @diagnostics.track('initialize','bootstrap', 'process')
           begin
-            if process_specs(options.bootstrap_values)
+            if process_specs(options.bootstrap_values).nil?
               @init_reason = EvaluationReason::BOOTSTRAP
             end
           rescue StandardError
@@ -68,13 +77,15 @@ module Statsig
         end
       end
 
+      failure_details = nil
+
       unless @options.data_store.nil?
         @options.data_store.init
-        load_config_specs_from_storage_adapter('initialize')
+        failure_details = load_config_specs_from_storage_adapter('initialize')
       end
 
       if @init_reason == EvaluationReason::UNINITIALIZED
-        download_config_specs('initialize')
+        failure_details = download_config_specs('initialize')
       end
 
       @initial_config_sync_time = @last_config_sync_time == 0 ? -1 : @last_config_sync_time
@@ -86,12 +97,18 @@ module Statsig
 
       @config_sync_thread = spawn_sync_config_specs_thread
       @id_lists_sync_thread = spawn_sync_id_lists_thread
+      endTime = (Time.now.to_f * 1000).to_i
+      @initialization_details = {duration: endTime - startTime, isSDKReady: true, configSpecReady: @init_reason != EvaluationReason::UNINITIALIZED, failureDetails: failure_details}
     end
 
     def is_ready_for_checks
       @last_config_sync_time != 0
     end
 
+    def get_initialization_details
+      @initialization_details
+    end
+
     def shutdown
       @config_sync_thread&.exit
       @id_lists_sync_thread&.exit
@@ -114,6 +131,13 @@ module Statsig
       @layers.key?(layer_name.to_sym)
     end
 
+    def has_cmab_config?(config_name)
+      if @cmab_configs.nil?
+        return false
+      end
+      @cmab_configs.key?(config_name.to_sym)
+    end
+
     def get_gate(gate_name)
       gate_sym = gate_name.to_sym
       return nil unless has_gate?(gate_sym)
@@ -134,6 +158,12 @@ module Statsig
       @layers[layer_sym]
     end
 
+    def get_cmab_config(config_name)
+      config_sym = config_name.to_sym
+      return nil unless has_cmab_config?(config_sym)
+      @cmab_configs[config_sym]
+    end
+
     def get_condition(condition_hash)
       @condition_map[condition_hash.to_sym]
     end
@@ -202,13 +232,19 @@ module Statsig
       return if cached_values.nil?
 
       tracker = @diagnostics.track(context, 'data_store_config_specs', 'process')
-      process_specs(cached_values, from_adapter: true)
-      @init_reason = EvaluationReason::DATA_ADAPTER
-      tracker.end(success: true)
+      failure_details = process_specs(cached_values, from_adapter: true)
+      if failure_details.nil?
+        @init_reason = EvaluationReason::DATA_ADAPTER
+        tracker.end(success: true)
+      else
+        tracker.end(success: false)
+        return download_config_specs(context)
+      end
+      return failure_details
     rescue StandardError
       # Fallback to network
       tracker.end(success: false)
-      download_config_specs(context)
+      return download_config_specs(context)
     end
 
     def save_rulesets_to_storage_adapter(rulesets_string)
@@ -253,18 +289,21 @@ module Statsig
       tracker = @diagnostics.track(context, 'download_config_specs', 'network_request')
 
       error = nil
+      failure_details = nil
       begin
         response, e = @network.download_config_specs(@last_config_sync_time)
         code = response&.status.to_i
         if e.is_a? NetworkError
           code = e.http_code
+          failure_details = {statusCode: code, exception: e, reason: "CONFIG_SPECS_NETWORK_ERROR"}
         end
         tracker.end(statusCode: code, success: e.nil?, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
 
         if e.nil?
           unless response.nil?
             tracker = @diagnostics.track(context, 'download_config_specs', 'process')
-            if process_specs(response.body.to_s)
+            failure_details = process_specs(response.body.to_s)
+            if failure_details.nil?
               @init_reason = EvaluationReason::NETWORK
             end
             tracker.end(success: @init_reason == EvaluationReason::NETWORK)
@@ -274,59 +313,68 @@ module Statsig
                                            @last_config_sync_time)
             end
           end
-
-          nil
         else
           error = e
         end
       rescue StandardError => e
+        failure_details = {exception: e, reason: "INTERNAL_ERROR"}
         error = e
       end
 
       @error_callback.call(error) unless error.nil? or @error_callback.nil?
+      return failure_details
     end
 
     def process_specs(specs_string, from_adapter: false)
       if specs_string.nil?
-        return false
-      end
-
-      specs_json = JSON.parse(specs_string, { symbolize_names: true })
-      return false unless specs_json.is_a? Hash
-
-      hashed_sdk_key_used = specs_json[:hashed_sdk_key_used]
-      unless hashed_sdk_key_used.nil? or hashed_sdk_key_used == Statsig::HashUtils.djb2(@secret_key)
-        err_boundary.log_exception(Statsig::InvalidSDKKeyResponse.new)
-        return false
-      end
-
-      new_specs_sync_time = specs_json[:time]
-      if new_specs_sync_time.nil? \
-        || new_specs_sync_time < @last_config_sync_time \
-        || specs_json[:has_updates] != true \
-        || specs_json[:feature_gates].nil? \
-        || specs_json[:dynamic_configs].nil? \
-        || specs_json[:layer_configs].nil?
-        return false
+        return {reason: "EMPTY_SPEC"}
       end
 
-      @last_config_sync_time = new_specs_sync_time
-      @unsupported_configs.clear
+      begin
+        specs_json = JSON.parse(specs_string, { symbolize_names: true })
+        return {reason: "PARSE_RESPONSE_ERROR"} unless specs_json.is_a? Hash
 
-      specs_json[:diagnostics]&.each { |key, value| @diagnostics.sample_rates[key.to_s] = value }
+        hashed_sdk_key_used = specs_json[:hashed_sdk_key_used]
+        unless hashed_sdk_key_used.nil? or hashed_sdk_key_used == Statsig::HashUtils.djb2(@secret_key)
+          err_boundary.log_exception(Statsig::InvalidSDKKeyResponse.new)
+          return {reason: "PARSE_RESPONSE_ERROR"}
+        end
 
-      @gates = specs_json[:feature_gates]
-      @configs = specs_json[:dynamic_configs]
-      @layers = specs_json[:layer_configs]
-      @condition_map = specs_json[:condition_map]
-      @experiment_to_layer = specs_json[:experiment_to_layer]
-      @sdk_keys_to_app_ids = specs_json[:sdk_keys_to_app_ids] || {}
-      @hashed_sdk_keys_to_app_ids = specs_json[:hashed_sdk_keys_to_app_ids] || {}
+        new_specs_sync_time = specs_json[:time]
+        if new_specs_sync_time.nil? \
+          || new_specs_sync_time < @last_config_sync_time \
+          || specs_json[:has_updates] != true \
+          || specs_json[:feature_gates].nil? \
+          || specs_json[:dynamic_configs].nil? \
+          || specs_json[:layer_configs].nil?
+          return {reason: "PARSE_RESPONSE_ERROR"}
+        end
 
-      unless from_adapter
-        save_rulesets_to_storage_adapter(specs_string)
+        @last_config_sync_time = new_specs_sync_time
+        @unsupported_configs.clear
+
+        specs_json[:diagnostics]&.each { |key, value| @diagnostics.sample_rates[key.to_s] = value }
+
+        @gates = specs_json[:feature_gates]
+        @configs = specs_json[:dynamic_configs]
+        @layers = specs_json[:layer_configs]
+        @cmab_configs = specs_json[:cmab_configs]
+        @condition_map = specs_json[:condition_map]
+        @experiment_to_layer = specs_json[:experiment_to_layer]
+        @sdk_keys_to_app_ids = specs_json[:sdk_keys_to_app_ids] || {}
+        @hashed_sdk_keys_to_app_ids = specs_json[:hashed_sdk_keys_to_app_ids] || {}
+        @sdk_configs.set_flags(specs_json[:sdk_flags])
+        @sdk_configs.set_configs(specs_json[:sdk_configs])
+        @overrides = specs_json[:overrides] || {}
+        @override_rules = specs_json[:override_rules] || {}
+
+        unless from_adapter
+          save_rulesets_to_storage_adapter(specs_string)
+        end
+      rescue StandardError => e
+        return {reason: "PARSE_RESPONSE_ERROR"}
       end
-      true
+      nil
     end
 
     def get_id_lists_from_adapter(context)

data/lib/statsig.rb

@@ -1,6 +1,5 @@
-require 'statsig_driver'
-
-require 'statsig_errors'
+require_relative 'statsig_driver'
+require_relative 'statsig_errors'
 
 module Statsig
 
@@ -20,6 +19,13 @@ module Statsig
     @shared_instance = StatsigDriver.new(secret_key, options, error_callback)
   end
 
+  def self.get_initialization_details
+    if not defined? @shared_instance or @shared_instance.nil?
+      return {duration: 0, isSDKReady: false, configSpecReady: false, failure_details: {exception: Statsig::UninitializedError.new, reason: 'INTERNAL_ERROR'}}
+    end
+    @shared_instance.get_initialization_details
+  end
+
   class GetGateOptions
     attr_accessor :disable_log_exposure, :skip_evaluation, :disable_evaluation_details
 
@@ -65,7 +71,7 @@ module Statsig
   end
 
   ##
-  # @deprecated - use check_gate(user, gate, options) and disable_exposure_logging in options
+  # @deprecated - use check_gate(user, gate, options) with CheckGateOptions.new(disable_log_exposure: true) as options
   # Gets the boolean result of a gate, evaluated against the given user.
   #
   # @param user A StatsigUser object used for the evaluation
@@ -85,6 +91,11 @@ module Statsig
     @shared_instance&.manually_log_gate_exposure(user, gate_name)
   end
 
+  def self.get_fields_used_for_gate(gate_name)
+    ensure_initialized
+    @shared_instance&.get_fields_used_for_gate(gate_name)
+  end
+
   class GetConfigOptions
     attr_accessor :disable_log_exposure, :disable_evaluation_details, :ignore_local_overrides
 
@@ -108,7 +119,7 @@ module Statsig
   end
 
   ##
-  # @deprecated - use get_config(user, config, options) and disable_exposure_logging in options
+  # @deprecated - use get_config(user, config, options) with GetConfigOptions.new(disable_log_exposure: true) as options
   # Get the values of a dynamic config, evaluated against the given user.
   #
   # @param [StatsigUser] user A StatsigUser object used for the evaluation
@@ -129,6 +140,11 @@ module Statsig
     @shared_instance&.manually_log_config_exposure(user, dynamic_config)
   end
 
+  def self.get_fields_used_for_config(config_name)
+    ensure_initialized
+    @shared_instance&.get_fields_used_for_config(config_name)
+  end
+
   class GetExperimentOptions
     attr_accessor :disable_log_exposure, :user_persisted_values, :disable_evaluation_details, :ignore_local_overrides
 
@@ -152,7 +168,7 @@ module Statsig
   end
 
   ##
-  # @deprecated - use get_experiment(user, experiment, options) and disable_exposure_logging in options
+  # @deprecated - use get_experiment(user, experiment, options) with GetExperimentOptions.new(disable_log_exposure: true) as options
   # Get the values of an experiment, evaluated against the given user.
   #
   # @param [StatsigUser] user A StatsigUser object used for the evaluation
@@ -177,6 +193,11 @@ module Statsig
     @shared_instance&.get_user_persisted_values(user, id_type)
   end
 
+  def self.get_fields_used_for_experiment(experiment_name)
+    ensure_initialized
+    @shared_instance&.get_fields_used_for_config(experiment_name)
+  end
+
   class GetLayerOptions
     attr_accessor :disable_log_exposure, :disable_evaluation_details
 
@@ -199,7 +220,7 @@ module Statsig
   end
 
   ##
-  # @deprecated - use get_layer(user, gate, options) and disable_exposure_logging in options
+  # @deprecated - use get_layer(user, gate, options) with GetLayerOptions.new(disable_log_exposure: true) as options
   # Get the values of a layer, evaluated against the given user.
   #
   # @param user A StatsigUser object used for the evaluation
@@ -220,6 +241,11 @@ module Statsig
     @shared_instance&.manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
   end
 
+  def self.get_fields_used_for_layer(layer_name)
+    ensure_initialized
+    @shared_instance&.get_fields_used_for_layer(layer_name)
+  end
+
   ##
   # Logs an event to Statsig with the provided values.
   #
@@ -321,6 +347,17 @@ module Statsig
     @shared_instance&.override_config(config_name, config_value)
   end
 
+
+  ##
+  # Overrides an experiment to return the value for a specific group name.
+  #
+  # @param experiment_name The name of the experiment to be overridden
+  # @param group_name The name of the group whose value should be returned
+  def self.override_experiment_by_group_name(experiment_name, group_name)
+    ensure_initialized
+    @shared_instance&.override_experiment_by_group_name(experiment_name, group_name)
+  end
+
   def self.remove_config_override(config_name)
     ensure_initialized
     @shared_instance&.remove_config_override(config_name)
@@ -331,6 +368,16 @@ module Statsig
     @shared_instance&.clear_config_overrides
   end
 
+  def self.clear_experiment_overrides
+    ensure_initialized
+    @shared_instance&.clear_experiment_overrides
+  end
+
+  def self.remove_experiment_override(experiment_name)
+    ensure_initialized
+    @shared_instance&.remove_experiment_override(experiment_name)
+  end
+
   ##
   # @param [HashTable] debug information log with exposure events
   def self.set_debug_info(debug_info)
@@ -363,11 +410,15 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '2.0.1',
+      'sdkVersion' => '2.8.1',
       'languageVersion' => RUBY_VERSION
     }
   end
 
+  def self.get_options
+    @driver&.instance_variable_get(:@options)
+  end
+
   private
 
   def self.ensure_initialized