statsig 1.29.0 → 1.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '093cc05e0b8f3bb7e2f0f019cf36ad33e5abc4c4349d2fb1faa056c1ff5aa341'
-  data.tar.gz: d66640f8b0c317ca018ff4ccc77d1d370af89b1c84416508631deb610236d519
+  metadata.gz: 1442642777f1e73e38aa9944a88f9eab27a88df0c856ed0bc708555fe51a7b91
+  data.tar.gz: '07159c53071c5650f01016e485aca359568025f96dbeea39e3b99d39d1286662'
 SHA512:
-  metadata.gz: f634575320cd1ababfa25816ee8ac5fe27e34c761895b4ba6b20957363e487c295767d65e123ab7d306aa1ce2f535f55cc58570f8767790948d2647ab321150b
-  data.tar.gz: d563727b175a23afa50cb68cbaf91eb49435bae46b1a48b72d9bf0ff38febeefa86b886c34cc2632f37e357c44f96a1e2586050b41e9ac156697f4105c4f9f0b
+  metadata.gz: 1454423d5e182969c8abce5ab37a7aef9ed9ff854398725b13d3743dc85f49dffb2a7e9176ffdda6e18bef2cdbc4c191aac0716ac204b5a054e1e11e359bde6c
+  data.tar.gz: 1a07714268ca3bec58974e3059c34dcc6a7e7f0a8617fd22874b0c49342546cc475ea9b6ec24569e4d07109aca7c0afdd5ead59f809512d5a9ba83ca0894e4e7

data/lib/client_initialize_helpers.rb

@@ -3,13 +3,6 @@
 require_relative 'hash_utils'
 require 'sorbet-runtime'
 
-$empty_eval_result = {
-  :gate_value => false,
-  :json_value => {},
-  :rule_id => "",
-  :is_experiment_group => false,
-  :secondary_exposures => []
-}
 
 module ClientInitializeHelpers
   class ResponseFormatter
@@ -51,18 +44,6 @@ module ClientInitializeHelpers
         return nil
       end
 
-      safe_eval_result = eval_result == $fetch_from_server ? $empty_eval_result : {
-        :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 => filter_segments_from_secondary_exposures(eval_result.secondary_exposures),
-        :undelegated_sec_exps => eval_result.undelegated_sec_exps
-      }
-
       category = config_spec['type']
       entity_type = config_spec['entity']
 
@@ -75,26 +56,26 @@ module ClientInitializeHelpers
           return nil
         end
 
-        result['value'] = safe_eval_result[:gate_value]
-        result["group_name"] = safe_eval_result[:group_name]
-        result["id_type"] = safe_eval_result[:id_type]
+        result['value'] = eval_result.gate_value
+        result["group_name"] = eval_result.group_name
+        result["id_type"] = 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['value'] = eval_result.json_value
+        result["group"] = eval_result.rule_id
+        result["group_name"] = eval_result.group_name
+        result["id_type"] = eval_result.id_type
         result["is_device_based"] = id_type.is_a?(String) && id_type.downcase == 'stableid'
       else
         return nil
       end
 
       if entity_type == 'experiment'
-        populate_experiment_fields(config_name, config_spec, safe_eval_result, result)
+        populate_experiment_fields(config_name, config_spec, eval_result, result)
       end
 
       if entity_type == 'layer'
-        populate_layer_fields(config_spec, safe_eval_result, result)
+        populate_layer_fields(config_spec, eval_result, result)
         result.delete('id_type') # not exposed for layer configs in /initialize
       end
 
@@ -102,8 +83,8 @@ module ClientInitializeHelpers
       [hashed_name, result.merge(
         {
           "name" => hashed_name,
-          "rule_id" => safe_eval_result[:rule_id],
-          "secondary_exposures" => clean_exposures(safe_eval_result[:secondary_exposures])
+          "rule_id" => eval_result.rule_id,
+          "secondary_exposures" => clean_exposures(eval_result.secondary_exposures)
         }).compact]
     end
 
@@ -118,7 +99,7 @@ module ClientInitializeHelpers
     end
 
     def populate_experiment_fields(config_name, config_spec, eval_result, result)
-      result["is_user_in_experiment"] = eval_result[:is_experiment_group]
+      result["is_user_in_experiment"] = eval_result.is_experiment_group
       result["is_experiment_active"] = config_spec['isActive'] == true
 
       if config_spec['hasSharedParams'] != true
@@ -138,7 +119,7 @@ module ClientInitializeHelpers
     end
 
     def populate_layer_fields(config_spec, eval_result, result)
-      delegate = eval_result[:config_delegate]
+      delegate = eval_result.config_delegate
       result["explicit_parameters"] = config_spec["explicitParameters"] || []
 
       if delegate.nil? == false && delegate.empty? == false
@@ -151,7 +132,7 @@ module ClientInitializeHelpers
         result["explicit_parameters"] = delegate_spec["explicitParameters"] || []
       end
 
-      result["undelegated_secondary_exposures"] = clean_exposures(eval_result[:undelegated_sec_exps] || [])
+      result["undelegated_secondary_exposures"] = clean_exposures(eval_result.undelegated_sec_exps || [])
     end
 
     def hash_name(name)

