statsig 1.25.2 → 1.30.0

data/lib/evaluator.rb

@@ -1,4 +1,6 @@
 # typed: false
+
+require 'sorbet-runtime'
 require 'config_result'
 require 'country_lookup'
 require 'digest'
@@ -9,21 +11,40 @@ require 'time'
 require 'ua_parser'
 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
+
+    sig { returns(SpecStore) }
     attr_accessor :spec_store
 
-    def initialize(network, options, error_callback, diagnostics)
-      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics)
+    sig { returns(StatsigOptions) }
+    attr_accessor :options
+
+    sig { returns(UserPersistentStorageUtils) }
+    attr_accessor :persistent_storage_utils
+
+    sig do
+      params(
+        store: SpecStore,
+        options: StatsigOptions,
+        persistent_storage_utils: UserPersistentStorageUtils,
+      ).void
+    end
+    def initialize(store, options, persistent_storage_utils)
       UAParser.initialize_async
       CountryLookup.initialize_async
 
+      @spec_store = store
       @gate_overrides = {}
       @config_overrides = {}
+      @options = options
+      @persistent_storage_utils = persistent_storage_utils
     end
 
     def maybe_restart_background_threads
@@ -52,7 +73,8 @@ module Statsig
       eval_spec(user, @spec_store.get_gate(gate_name))
     end
 
-    def get_config(user, config_name)
+    sig { params(user: StatsigUser, config_name: String, user_persisted_values: T.nilable(UserPersistedValues)).returns(ConfigResult) }
+    def get_config(user, config_name, user_persisted_values: nil)
       if @config_overrides.key?(config_name)
         id_type = @spec_store.has_config?(config_name) ? @spec_store.get_config(config_name)['idType'] : ''
         return Statsig::ConfigResult.new(
@@ -83,7 +105,26 @@ module Statsig
         )
       end
 
-      eval_spec(user, @spec_store.get_config(config_name))
+      config = @spec_store.get_config(config_name)
+
+      # If persisted values is provided and the experiment is active, return sticky values if exists.
+      if !user_persisted_values.nil? && config['isActive'] == true
+        sticky_result = Statsig::ConfigResult.from_user_persisted_values(config_name, user_persisted_values)
+        return sticky_result unless sticky_result.nil?
+
+        # If it doesn't exist, then save to persisted storage if the user was assigned to an experiment group.
+        evaluation = eval_spec(user, config)
+        if evaluation.is_experiment_group
+          @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
+      else
+        @persistent_storage_utils.remove_experiment_from_storage(user, config['idType'], config_name)
+        evaluation = eval_spec(user, config)
+      end
+
+      return evaluation
     end
 
     def get_layer(user, layer_name)
@@ -98,12 +139,32 @@ module Statsig
       eval_spec(user, @spec_store.get_layer(layer_name))
     end
 
-    def get_client_initialize_response(user)
+    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
       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 +184,8 @@ module Statsig
         "generator" => "statsig-ruby-sdk",
         "evaluated_keys" => evaluated_keys,
         "time" => 0,
+        "hash_used" => hash,
+        "user_hash" => user.to_hash_without_stable_id()
       }
     end
 
@@ -148,6 +211,7 @@ module Statsig
       @config_overrides[config] = value
     end
 
+    sig { params(user: StatsigUser, config: Hash).returns(ConfigResult) }
     def eval_spec(user, config)
       default_rule_id = 'default'
       exposures = []
@@ -178,7 +242,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
 
@@ -200,7 +265,8 @@ module Statsig
           @spec_store.init_reason
         ),
         group_name: nil,
-        id_type: config['idType']
+        id_type: config['idType'],
+        target_app_ids: config['targetAppIDs']
       )
     end
 
@@ -264,7 +330,7 @@ module Statsig
       operator = condition['operator']
       additional_values = condition['additionalValues']
       additional_values = Hash.new unless additional_values.is_a? Hash
-      idType = condition['idType']
+      id_type = condition['idType']
 
       return $fetch_from_server unless type.is_a? String
       type = type.downcase
@@ -302,14 +368,14 @@ module Statsig
       when 'user_bucket'
         begin
           salt = additional_values['salt']
-          unit_id = get_unit_id(user, idType) || ''
+          unit_id = user.get_unit_id(id_type) || ''
           # there are only 1000 user buckets as opposed to 10k for gate pass %
           value = compute_user_hash("#{salt}.#{unit_id}") % 1000
         rescue
           return false
         end
       when 'unit_id'
-        value = get_unit_id(user, idType)
+        value = user.get_unit_id(id_type)
       else
         return $fetch_from_server
       end
@@ -359,7 +425,7 @@ module Statsig
       when 'none_case_sensitive'
         return !EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
 
-        #string
+        # string
       when 'str_starts_with_any'
         return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.start_with?(b) })
       when 'str_ends_with_any'
@@ -468,7 +534,7 @@ module Statsig
     def eval_pass_percent(user, rule, config_salt)
       return false unless config_salt.is_a?(String) && !rule['passPercentage'].nil?
       begin
