statsig 1.30.0 → 1.32.0

data/lib/spec_store.rb

@@ -1,17 +1,24 @@
-# typed: false
 require 'net/http'
 require 'uri'
 require 'evaluation_details'
 require 'id_list'
 require 'concurrent-ruby'
 require 'hash_utils'
+require 'api_config'
 
 module Statsig
   class SpecStore
-
     attr_accessor :last_config_sync_time
     attr_accessor :initial_config_sync_time
     attr_accessor :init_reason
+    attr_accessor :gates
+    attr_accessor :configs
+    attr_accessor :layers
+    attr_accessor :id_lists
+    attr_accessor :experiment_to_layer
+    attr_accessor :sdk_keys_to_app_ids
+    attr_accessor :hashed_sdk_keys_to_app_ids
+    attr_accessor :unsupported_configs
 
     def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key)
       @init_reason = EvaluationReason::UNINITIALIZED
@@ -23,37 +30,36 @@ module Statsig
       @rulesets_sync_interval = options.rulesets_sync_interval
       @id_lists_sync_interval = options.idlists_sync_interval
       @rules_updated_callback = options.rules_updated_callback
-      @specs = {
-        :gates => {},
-        :configs => {},
-        :layers => {},
-        :id_lists => {},
-        :experiment_to_layer => {},
-        :sdk_keys_to_app_ids => {},
-        :hashed_sdk_keys_to_app_ids => {}
-      }
+      @gates = {}
+      @configs = {}
+      @layers = {}
+      @id_lists = {}
+      @experiment_to_layer = {}
+      @sdk_keys_to_app_ids = {}
+      @hashed_sdk_keys_to_app_ids = {}
       @diagnostics = diagnostics
       @error_boundary = error_boundary
       @logger = logger
       @secret_key = secret_key
+      @unsupported_configs = Set.new
 
       @id_list_thread_pool = Concurrent::FixedThreadPool.new(
         options.idlist_threadpool_size,
         name: 'statsig-idlist',
         max_queue: 100,
-        fallback_policy: :discard,
+        fallback_policy: :discard
       )
 
       unless @options.bootstrap_values.nil?
         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
             end
-          rescue
+          rescue StandardError
             puts 'the provided bootstrapValues is not a valid JSON string'
           ensure
             tracker.end(success: @init_reason == EvaluationReason::BOOTSTRAP)
@@ -63,18 +69,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
@@ -96,70 +102,61 @@ module Statsig
     end
 
     def has_gate?(gate_name)
-      @specs[:gates].key?(gate_name)
+      @gates.key?(gate_name)
     end
 
     def has_config?(config_name)
-      @specs[:configs].key?(config_name)
+      @configs.key?(config_name)
     end
 
     def has_layer?(layer_name)
-      @specs[:layers].key?(layer_name)
+      @layers.key?(layer_name)
     end
 
     def get_gate(gate_name)
       return nil unless has_gate?(gate_name)
-      @specs[:gates][gate_name]
+
+      @gates[gate_name]
     end
 
     def get_config(config_name)
       return nil unless has_config?(config_name)
-      @specs[:configs][config_name]
+
+      @configs[config_name]
     end
 
     def get_layer(layer_name)
       return nil unless has_layer?(layer_name)
-      @specs[:layers][layer_name]
-    end
 
-    def gates
-      @specs[:gates]
-    end
-
-    def configs
-      @specs[:configs]
-    end
-
-    def layers
-      @specs[:layers]
+      @layers[layer_name]
     end
 
     def get_id_list(list_name)
-      @specs[:id_lists][list_name]
+      @id_lists[list_name]
     end
 
     def has_sdk_key?(sdk_key)
-      @specs[:sdk_keys_to_app_ids].key?(sdk_key)
+      @sdk_keys_to_app_ids.key?(sdk_key)
     end
 
     def has_hashed_sdk_key?(hashed_sdk_key)
-      @specs[:hashed_sdk_keys_to_app_ids].key?(hashed_sdk_key)
+      @hashed_sdk_keys_to_app_ids.key?(hashed_sdk_key)
     end
 
     def get_app_id_for_sdk_key(sdk_key)
       if sdk_key.nil?
         return nil
       end
-      hashed_sdk_key = Statsig::HashUtils.djb2(sdk_key)
+
+      hashed_sdk_key = Statsig::HashUtils.djb2(sdk_key).to_sym
       if has_hashed_sdk_key?(hashed_sdk_key)
-        return @specs[:hashed_sdk_keys_to_app_ids][hashed_sdk_key]
+        return @hashed_sdk_keys_to_app_ids[hashed_sdk_key]
       end
-      return nil unless has_sdk_key?(sdk_key)
-      @specs[:sdk_keys_to_app_ids][sdk_key]
-    end
 
-    def get_raw_specs
-      @specs
+      key = sdk_key.to_sym
+      return nil unless has_sdk_key?(key)
+
+      @sdk_keys_to_app_ids[key]
     end
 
     def maybe_restart_background_threads