data/lib/config_result.rb

@@ -18,6 +18,7 @@ module Statsig
     attr_accessor :evaluation_details
     attr_accessor :group_name
     attr_accessor :id_type
+    attr_accessor :target_app_ids
 
     def initialize(
       name,
@@ -30,7 +31,8 @@ module Statsig
       is_experiment_group: false,
       evaluation_details: nil,
       group_name: nil,
-      id_type: '')
+      id_type: '',
+      target_app_ids: nil)
       @name = name
       @gate_value = gate_value
       @json_value = json_value
@@ -43,6 +45,7 @@ module Statsig
       @evaluation_details = evaluation_details
       @group_name = group_name
       @id_type = id_type
+      @target_app_ids = target_app_ids
     end
 
     sig { params(config_name: String, user_persisted_values: UserPersistedValues).returns(T.nilable(ConfigResult)) }
@@ -62,7 +65,9 @@ module Statsig
         hash['rule_id'],
         hash['secondary_exposures'],
         evaluation_details: EvaluationDetails.persisted(hash['config_sync_time'], hash['init_time']),
-        group_name: hash['group_name']
+        group_name: hash['group_name'],
+        id_type: hash['id_type'],
+        target_app_ids: hash['target_app_ids']
       )
     end
 
@@ -75,7 +80,9 @@ module Statsig
         secondary_exposures: @secondary_exposures,
         config_sync_time: @evaluation_details.config_sync_time,
         init_time: @init_time,
-        group_name: @group_name
+        group_name: @group_name,
+        id_type: @id_type,
+        target_app_ids: @target_app_ids
       }
     end
   end

data/lib/diagnostics.rb

@@ -6,18 +6,14 @@ module Statsig
   class Diagnostics
     extend T::Sig
 
-    sig { returns(String) }
-    attr_accessor :context
-
-    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    sig { returns(T::Hash[String, T::Array[T::Hash[Symbol, T.untyped]]]) }
     attr_reader :markers
 
     sig { returns(T::Hash[String, Numeric]) }
     attr_accessor :sample_rates
 
-    def initialize(context)
-      @context = context
-      @markers = []
+    def initialize()
+      @markers = {:initialize => [], :api_call => [], :config_sync => []}
       @sample_rates = {}
     end
 
@@ -26,11 +22,12 @@ module Statsig
         key: String,
         action: String,
         step: T.any(String, NilClass),
-        tags: T::Hash[Symbol, T.untyped]
+        tags: T::Hash[Symbol, T.untyped],
+        context: String
       ).void
     end
 
-    def mark(key, action, step, tags)
+    def mark(key, action, step, tags, context)
       marker = {
         key: key,
         action: action,
@@ -44,60 +41,49 @@ module Statsig
           marker[key] = val
         end
       end
-      @markers.push(marker)
+      if @markers[context].nil?
+        @markers[context] = []
+      end
+      @markers[context].push(marker)
     end
 
     sig do
       params(
+        context: String,
         key: String,
         step: T.any(String, NilClass),
         tags: T::Hash[Symbol, T.untyped]
       ).returns(Tracker)
     end
-    def track(key, step = nil, tags = {})
-      tracker = Tracker.new(self, key, step, tags)
+    def track(context, key, step = nil, tags = {})
+      tracker = Tracker.new(self, context, key, step, tags)
       tracker.start(**tags)
       tracker
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-
-    def serialize
-      {
-        context: @context.clone,
-        markers: @markers.clone
-      }
-    end
-
-    def serialize_with_sampling
-      marker_keys = @markers.map { |e| e[:key] }
+    def serialize_with_sampling(context)
+      marker_keys = @markers[context].map { |e| e[:key] }
       unique_marker_keys = marker_keys.uniq { |e| e }
       sampled_marker_keys = unique_marker_keys.select do |key|
         @sample_rates.key?(key) && !self.class.sample(@sample_rates[key])
       end
-      final_markers = @markers.select do |marker|
+      final_markers = @markers[context].select do |marker|
         !sampled_marker_keys.include?(marker[:key])
       end
       {
-        context: @context.clone,
-        markers: final_markers
+        context: context.clone,
+        markers: final_markers.clone
       }
     end
 
-    def clear_markers
-      @markers.clear
+    def clear_markers(context)
+      @markers[context].clear
     end
 
     def self.sample(rate_over_ten_thousand)
       rand * 10_000 < rate_over_ten_thousand
     end
 
-    class Context
-      INITIALIZE = 'initialize'.freeze
-      CONFIG_SYNC = 'config_sync'.freeze
-      API_CALL = 'api_call'.freeze
-    end
-
     API_CALL_KEYS = %w[check_gate get_config get_experiment get_layer].freeze
 
     class Tracker
@@ -106,24 +92,26 @@ module Statsig
       sig do
         params(
           diagnostics: Diagnostics,
+          context: String,
           key: String,
           step: T.any(String, NilClass),
           tags: T::Hash[Symbol, T.untyped]
         ).void
       end
-      def initialize(diagnostics, key, step, tags = {})
+      def initialize(diagnostics, context, key, step, tags = {})
         @diagnostics = diagnostics
+        @context = context
         @key = key
         @step = step
         @tags = tags
       end
 
       def start(**tags)
-        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags))
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
 
       def end(**tags)