-        unit_id = get_unit_id(user, rule['idType']) || ''
+        unit_id = user.get_unit_id(rule['idType']) || ''
         rule_salt = rule['salt'] || rule['id'] || ''
         hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
         return (hash % 10000) < (rule['passPercentage'].to_f * 100)
@@ -477,14 +543,6 @@ module Statsig
       end
     end
 
-    def get_unit_id(user, id_type)
-      if id_type.is_a?(String) && id_type.downcase != 'userid'
-        return nil unless user&.custom_ids.is_a? Hash
-        return user.custom_ids[id_type] || user.custom_ids[id_type.downcase]
-      end
-      user.user_id
-    end
-
     def compute_user_hash(user_hash)
       Digest::SHA256.digest(user_hash).unpack('Q>')[0]
     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/hash_utils.rb

@@ -0,0 +1,32 @@
+require 'json'
+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.djb2ForHash(input_hash)
+      return djb2(input_hash.to_json)
+    end
+
+    def self.sha256(input_str)
+      return Digest::SHA256.base64digest(input_str)
+    end
+
+    def self.sortHash(input_hash)
+      dictionary = input_hash.clone.sort_by { |key| key }.to_h;
+      input_hash.each do |key, value|
+        if value.is_a?(Hash)
+          dictionary[key] = self.sortHash(value)
+        end
+      end
+      return dictionary
+    end
+  end
+end

data/lib/id_list.rb

@@ -19,7 +19,7 @@ module Statsig
     end
 
     def self.new_empty(json)
-      self.new(json)
+      new(json)
       @size = 0
     end
 

data/lib/interfaces/user_persistent_storage.rb

@@ -0,0 +1,12 @@
+# typed: true
+module Statsig
+  module Interfaces
+    class IUserPersistentStorage
+      def load(key)
+        nil
+      end
+
+      def save(key, data) end
+    end
+  end
+end

data/lib/layer.rb

@@ -17,11 +17,25 @@ class Layer
   sig { returns(String) }
   attr_accessor :rule_id
 
-  sig { params(name: String, value: T::Hash[String, T.untyped], rule_id: String, exposure_log_func: T.any(Method, Proc, NilClass)).void }
-  def initialize(name, value = {}, rule_id = '', exposure_log_func = nil)
+  sig { returns(String) }
+  attr_accessor :group_name
+
+  sig do
+    params(
+      name: String,
+      value: T::Hash[String, T.untyped],
+      rule_id: String,
+      group_name: T.nilable(String),
+      allocated_experiment: T.nilable(String),
+      exposure_log_func: T.any(Method, Proc, NilClass)
+    ).void
+  end
+  def initialize(name, value = {}, rule_id = '', group_name = nil, allocated_experiment = nil, exposure_log_func = nil)
     @name = name
     @value = value
     @rule_id = rule_id
+    @group_name = group_name
+    @allocated_experiment = allocated_experiment
     @exposure_log_func = exposure_log_func
   end
 
@@ -58,4 +72,4 @@ class Layer
 
     @value[index]
   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
@@ -22,7 +23,6 @@ module Statsig
     extend T::Sig
 
     sig { params(server_secret: String, options: StatsigOptions, backoff_mult: Integer).void }
-
     def initialize(server_secret, options, backoff_mult = 10)
       super()
       URIHelper.initialize(options)
@@ -33,29 +33,67 @@ 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.use(:auto_inflate).headers(
+          {
+            'STATSIG-API-KEY' => @server_secret,
+            'STATSIG-SERVER-SESSION-ID' => @session_id,
+            '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)
+        if @timeout
+          client = client.timeout(@timeout)
+        end
+
+        client
+      end
+    end
+
+    sig do
+      params(since_time: Integer)
+        .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)])
+    end
+    def download_config_specs(since_time)
+      get("download_config_specs/#{@server_secret}.json?sinceTime=#{since_time}")
+    end
+
+    class HttpMethod < T::Enum
+      enums do
+        GET = new
+        POST = new
+      end
+    end
+
+    sig do
+      params(endpoint: String, retries: Integer, backoff: Integer)
+        .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)])
+    end
+    def get(endpoint, retries = 0, backoff = 1)
+      request(HttpMethod::GET, endpoint, nil, retries, backoff)
     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(endpoint, body, retries = 0, backoff = 1)
+      request(HttpMethod::POST, endpoint, body, retries, backoff)
+    end
 
-    def post_helper(endpoint, body, retries = 0, backoff = 1)
+    sig do
+      params(method: HttpMethod, endpoint: String, body: T.nilable(String), retries: Integer, backoff: Integer)
+        .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)])
+    end
+    def request(method, 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 +104,59 @@ module Statsig
       end
       url = URIHelper.build_url(endpoint)
       begin
-        res = http.post(url, body: body)
+        res = @connection_pool.with do |conn|
+          request = conn.headers('STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s)
+          case method
+          when HttpMethod::GET
+            request.get(url)
+          when HttpMethod::POST
+            request.post(url, body: body)
+          end
+        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)
+        return request(method, 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)
+      request(method, 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('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('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('log_event', json_body, @post_logs_retry_limit)
+    rescue StandardError
+
     end
   end
-end
+end