@@ -172,47 +169,46 @@ 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)
       if @options.data_store.nil?
         return
       end
+
       @options.data_store.set(Interfaces::IDataStore::CONFIG_SPECS_KEY, specs_string)
     end
 
@@ -246,8 +242,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
@@ -260,14 +256,16 @@ 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
             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?
+            unless response.body.nil? or @rules_updated_callback.nil?
+              @rules_updated_callback.call(response.body.to_s,
+                                           @last_config_sync_time)
+            end
           end
 
           nil
@@ -286,43 +284,41 @@ module Statsig
         return false
       end
 
-      specs_json = JSON.parse(specs_string)
+      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']
+      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? &&
-        !specs_json['dynamic_configs'].nil? &&
-        !specs_json['layer_configs'].nil?
+      @last_config_sync_time = specs_json[:time] || @last_config_sync_time
+      return false unless specs_json[:has_updates] == true &&
+                          !specs_json[:feature_gates].nil? &&
+                          !specs_json[:dynamic_configs].nil? &&
+                          !specs_json[:layer_configs].nil?
 
-      new_gates = {}
-      new_configs = {}
-      new_layers = {}
-      new_exp_to_layer = {}
+      @unsupported_configs.clear()
+      new_gates = process_configs(specs_json[:feature_gates])
+      new_configs = process_configs(specs_json[:dynamic_configs])
+      new_layers = process_configs(specs_json[:layer_configs])
 
-      specs_json['feature_gates'].each { |gate| new_gates[gate['name']] = gate }
-      specs_json['dynamic_configs'].each { |config| new_configs[config['name']] = config }
-      specs_json['layer_configs'].each { |layer| new_layers[layer['name']] = layer }
-      specs_json['diagnostics']&.each { |key, value| @diagnostics.sample_rates[key] = value }
+      new_exp_to_layer = {}
+      specs_json[:diagnostics]&.each { |key, value| @diagnostics.sample_rates[key.to_s] = value }
 
-      if specs_json['layers'].is_a?(Hash)
-        specs_json['layers'].each { |layer_name, experiments|
+      if specs_json[:layers].is_a?(Hash)
+        specs_json[:layers].each do |layer_name, experiments|
           experiments.each { |experiment_name| new_exp_to_layer[experiment_name] = layer_name }
-        }
+        end
       end
 
-      @specs[:gates] = new_gates
-      @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[:hashed_sdk_keys_to_app_ids] = specs_json['hashed_sdk_keys_to_app_ids'] || {}
+      @gates = new_gates
+      @configs = new_configs
+      @layers = new_layers
+      @experiment_to_layer = new_exp_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] || {}
 
       unless from_adapter
         save_config_specs_to_storage_adapter(specs_string)
@@ -330,29 +326,41 @@ module Statsig
       true
     end
 
-    def get_id_lists_from_adapter
-      tracker = @diagnostics.track('data_store_id_lists', 'fetch')
+    def process_configs(configs)
+      configs.each_with_object({}) do |config, new_configs|
+        begin
+          new_configs[config[:name]] = APIConfig.from_json(config)
+        rescue UnsupportedConfigException => e
+          @unsupported_configs.add(config[:name])
+          nil
+        end
+      end
+    end
+
+    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)
       if @options.data_store.nil?
         return
       end
+
       @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
@@ -360,27 +368,28 @@ module Statsig
       end
       success = e.nil? && !response.nil?
       tracker.end(statusCode: code, success: success, sdkRegion: response&.headers&.[]('X-Statsig-Region'))
-      if !success
+      unless success
         return
       end
 
       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
+      rescue StandardError
         # Ignored, will try again
       end
     end
 
-    def process_id_lists(new_id_lists, from_adapter: false)
-      local_id_lists = @specs[:id_lists]
+    def process_id_lists(new_id_lists, context, from_adapter: false)
+      local_id_lists = @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 }
@@ -392,7 +401,7 @@ module Statsig
       end
 
       delete_lists = []
-      local_id_lists.each do |list_name, list|
+      local_id_lists.each do |list_name, _list|
         unless new_id_lists.key? list_name
           delete_lists.push list_name
         end
@@ -428,11 +437,11 @@ module Statsig
           next
         end
 
-        tasks << Concurrent::Promise.execute(:executor => @id_list_thread_pool) do
+        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
@@ -441,12 +450,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
@@ -458,10 +467,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?)
@@ -469,20 +478,20 @@ 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
+      rescue StandardError
         tracker.end(success: false)
         nil
       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)
+          @id_lists.delete(list.name)
           tracker.end(success: false)
           return false
         end
@@ -491,6 +500,7 @@ module Statsig
         lines.each do |li|
           line = li.strip
           next if line.length <= 1
+
           op = line[0]
           id = line[1..line.length]
           if op == '+'
@@ -507,11 +517,10 @@ module Statsig
                     end
         tracker.end(success: true)
         return true
-      rescue
+      rescue StandardError
         tracker.end(success: false)
         return false
       end
     end
-
   end
-end
+end