-        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags))
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
     end
   end

data/lib/error_boundary.rb

@@ -24,6 +24,7 @@ module Statsig
         end
 
         puts '[Statsig]: An unexpected exception occurred.'
+        puts e.message
         log_exception(e, tag: caller)
         res = recover.call
       end
@@ -45,6 +46,7 @@ module Statsig
           'STATSIG-API-KEY' => @sdk_key,
           'STATSIG-SDK-TYPE' => meta['sdkType'],
           'STATSIG-SDK-VERSION' => meta['sdkVersion'],
+          'STATSIG-SDK-LANGUAGE-VERSION' => meta['languageVersion'],
           'Content-Type' => 'application/json; charset=UTF-8'
         }).accept(:json)
       body = {

data/lib/evaluation_details.rb

@@ -9,6 +9,7 @@ module Statsig
     BOOTSTRAP = 'Bootstrap'.freeze
     DATA_ADAPTER = 'DataAdapter'.freeze
     PERSISTED = 'Persisted'.freeze
+    UNSUPPORTED = 'Unsupported'.freeze
   end
 
   class EvaluationDetails

data/lib/evaluator.rb

@@ -13,13 +13,12 @@ require 'evaluation_details'
 require 'user_agent_parser/operating_system'
 require 'user_persistent_storage_utils'
 
-$fetch_from_server = 'fetch_from_server'
-$type_dynamic_config = 'dynamic_config'
-
 module Statsig
   class Evaluator
     extend T::Sig
 
+    UNSUPPORTED_EVALUATION = :unsupported_eval
+
     sig { returns(SpecStore) }
     attr_accessor :spec_store
 
@@ -31,20 +30,16 @@ module Statsig
 
     sig do
       params(
-        network: Network,
+        store: SpecStore,
         options: StatsigOptions,
-        error_callback: T.any(Method, Proc, NilClass),
-        diagnostics: Diagnostics,
-        error_boundary: ErrorBoundary,
-        logger: StatsigLogger,
         persistent_storage_utils: UserPersistentStorageUtils,
       ).void
     end
-    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, persistent_storage_utils)
-      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics, error_boundary, logger)
+    def initialize(store, options, persistent_storage_utils)
       UAParser.initialize_async
       CountryLookup.initialize_async
 
+      @spec_store = store
       @gate_overrides = {}
       @config_overrides = {}
       @options = options
@@ -122,7 +117,7 @@ module Statsig
           @persistent_storage_utils.add_evaluation_to_user_persisted_values(user_persisted_values, config_name, evaluation)
           @persistent_storage_utils.save_to_storage(user, config['idType'], user_persisted_values)
         end
-      # Otherwise, remove from persisted storage
+        # Otherwise, remove from persisted storage
       else
         @persistent_storage_utils.remove_experiment_from_storage(user, config['idType'], config_name)
         evaluation = eval_spec(user, config)
@@ -143,6 +138,26 @@ module Statsig
       eval_spec(user, @spec_store.get_layer(layer_name))
     end
 
+    def list_gates
+      @spec_store.gates.map { |name, _| name }
+    end
+
+    def list_configs
+      @spec_store.configs.map { |name, config| name if config['entity'] == 'dynamic_config' }.compact
+    end
+
+    def list_experiments
+      @spec_store.configs.map { |name, config| name if config['entity'] == 'experiment' }.compact
+    end
+
+    def list_autotunes
+      @spec_store.configs.map { |name, config| name if config['entity'] == 'autotune' }.compact
+    end
+
+    def list_layers
+      @spec_store.layers.map { |name, _| name }
+    end
+
     def get_client_initialize_response(user, hash, client_sdk_key)
       if @spec_store.is_ready_for_checks == false
         return nil
@@ -204,7 +219,21 @@ module Statsig
         until i >= config['rules'].length do
           rule = config['rules'][i]
           result = eval_rule(user, rule)
-          return $fetch_from_server if result.to_s == $fetch_from_server
+          return Statsig::ConfigResult.new(
+            config['name'],
+            false,
+            config['defaultValue'],
+            '',
+            exposures,
+            evaluation_details: EvaluationDetails.new(
+              @spec_store.last_config_sync_time,
+              @spec_store.initial_config_sync_time,
+              EvaluationReason::UNSUPPORTED,
+            ),
+            group_name: nil,
+            id_type: config['idType'],
+            target_app_ids: config['targetAppIDs']
+          ) if result == UNSUPPORTED_EVALUATION
           exposures = exposures + result.secondary_exposures
           if result.gate_value
 
@@ -226,7 +255,8 @@ module Statsig
               ),
               is_experiment_group: result.is_experiment_group,
               group_name: result.group_name,
-              id_type: config['idType']
+              id_type: config['idType'],
+              target_app_ids: config['targetAppIDs']
             )
           end
 
@@ -248,7 +278,8 @@ module Statsig
           @spec_store.init_reason
         ),
         group_name: nil,
-        id_type: config['idType']
+        id_type: config['idType'],
+        target_app_ids: config['targetAppIDs']
       )
     end
 
@@ -260,8 +291,8 @@ module Statsig
       i = 0
       until i >= rule['conditions'].length do
         result = eval_condition(user, rule['conditions'][i])
-        if result.to_s == $fetch_from_server
-          return $fetch_from_server
+        if result == UNSUPPORTED_EVALUATION
+          return UNSUPPORTED_EVALUATION
         end
 
         if result.is_a?(Hash)
@@ -294,7 +325,7 @@ module Statsig
       return nil unless (config = @spec_store.get_config(delegate))
 
       delegated_result = self.eval_spec(user, config)
-      return $fetch_from_server if delegated_result.to_s == $fetch_from_server
+      return UNSUPPORTED_EVALUATION if delegated_result == UNSUPPORTED_EVALUATION
 
       delegated_result.name = name
       delegated_result.config_delegate = delegate
@@ -314,7 +345,7 @@ module Statsig
       additional_values = Hash.new unless additional_values.is_a? Hash
       id_type = condition['idType']
 
-      return $fetch_from_server unless type.is_a? String
+      return UNSUPPORTED_EVALUATION unless type.is_a? String
       type = type.downcase
 
       case type
@@ -322,7 +353,7 @@ module Statsig
         return true
       when 'fail_gate', 'pass_gate'
         other_gate_result = check_gate(user, target)
-        return $fetch_from_server if other_gate_result.to_s == $fetch_from_server
+        return UNSUPPORTED_EVALUATION if other_gate_result == UNSUPPORTED_EVALUATION
 
         gate_value = other_gate_result&.gate_value == true
         new_exposure = {
@@ -337,10 +368,8 @@ module Statsig
         }
       when 'ip_based'
         value = get_value_from_user(user, field) || get_value_from_ip(user, field)
-        return $fetch_from_server if value.to_s == $fetch_from_server
       when 'ua_based'
         value = get_value_from_user(user, field) || get_value_from_ua(user, field)
-        return $fetch_from_server if value.to_s == $fetch_from_server
       when 'user_field'
         value = get_value_from_user(user, field)
       when 'environment_field'
@@ -359,10 +388,10 @@ module Statsig
       when 'unit_id'
         value = user.get_unit_id(id_type)
       else
-        return $fetch_from_server
+        return UNSUPPORTED_EVALUATION
       end
 
-      return $fetch_from_server if value.to_s == $fetch_from_server || !operator.is_a?(String)
+      return UNSUPPORTED_EVALUATION if !operator.is_a?(String)
       operator = operator.downcase
 
       case operator
@@ -444,7 +473,7 @@ module Statsig
           return false
         end
       else
-        return $fetch_from_server
+        return UNSUPPORTED_EVALUATION
       end
     end
 

data/lib/feature_gate.rb

@@ -0,0 +1,70 @@
+# typed: false
+
+require 'sorbet-runtime'
+
+class FeatureGate
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_accessor :name
+
+  sig { returns(T::Boolean) }
+  attr_accessor :value
+
+  sig { returns(String) }
+  attr_accessor :rule_id
+
+  sig { returns(T.nilable(String)) }
+  attr_accessor :group_name
+
+  sig { returns(String) }
+  attr_accessor :id_type
+
+  sig { returns(T.nilable(Statsig::EvaluationDetails)) }
+  attr_accessor :evaluation_details
+
+  sig { returns(T.nilable(T::Array[String])) }
+  attr_accessor :target_app_ids
+
+  sig do
+    params(
+      name: String,
+      value: T::Boolean,
+      rule_id: String,
+      group_name: T.nilable(String),
+      id_type: String,
+      evaluation_details: T.nilable(Statsig::EvaluationDetails),
+      target_app_ids: T.nilable(T::Array[String])
+    ).void
+  end
+  def initialize(
+    name,
+    value: false,
+    rule_id: '',
+    group_name: nil,
+    id_type: '',
+    evaluation_details: nil,
+    target_app_ids: nil
+  )
+    @name = name
+    @value = value
+    @rule_id = rule_id
+    @group_name = group_name
+    @id_type = id_type
+    @evaluation_details = evaluation_details
+    @target_app_ids = target_app_ids
+  end
+
+  sig { params(res: Statsig::ConfigResult).returns(FeatureGate) }
+  def self.from_config_result(res)
+    new(
+      res.name,
+      value: res.gate_value,
+      rule_id: res.rule_id,
+      group_name: res.group_name,
+      id_type: res.id_type,
+      evaluation_details: res.evaluation_details,
+      target_app_ids: res.target_app_ids
+    )
+  end
+end

data/lib/network.rb

@@ -42,6 +42,7 @@ module Statsig
             'Content-Type' => 'application/json; charset=UTF-8',
             'STATSIG-SDK-TYPE' => meta['sdkType'],
             'STATSIG-SDK-VERSION' => meta['sdkVersion'],
+            'STATSIG-SDK-LANGUAGE-VERSION' => meta['languageVersion'],
             'Accept-Encoding' => 'gzip'
           }
         ).accept(:json)
@@ -131,26 +132,6 @@ module Statsig
       request(method, endpoint, body, retries - 1, backoff * @backoff_multiplier)
     end
 
-    def check_gate(user, gate_name)
-      request_body = JSON.generate({ 'user' => user&.serialize(false), 'gateName' => gate_name })
-      response, = post('check_gate', request_body)
-      return JSON.parse(response.body) unless response.nil?
-
-      false
-    rescue StandardError
-      false
-    end
-
-    def get_config(user, dynamic_config_name)
-      request_body = JSON.generate({ 'user' => user&.serialize(false), 'configName' => dynamic_config_name })
-      response, = post('get_config', request_body)
-      return JSON.parse(response.body) unless response.nil?
-
-      nil
-    rescue StandardError
-      nil
-    end
-
     def post_logs(events)
       json_body = JSON.generate({ 'events' => events, 'statsigMetadata' => Statsig.get_statsig_metadata })
       post('log_event', json_body, @post_logs_retry_limit)

data/lib/spec_store.rb

@@ -13,7 +13,7 @@ module Statsig
     attr_accessor :initial_config_sync_time
     attr_accessor :init_reason
 
-    def initialize(network, options, error_callback, diagnostics, error_boundary, logger)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -35,6 +35,7 @@ module Statsig
       @diagnostics = diagnostics
       @error_boundary = error_boundary
       @logger = logger
+      @secret_key = secret_key
 
       @id_list_thread_pool = Concurrent::FixedThreadPool.new(
         options.idlist_threadpool_size,
@@ -47,7 +48,7 @@ module Statsig
         if !@options.data_store.nil?
           puts 'data_store gets priority over bootstrap_values. bootstrap_values will be ignored'
         else
-          tracker = @diagnostics.track('bootstrap', 'process')
+          tracker = @diagnostics.track('initialize','bootstrap', 'process')
           begin
             if process_specs(options.bootstrap_values)
               @init_reason = EvaluationReason::BOOTSTRAP
@@ -62,18 +63,18 @@ module Statsig
 
       unless @options.data_store.nil?
         @options.data_store.init
-        load_config_specs_from_storage_adapter
+        load_config_specs_from_storage_adapter('initialize')
       end
 
       if @init_reason == EvaluationReason::UNINITIALIZED
-        download_config_specs
+        download_config_specs('initialize')
       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
+        get_id_lists_from_adapter('initialize')
       else
-        get_id_lists_from_network
+        get_id_lists_from_network('initialize')
       end
 
       @config_sync_thread = spawn_sync_config_specs_thread
@@ -121,6 +122,18 @@ module Statsig
       @specs[:layers][layer_name]
     end
 
+    def gates
+      @specs[:gates]
+    end
+
+    def configs
+      @specs[:configs]
+    end
+
+    def layers
+      @specs[:layers]
+    end
+
     def get_id_list(list_name)
       @specs[:id_lists][list_name]
     end
@@ -159,41 +172,39 @@ module Statsig
     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
+        load_config_specs_from_storage_adapter('config_sync')
       else
-        download_config_specs
+        download_config_specs('config_sync')
       end
-      @logger.log_diagnostics_event(@diagnostics)
+      @logger.log_diagnostics_event(@diagnostics, 'config_sync')
     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
+        get_id_lists_from_adapter('config_sync')
       else
-        get_id_lists_from_network
+        get_id_lists_from_network('config_sync')
       end
-      @logger.log_diagnostics_event(@diagnostics)
+      @logger.log_diagnostics_event(@diagnostics, 'config_sync')
     end
 
     private
 
-    def load_config_specs_from_storage_adapter
-      tracker = @diagnostics.track('data_store_config_specs', 'fetch')
+    def load_config_specs_from_storage_adapter(context)
+      tracker = @diagnostics.track(context, 'data_store_config_specs', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::CONFIG_SPECS_KEY)
       tracker.end(success: true)
       return if cached_values.nil?
 
-      tracker = @diagnostics.track('data_store_config_specs', 'process')
+      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)
     rescue StandardError
       # Fallback to network
       tracker.end(success: false)
-      download_config_specs
+      download_config_specs(context)
     end
 
     def save_config_specs_to_storage_adapter(specs_string)
@@ -233,8 +244,8 @@ module Statsig
       end
     end
 
-    def download_config_specs
-      tracker = @diagnostics.track('download_config_specs', 'network_request')
+    def download_config_specs(context)
+      tracker = @diagnostics.track(context, 'download_config_specs', 'network_request')
 
       error = nil
       begin
@@ -247,8 +258,7 @@ module Statsig
 
         if e.nil?
           unless response.nil?
-            tracker = @diagnostics.track('download_config_specs', 'process')
-
+            tracker = @diagnostics.track(context, 'download_config_specs', 'process')
             if process_specs(response.body.to_s)
               @init_reason = EvaluationReason::NETWORK
             end
@@ -276,6 +286,12 @@ module Statsig
       specs_json = JSON.parse(specs_string)
       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
+
       @last_config_sync_time = specs_json['time'] || @last_config_sync_time
       return false unless specs_json['has_updates'] == true &&
         !specs_json['feature_gates'].nil? &&
@@ -311,18 +327,18 @@ module Statsig
       true
     end
 
-    def get_id_lists_from_adapter
-      tracker = @diagnostics.track('data_store_id_lists', 'fetch')
+    def get_id_lists_from_adapter(context)
+      tracker = @diagnostics.track(context, 'data_store_id_lists', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::ID_LISTS_KEY)
       return if cached_values.nil?
 
       tracker.end(success: true)
       id_lists = JSON.parse(cached_values)
-      process_id_lists(id_lists, from_adapter: true)
+      process_id_lists(id_lists, context, from_adapter: true)
     rescue StandardError
       # Fallback to network
       tracker.end(success: false)
-      get_id_lists_from_network
+      get_id_lists_from_network(context)
     end
 
     def save_id_lists_to_adapter(id_lists_raw_json)
@@ -332,8 +348,8 @@ module Statsig
       @options.data_store.set(Interfaces::IDataStore::ID_LISTS_KEY, id_lists_raw_json)
     end
 
-    def get_id_lists_from_network
-      tracker = @diagnostics.track('get_id_list_sources', 'network_request')
+    def get_id_lists_from_network(context)
+      tracker = @diagnostics.track(context, 'get_id_list_sources', 'network_request')
       response, e = @network.post('get_id_lists', JSON.generate({ 'statsigMetadata' => Statsig.get_statsig_metadata }))
       code = response&.status.to_i
       if e.is_a? NetworkError
@@ -347,21 +363,21 @@ module Statsig
 
       begin
         server_id_lists = JSON.parse(response)
-        process_id_lists(server_id_lists)
+        process_id_lists(server_id_lists, context)
         save_id_lists_to_adapter(response.body.to_s)
       rescue
         # Ignored, will try again
       end
     end
 
-    def process_id_lists(new_id_lists, from_adapter: false)
+    def process_id_lists(new_id_lists, context, 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 = []
 
-      tracker = @diagnostics.track(
+      tracker = @diagnostics.track(context,
         from_adapter ? 'data_store_id_lists' : 'get_id_list_sources',
         'process',
         { idListCount: new_id_lists.length }
@@ -411,9 +427,9 @@ module Statsig
 
         tasks << Concurrent::Promise.execute(:executor => @id_list_thread_pool) do
           if from_adapter
-            get_single_id_list_from_adapter(local_list)
+            get_single_id_list_from_adapter(local_list, context)
           else
-            download_single_id_list(local_list)
+            download_single_id_list(local_list, context)
           end
         end
       end
@@ -422,12 +438,12 @@ module Statsig
       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 })
+    def get_single_id_list_from_adapter(list, context)
+      tracker = @diagnostics.track(context, '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, from_adapter: true)
+      process_single_id_list(list, context, content, from_adapter: true)
     rescue StandardError
       tracker.end(success: false)
       nil
@@ -439,10 +455,10 @@ module Statsig
       @options.data_store.set("#{Interfaces::IDataStore::ID_LISTS_KEY}::#{name}", content)
     end
 
-    def download_single_id_list(list)
+    def download_single_id_list(list, context)
       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 })
+      tracker = @diagnostics.track(context, 'get_id_list', 'network_request', { url: list.url })
       begin
         res = http.get(list.url)
         tracker.end(statusCode: res.status.code, success: res.status.success?)
@@ -450,7 +466,7 @@ module Statsig
         content_length = Integer(res['content-length'])
         nil if content_length.nil? || content_length <= 0
         content = res.body.to_s
-        success = process_single_id_list(list, content, content_length)
+        success = process_single_id_list(list, context, content, content_length)
         save_single_id_list_to_adapter(list.name, content) unless success.nil? || !success
       rescue
         tracker.end(success: false)
@@ -458,10 +474,10 @@ module Statsig
       end
     end
 
-    def process_single_id_list(list, content, content_length = nil, from_adapter: false)
+    def process_single_id_list(list, context, 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 })
+        tracker = @diagnostics.track(context, 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)
@@ -495,4 +511,4 @@ module Statsig
     end
 
   end
-end
+end

data/lib/statsig.rb

@@ -26,6 +26,23 @@ module Statsig
     @shared_instance = StatsigDriver.new(secret_key, options, error_callback)
   end
 
+  class GetGateOptions < T::Struct
+    prop :disable_log_exposure, T::Boolean, default: false
+    prop :skip_evaluation, T::Boolean, default: false
+  end
+
+  sig { params(user: StatsigUser, gate_name: String, options: GetGateOptions).returns(FeatureGate) }
+  ##
+  # Gets the gate, evaluated against the given user. An exposure event will automatically be logged for the gate.
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param gate_name The name of the gate being checked
+  # @param options Additional options for evaluating the gate
+  def self.get_gate(user, gate_name, options = GetGateOptions.new)
+    ensure_initialized
+    @shared_instance&.get_gate(user, gate_name, options)
+  end
+
   class CheckGateOptions < T::Struct
     prop :disable_log_exposure, T::Boolean, default: false
   end
@@ -212,6 +229,51 @@ module Statsig
     @shared_instance&.manually_sync_idlists
   end
 
+  sig { returns(T::Array[String]) }
+  ##
+  # Returns a list of all gate names
+  #
+  def self.list_gates
+    ensure_initialized
+    @shared_instance&.list_gates
+  end
+
+  sig { returns(T::Array[String]) }
+  ##
+  # Returns a list of all config names
+  #
+  def self.list_configs
+    ensure_initialized
+    @shared_instance&.list_configs
+  end
+
+  sig { returns(T::Array[String]) }
+  ##
+  # Returns a list of all experiment names
+  #
+  def self.list_experiments
+    ensure_initialized
+    @shared_instance&.list_experiments
+  end
+
+  sig { returns(T::Array[String]) }
+  ##
+  # Returns a list of all autotune names
+  #
+  def self.list_autotunes
+    ensure_initialized
+    @shared_instance&.list_autotunes
+  end
+
+  sig { returns(T::Array[String]) }
+  ##
+  # Returns a list of all layer names
+  #
+  def self.list_layers
+    ensure_initialized
+    @shared_instance&.list_layers
+  end
+
   sig { void }
   ##
   # Stops all Statsig activity and flushes any pending events.
@@ -265,7 +327,8 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.29.0',
+      'sdkVersion' => '1.31.0',
+      'languageVersion' => RUBY_VERSION
     }
   end
 

data/lib/statsig_driver.rb

@@ -10,6 +10,7 @@ require 'statsig_options'
 require 'statsig_user'
 require 'spec_store'
 require 'dynamic_config'
+require 'feature_gate'
 require 'error_boundary'
 require 'layer'
 require 'sorbet-runtime'
@@ -30,42 +31,65 @@ class StatsigDriver
 
     @err_boundary = Statsig::ErrorBoundary.new(secret_key)
     @err_boundary.capture(task: lambda {
-      @diagnostics = Statsig::Diagnostics.new('initialize')
-      tracker = @diagnostics.track('overall')
+      @diagnostics = Statsig::Diagnostics.new()
+      tracker = @diagnostics.track('initialize', 'overall')
       @options = options || StatsigOptions.new
       @shutdown = false
       @secret_key = secret_key
       @net = Statsig::Network.new(secret_key, @options)
       @logger = Statsig::StatsigLogger.new(@net, @options, @err_boundary)
       @persistent_storage_utils = Statsig::UserPersistentStorageUtils.new(@options)
-      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger, @persistent_storage_utils)
+      @store = Statsig::SpecStore.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger, secret_key)
+      @evaluator = Statsig::Evaluator.new(@store, @options, @persistent_storage_utils)
       tracker.end(success: true)
 
-      @logger.log_diagnostics_event(@diagnostics)
+      @logger.log_diagnostics_event(@diagnostics, 'initialize')
     }, caller: __method__.to_s)
   end
 
+  sig do
+    params(
+      user: StatsigUser,
+      gate_name: String,
+      disable_log_exposure: T::Boolean,
+      skip_evaluation: T::Boolean
+    ).returns(FeatureGate)
+  end
+  def get_gate_impl(user, gate_name, disable_log_exposure: false, skip_evaluation: false)
+    if skip_evaluation
+      gate = @store.get_gate(gate_name)
+      return FeatureGate.new(gate_name) if gate.nil?
+      return FeatureGate.new(gate['name'], target_app_ids: gate['targetAppIDs'])
+    end
+    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
+
+    unless disable_log_exposure
+      @logger.log_gate_exposure(
+        user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
+      )
+    end
+    FeatureGate.from_config_result(res)
+  end
+
+  sig { params(user: StatsigUser, gate_name: String, options: Statsig::GetGateOptions).returns(FeatureGate) }
+  def get_gate(user, gate_name, options = Statsig::GetGateOptions.new)
+    @err_boundary.capture(task: lambda {
+      run_with_diagnostics(task: lambda {
+        get_gate_impl(user, gate_name, disable_log_exposure: options.disable_log_exposure, skip_evaluation: options.skip_evaluation)
+      }, caller: __method__.to_s)
+    }, recover: -> { false }, caller: __method__.to_s)
+  end
+
   sig { params(user: StatsigUser, gate_name: String, options: Statsig::CheckGateOptions).returns(T::Boolean) }
   def check_gate(user, gate_name, options = Statsig::CheckGateOptions.new)
     @err_boundary.capture(task: lambda {
       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
-
-        if res == $fetch_from_server
-          res = check_gate_fallback(user, gate_name)
-          # exposure logged by the server
-        else
-          if !options.disable_log_exposure
-            @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
-          end
-        end
-
-        res.gate_value
+        get_gate_impl(user, gate_name, disable_log_exposure: options.disable_log_exposure).value
       }, caller: __method__.to_s)
     }, recover: -> { false }, caller: __method__.to_s)
   end
@@ -129,14 +153,6 @@ class StatsigDriver
           res = Statsig::ConfigResult.new(layer_name)
         end
 
-        if res == $fetch_from_server
-          if res.config_delegate.nil?
-            return Layer.new(layer_name)
-          end
-          res = get_config_fallback(user, res.config_delegate)
-          # exposure logged by the server
-        end
-
         exposure_log_func = !options.disable_log_exposure ? lambda { |layer, parameter_name|
           @logger.log_layer_exposure(user, layer, parameter_name, res)
         } : nil
@@ -184,6 +200,41 @@ class StatsigDriver
     }, caller: __method__.to_s)
   end
 
+  sig { returns(T::Array[String]) }
+  def list_gates
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_gates
+    }, caller: __method__.to_s)
+  end
+
+  sig { returns(T::Array[String]) }
+  def list_configs
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_configs
+    }, caller: __method__.to_s)
+  end
+
+  sig { returns(T::Array[String]) }
+  def list_experiments
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_experiments
+    }, caller: __method__.to_s)
+  end
+
+  sig { returns(T::Array[String]) }
+  def list_autotunes
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_autotunes
+    }, caller: __method__.to_s)
+  end
+
+  sig { returns(T::Array[String]) }
+  def list_layers
+    @err_boundary.capture(task: lambda {
+      @evaluator.list_layers
+    }, caller: __method__.to_s)
+  end
+
   def shutdown
     @err_boundary.capture(task: lambda {
       @shutdown = true
@@ -231,8 +282,8 @@ class StatsigDriver
   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)
+      diagnostics = Statsig::Diagnostics.new()
+      tracker = diagnostics.track('api_call', caller)
     end
     begin
       res = task.call
@@ -241,7 +292,7 @@ class StatsigDriver
       tracker&.end(success: false)
       raise e
     ensure
-      @logger.log_diagnostics_event(diagnostics)
+      @logger.log_diagnostics_event(diagnostics, 'api_call')
     end
     return res
   end
@@ -272,13 +323,8 @@ class StatsigDriver
       res = Statsig::ConfigResult.new(config_name)
     end
 
-    if res == $fetch_from_server
-      res = get_config_fallback(user, config_name)
-      # exposure logged by the server
-    else
-      if !disable_log_exposure
-        @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
-      end
+    unless disable_log_exposure
+      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
     end
 
     DynamicConfig.new(res.name, res.json_value, res.rule_id, res.group_name, res.id_type, res.evaluation_details)
@@ -308,34 +354,4 @@ class StatsigDriver
       puts 'SDK has been shutdown.  Updates in the Statsig Console will no longer reflect.'
     end
   end
-
-  def check_gate_fallback(user, gate_name)
-    network_result = @net.check_gate(user, gate_name)
-    if network_result.nil?
-      config_result = Statsig::ConfigResult.new(gate_name)
-      return config_result
-    end
-
-    Statsig::ConfigResult.new(
-      network_result['name'],
-      network_result['value'],
-      {},
-      network_result['rule_id'],
-    )
-  end
-
-  def get_config_fallback(user, dynamic_config_name)
-    network_result = @net.get_config(user, dynamic_config_name)
-    if network_result.nil?
-      config_result = Statsig::ConfigResult.new(dynamic_config_name)
-      return config_result
-    end
-
-    Statsig::ConfigResult.new(
-      network_result['name'],
-      false,
-      network_result['value'],
-      network_result['rule_id'],
-    )
-  end
 end

data/lib/statsig_errors.rb

@@ -9,4 +9,10 @@ module Statsig
   class ValueError < StandardError
 
   end
+
+  class InvalidSDKKeyResponse < StandardError
+    def initialize(msg="Incorrect SDK Key used to generate response.")
+      super
+    end
+  end
 end

data/lib/statsig_logger.rb

@@ -98,18 +98,21 @@ module Statsig
       log_event(event)
     end
 
-    def log_diagnostics_event(diagnostics, user = nil)
-      return if @options.disable_diagnostics_logging
+    def log_diagnostics_event(diagnostics, context, user = nil)
       return if diagnostics.nil?
+      if @options.disable_diagnostics_logging
+        diagnostics.clear_markers(context)
+        return
+      end
 
       event = StatsigEvent.new($diagnostics_event)
       event.user = user
-      serialized = diagnostics.serialize_with_sampling
+      serialized = diagnostics.serialize_with_sampling(context)
+      diagnostics.clear_markers(context)
       return if serialized[:markers].empty?
 
       event.metadata = serialized
       log_event(event)
-      diagnostics.clear_markers
     end
 
     def periodic_flush
@@ -204,4 +207,4 @@ module Statsig
       true
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.29.0
+  version: 1.31.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2024-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -330,6 +330,7 @@ files:
 - lib/evaluation_details.rb
 - lib/evaluation_helpers.rb
 - lib/evaluator.rb
+- lib/feature_gate.rb
 - lib/hash_utils.rb
 - lib/id_list.rb
 - lib/interfaces/data_store.rb