statsig 1.25.2 → 1.33.0

data/lib/statsig_logger.rb

@@ -1,4 +1,4 @@
-# typed: true
+require 'constants'
 require 'statsig_event'
 require 'concurrent-ruby'
 
@@ -6,10 +6,10 @@ $gate_exposure_event = 'statsig::gate_exposure'
 $config_exposure_event = 'statsig::config_exposure'
 $layer_exposure_event = 'statsig::layer_exposure'
 $diagnostics_event = 'statsig::diagnostics'
-$ignored_metadata_keys = ['serverTime', 'configSyncTime', 'initTime', 'reason']
+$ignored_metadata_keys = [:serverTime, :configSyncTime, :initTime, :reason]
 module Statsig
   class StatsigLogger
-    def initialize(network, options)
+    def initialize(network, options, error_boundary)
       @network = network
       @events = []
       @options = options
@@ -23,9 +23,11 @@ module Statsig
         fallback_policy: :discard
       )
 
+      @error_boundary = error_boundary
       @background_flush = periodic_flush
       @deduper = Concurrent::Set.new()
       @interval = 0
+      @flush_mutex = Mutex.new
     end
 
     def log_event(event)
@@ -39,9 +41,9 @@ module Statsig
       event = StatsigEvent.new($gate_exposure_event)
       event.user = user
       metadata = {
-        'gate' => gate_name,
-        'gateValue' => value.to_s,
-        'ruleID' => rule_id,
+        gate: gate_name,
+        gateValue: value.to_s,
+        ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
       return false if not is_unique_exposure(user, $gate_exposure_event, metadata)
       event.metadata = metadata
@@ -57,8 +59,8 @@ module Statsig
       event = StatsigEvent.new($config_exposure_event)
       event.user = user
       metadata = {
-        'config' => config_name,
-        'ruleID' => rule_id,
+        config: config_name,
+        ruleID: rule_id || Statsig::Const::EMPTY_STR,
       }
       return false if not is_unique_exposure(user, $config_exposure_event, metadata)
       event.metadata = metadata
@@ -70,8 +72,8 @@ module Statsig
     end
 
     def log_layer_exposure(user, layer, parameter_name, config_evaluation, context = nil)
-      exposures = config_evaluation.undelegated_sec_exps
-      allocated_experiment = ''
+      exposures = config_evaluation.undelegated_sec_exps || []
+      allocated_experiment = Statsig::Const::EMPTY_STR
       is_explicit = (config_evaluation.explicit_parameters&.include? parameter_name) || false
       if is_explicit
         allocated_experiment = config_evaluation.config_delegate
@@ -81,13 +83,13 @@ module Statsig
       event = StatsigEvent.new($layer_exposure_event)
       event.user = user
       metadata = {
-        'config' => layer.name,
-        'ruleID' => layer.rule_id,
-        'allocatedExperiment' => allocated_experiment,
-        'parameterName' => parameter_name,
-        'isExplicitParameter' => String(is_explicit),
+        config: layer.name,
+        ruleID: layer.rule_id || Statsig::Const::EMPTY_STR,
+        allocatedExperiment: allocated_experiment,
+        parameterName: parameter_name,
+        isExplicitParameter: String(is_explicit)
       }
-      return false if not is_unique_exposure(user, $layer_exposure_event, metadata)
+      return false unless is_unique_exposure(user, $layer_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
 
@@ -96,25 +98,33 @@ module Statsig
       log_event(event)
     end
 
-    def log_diagnostics_event(diagnostics, user = nil)
-      return if @options.disable_diagnostics_logging
-      return if diagnostics.nil? || diagnostics.markers.empty?
+    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
-      event.metadata = diagnostics.serialize
+      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
       Thread.new do
-        loop do
-          sleep @options.logging_interval_seconds
-          flush_async
-          @interval += 1
-          @deduper.clear if @interval % 2 == 0
-        end
+        @error_boundary.capture(task: lambda {
+          loop do
+            sleep @options.logging_interval_seconds
+            flush_async
+            @interval += 1
+            @deduper.clear if @interval % 2 == 0
+          end
+        })
       end
     end
 
@@ -132,18 +142,20 @@ module Statsig
     end
 
     def flush
-      if @events.length == 0
-        return
-      end
-      events_clone = @events
-      @events = []
-      flush_events = events_clone.map { |e| e.serialize }
+      @flush_mutex.synchronize do
+        if @events.length.zero?
+          return
+        end
 
-      @network.post_logs(flush_events)
+        events_clone = @events
+        @events = []
+        flush_events = events_clone.map { |e| e.serialize }
+        @network.post_logs(flush_events)
+      end
     end
 
     def maybe_restart_background_threads
-      if @background_flush.nil? or !@background_flush.alive?
+      if @background_flush.nil? || !@background_flush.alive?
         @background_flush = periodic_flush
       end
     end
@@ -155,10 +167,10 @@ module Statsig
         return
       end
 
-      event.metadata['reason'] = eval_details.reason
-      event.metadata['configSyncTime'] = eval_details.config_sync_time
-      event.metadata['initTime'] = eval_details.init_time
-      event.metadata['serverTime'] = eval_details.server_time
+      event.metadata[:reason] = eval_details.reason
+      event.metadata[:configSyncTime] = eval_details.config_sync_time
+      event.metadata[:initTime] = eval_details.init_time
+      event.metadata[:serverTime] = eval_details.server_time
     end
 
     def safe_add_exposure_context(context, event)
@@ -166,8 +178,8 @@ module Statsig
         return
       end
 
-      if context['is_manual_exposure']
-        event.metadata['isManualExposure'] = 'true'
+      if context[:is_manual_exposure]
+        event.metadata[:isManualExposure] = 'true'
       end
     end
 
@@ -195,4 +207,4 @@ module Statsig
       true
     end
   end
-end
+end

data/lib/statsig_options.rb

@@ -1,132 +1,100 @@
-# typed: true
-
-require 'sorbet-runtime'
 require_relative 'interfaces/data_store'
+require_relative 'interfaces/user_persistent_storage'
 
 ##
 # Configuration options for the Statsig SDK.
 class StatsigOptions
-  extend T::Sig
 
-  sig { returns(T.any(T::Hash[String, String], NilClass)) }
   # Hash you can use to set environment variables that apply to all of your users in
   # the same session and will be used for targeting purposes.
   # eg. { "tier" => "development" }
   attr_accessor :environment
 
-  sig { returns(String) }
   # The base url used to make network calls to Statsig.
   # default: https://statsigapi.net/v1
   attr_accessor :api_url_base
 
   # The base url used specifically to call download_config_specs.
   # Takes precedence over api_url_base
-  sig { returns(T.any(String, NilClass)) }
   attr_accessor :api_url_download_config_specs
 
-  sig { returns(T.any(Float, Integer)) }
   # The interval (in seconds) to poll for changes to your Statsig configuration
   # default: 10s
   attr_accessor :rulesets_sync_interval
 
-  sig { returns(T.any(Float, Integer)) }
   # The interval (in seconds) to poll for changes to your id lists
   # default: 60s
   attr_accessor :idlists_sync_interval
 
-  sig { returns(T.any(Float, Integer)) }
+  # Disable background syncing for rulesets
+  attr_accessor :disable_rulesets_sync
+
+  # Disable background syncing for id lists
+  attr_accessor :disable_idlists_sync
+
   # How often to flush logs to Statsig
   # default: 60s
   attr_accessor :logging_interval_seconds
 
-  sig { returns(Integer) }
   # The maximum number of events to batch before flushing logs to the server
   # default: 1000
   attr_accessor :logging_max_buffer_size
 
-  sig { returns(T::Boolean) }
   # Restricts the SDK to not issue any network requests and only respond with default values (or local overrides)
   # default: false
   attr_accessor :local_mode
 
-  sig { returns(T.any(String, NilClass)) }
   # A string that represents all rules for all feature gates, dynamic configs and experiments.
   # It can be provided to bootstrap the Statsig server SDK at initialization in case your server runs
   # into network issue or Statsig is down temporarily.
   attr_accessor :bootstrap_values
 
-  sig { returns(T.any(Method, Proc, NilClass)) }
   # A callback function that will be called anytime the rulesets are updated.
   attr_accessor :rules_updated_callback
 
-  sig { returns(T.any(Statsig::Interfaces::IDataStore, NilClass)) }
   # A class that extends IDataStore. Can be used to provide values from a
   # common data store (like Redis) to initialize the Statsig SDK.
   attr_accessor :data_store
 
-  sig { returns(Integer) }
   # The number of threads allocated to syncing IDLists.
   # default: 3
   attr_accessor :idlist_threadpool_size
 
-  sig { returns(Integer) }
   # The number of threads allocated to posting event logs.
   # default: 3
   attr_accessor :logger_threadpool_size
 
-  sig { returns(T::Boolean) }
   # Should diagnostics be logged. These include performance metrics for initialize.
   # default: false
   attr_accessor :disable_diagnostics_logging
 
-  sig { returns(T::Boolean) }
   # Statsig utilizes Sorbet (https://sorbet.org) to ensure type safety of the SDK. This includes logging
   # to console when errors are detected. You can disable this logging by setting this flag to true.
   # default: false
   attr_accessor :disable_sorbet_logging_handlers
 
-  sig { returns(T.any(Integer, NilClass)) }
   # Number of seconds before a network call is timed out
   attr_accessor :network_timeout
 
-  sig { returns(Integer) }
   # Number of times to retry sending a batch of failed log events
   attr_accessor :post_logs_retry_limit
 
-  sig { returns(T.any(Method, Proc, Integer, NilClass)) }
   # The number of seconds, or a function that returns the number of seconds based on the number of retries remaining
   # which overrides the default backoff time between retries
   attr_accessor :post_logs_retry_backoff
 
-  sig do
-    params(
-      environment: T.any(T::Hash[String, String], NilClass),
-      api_url_base: String,
-      api_url_download_config_specs: T.any(String, NilClass),
-      rulesets_sync_interval: T.any(Float, Integer),
-      idlists_sync_interval: T.any(Float, Integer),
-      logging_interval_seconds: T.any(Float, Integer),
-      logging_max_buffer_size: Integer,
-      local_mode: T::Boolean,
-      bootstrap_values: T.any(String, NilClass),
-      rules_updated_callback: T.any(Method, Proc, NilClass),
-      data_store: T.any(Statsig::Interfaces::IDataStore, NilClass),
-      idlist_threadpool_size: Integer,
-      logger_threadpool_size: Integer,
-      disable_diagnostics_logging: T::Boolean,
-      disable_sorbet_logging_handlers: T::Boolean,
-      network_timeout: T.any(Integer, NilClass),
-      post_logs_retry_limit: Integer,
-      post_logs_retry_backoff: T.any(Method, Proc, Integer, NilClass)
-    ).void
-  end
+  # A storage adapter for persisted values. Can be used for sticky bucketing users in experiments.
+  # Implements Statsig::Interfaces::IUserPersistentStorage.
+  attr_accessor :user_persistent_storage
 
   def initialize(
     environment = nil,
-    api_url_base = 'https://statsigapi.net/v1',
+    api_url_base = nil,
     api_url_download_config_specs: nil,
     rulesets_sync_interval: 10,
     idlists_sync_interval: 60,
+    disable_rulesets_sync: false,
+    disable_idlists_sync: false,
     logging_interval_seconds: 60,
     logging_max_buffer_size: 1000,
     local_mode: false,
@@ -139,12 +107,16 @@ class StatsigOptions
     disable_sorbet_logging_handlers: false,
     network_timeout: nil,
     post_logs_retry_limit: 3,
-    post_logs_retry_backoff: nil)
+    post_logs_retry_backoff: nil,
+    user_persistent_storage: nil
+  )
     @environment = environment.is_a?(Hash) ? environment : nil
-    @api_url_base = api_url_base
-    @api_url_download_config_specs = api_url_download_config_specs
+    @api_url_base = api_url_base || 'https://statsigapi.net/v1'
+    @api_url_download_config_specs = api_url_download_config_specs || api_url_base || 'https://api.statsigcdn.com/v1'
     @rulesets_sync_interval = rulesets_sync_interval
     @idlists_sync_interval = idlists_sync_interval
+    @disable_rulesets_sync = disable_rulesets_sync
+    @disable_idlists_sync = disable_idlists_sync
     @logging_interval_seconds = logging_interval_seconds
     @logging_max_buffer_size = [logging_max_buffer_size, 1000].min
     @local_mode = local_mode
@@ -158,5 +130,7 @@ class StatsigOptions
     @network_timeout = network_timeout
     @post_logs_retry_limit = post_logs_retry_limit
     @post_logs_retry_backoff = post_logs_retry_backoff
+    @user_persistent_storage = user_persistent_storage
+
   end
-end
+end

data/lib/statsig_user.rb

@@ -1,67 +1,49 @@
-# typed: true
-
-require 'sorbet-runtime'
 require 'json'
+require 'constants'
 
 ##
 #  The user object to be evaluated against your Statsig configurations (gates/experiments/dynamic configs).
 class StatsigUser
-  extend T::Sig
 
-  sig { returns(T.any(String, NilClass)) }
   # An identifier for this user. Evaluated against the User ID criteria. (https://docs.statsig.com/feature-gates/conditions#userid)
   attr_accessor :user_id
 
-  sig { returns(T.any(String, NilClass)) }
   # An identifier for this user. Evaluated against the Email criteria. (https://docs.statsig.com/feature-gates/conditions#email)
   attr_accessor :email
 
-  sig { returns(T.any(String, NilClass)) }
   # An IP address associated with this user. Evaluated against the IP Address criteria. (https://docs.statsig.com/feature-gates/conditions#ip)
   attr_accessor :ip
 
-  sig { returns(T.any(String, NilClass)) }
   # A user agent string associated with this user. Evaluated against Browser Version and Name (https://docs.statsig.com/feature-gates/conditions#browser-version)
   attr_accessor :user_agent
 
-  sig { returns(T.any(String, NilClass)) }
   # The country code associated with this user (e.g New Zealand => NZ). Evaluated against the Country criteria. (https://docs.statsig.com/feature-gates/conditions#country)
   attr_accessor :country
 
-  sig { returns(T.any(String, NilClass)) }
   # An locale for this user.
   attr_accessor :locale
 
-  sig { returns(T.any(String, NilClass)) }
   # The current app version the user is interacting with. Evaluated against the App Version criteria. (https://docs.statsig.com/feature-gates/conditions#app-version)
   attr_accessor :app_version
 
-  sig { returns(T.any(T::Hash[String, String], NilClass)) }
   # A Hash you can use to set environment variables that apply to this user. e.g. { "tier" => "development" }
   attr_accessor :statsig_environment
 
-  sig { returns(T.any(T::Hash[String, String], NilClass)) }
   # Any Custom IDs to associated with the user. (See https://docs.statsig.com/guides/experiment-on-custom-id-types)
   attr_accessor :custom_ids
 
-  sig { returns(T.any(T::Hash[String, String], NilClass)) }
   # Any value you wish to use in evaluation, but do not want logged with events, can be stored in this field.
   attr_accessor :private_attributes
 
-  sig { returns(T.any(T::Hash[String, T.untyped], NilClass)) }
-
   def custom
     @custom
   end
 
-  sig { params(value: T.any(T::Hash[String, T.untyped], NilClass)).void }
   # Any custom fields for this user. Evaluated against the Custom criteria. (https://docs.statsig.com/feature-gates/conditions#custom)
   def custom=(value)
     @custom = value.is_a?(Hash) ? value : Hash.new
   end
 
-  sig { params(user_hash: T.any(T::Hash[T.any(String, Symbol), T.untyped], NilClass)).void }
-
   def initialize(user_hash)
     the_hash = user_hash
     begin
@@ -85,52 +67,79 @@ class StatsigUser
 
   def serialize(for_logging)
     hash = {
-      'userID' => @user_id,
-      'email' => @email,
-      'ip' => @ip,
-      'userAgent' => @user_agent,
-      'country' => @country,
-      'locale' => @locale,
-      'appVersion' => @app_version,
-      'custom' => @custom,
-      'statsigEnvironment' => @statsig_environment,
-      'privateAttributes' => @private_attributes,
-      'customIDs' => @custom_ids,
+      :userID => @user_id,
+      :email => @email,
+      :ip => @ip,
+      :userAgent => @user_agent,
+      :country => @country,
+      :locale => @locale,
+      :appVersion => @app_version,
+      :custom => @custom,
+      :statsigEnvironment => @statsig_environment,
+      :privateAttributes => @private_attributes,
+      :customIDs => @custom_ids,
     }
     if for_logging
-      hash.delete('privateAttributes')
+      hash.delete(:privateAttributes)
     end
     hash.compact
   end
 
-  def value_lookup
-    {
-      'userID' => @user_id,
-      'userid' => @user_id,
-      'user_id' => @user_id,
-      'email' => @email,
-      'ip' => @ip,
-      'userAgent' => @user_agent,
-      'useragent' => @user_agent,
-      'user_agent' => @user_agent,
-      'country' => @country,
-      'locale' => @locale,
-      'appVersion' => @app_version,
-      'appversion' => @app_version,
-      'app_version' => @app_version,
-      'custom' => @custom,
-      'privateAttributes' => @private_attributes,
-    }
+  def to_hash_without_stable_id
+    hash = {}
+
+    if @user_id != nil
+      hash[:userID] = @user_id
+    end
+    if @email != nil
+      hash[:email] = @email
+    end
+    if @ip != nil
+      hash[:ip] = @ip
+    end
+    if @user_agent != nil
+      hash[:userAgent] = @user_agent
+    end
+    if @country != nil
+      hash[:country] = @country
+    end
+    if @locale != nil
+      hash[:locale] = @locale
+    end
+    if @app_version != nil
+      hash[:appVersion] = @app_version
+    end
+    if @custom != nil
+      hash[:custom] = Statsig::HashUtils.sortHash(@custom)
+    end
+    if @statsig_environment != nil
+      hash[:statsigEnvironment] = @statsig_environment.clone.sort_by { |key| key }.to_h
+    end
+    if @private_attributes != nil
+      hash[:privateAttributes] = Statsig::HashUtils.sortHash(@private_attributes)
+    end
+    custom_ids = {}
+    if @custom_ids != nil
+      custom_ids = @custom_ids.clone
+      if custom_ids.key?("stableID")
+        custom_ids.delete("stableID")
+      end
+    end
+    hash[:customIDs] = custom_ids.sort_by { |key| key }.to_h
+    return Statsig::HashUtils.djb2ForHash(hash.sort_by { |key| key }.to_h)
+  end
+
+  def get_unit_id(id_type)
+    if id_type.is_a?(String) && id_type != Statsig::Const::CML_USER_ID
+      return nil unless @custom_ids.is_a? Hash
+
+      return @custom_ids[id_type] || @custom_ids[id_type.downcase]
+    end
+    @user_id
   end
 
   private
 
-  sig {
-    params(user_hash: T.any(T::Hash[T.any(String, Symbol), T.untyped], NilClass),
-           keys: T::Array[Symbol],
-           type: T.untyped)
-      .returns(T.untyped)
-  }
   # Pulls fields from the user hash via Symbols and Strings
   def from_hash(user_hash, keys, type)
     if user_hash.nil?
@@ -146,5 +155,4 @@ class StatsigUser
 
     nil
   end
-
-end
+end

data/lib/ua_parser.rb

@@ -1,3 +1,4 @@
+
 require 'user_agent_parser'
 
 module UAParser

data/lib/uri_helper.rb

@@ -1,24 +1,16 @@
-# typed: true
-
-require 'sorbet-runtime'
-
 class URIHelper
   class URIBuilder
-    extend T::Sig
 
-    sig { returns(StatsigOptions) }
     attr_accessor :options
 
-    sig { params(options: StatsigOptions).void }
     def initialize(options)
       @options = options
     end
 
-    sig { params(endpoint: String).returns(String) }
     def build_url(endpoint)
       api = @options.api_url_base
-      if endpoint == 'download_config_specs' && !@options.api_url_download_config_specs.nil?
-        api = T.must(@options.api_url_download_config_specs)
+      if endpoint.include?('download_config_specs')
+        api = @options.api_url_download_config_specs
       end
       unless api.end_with?('/')
         api += '/'

data/lib/user_persistent_storage_utils.rb

@@ -0,0 +1,89 @@
+require 'statsig_options'
+
+module Statsig
+  class UserPersistentStorageUtils
+
+    attr_accessor :cache
+
+    attr_accessor :storage
+
+    def initialize(options)
+      @storage = options.user_persistent_storage
+      @cache = {}
+    end
+
+    def get_user_persisted_values(user, id_type)
+      key = self.class.get_storage_key(user, id_type)
+      return @cache[key] unless @cache[key].nil?
+
+      return load_from_storage(key)
+    end
+
+    def load_from_storage(key)
+      return if @storage.nil?
+
+      begin
+        storage_values = @storage.load(key)
+      rescue StandardError => e
+        puts "Failed to load key (#{key}) from user_persisted_storage (#{e.message})"
+        return nil
+      end
+
+      unless storage_values.nil?
+        parsed_values = self.class.parse(storage_values)
+        unless parsed_values.nil?
+          @cache[key] = parsed_values
+          return @cache[key]
+        end
+      end
+      return nil
+    end
+
+    def save_to_storage(user, id_type, user_persisted_values)
+      return if @storage.nil?
+
+      key = self.class.get_storage_key(user, id_type)
+      stringified = self.class.stringify(user_persisted_values)
+      return if stringified.nil?
+
+      begin
+        @storage.save(key, stringified)
+      rescue StandardError => e
+        puts "Failed to save key (#{key}) to user_persisted_storage (#{e.message})"
+      end
+    end
+
+    def remove_experiment_from_storage(user, id_type, config_name)
+      persisted_values = get_user_persisted_values(user, id_type)
+      unless persisted_values.nil?
+        persisted_values.delete(config_name)
+        save_to_storage(user, id_type, persisted_values)
+      end
+    end
+
+    def add_evaluation_to_user_persisted_values(user_persisted_values, config_name, evaluation)
+      if user_persisted_values.nil?
+        user_persisted_values = {}
+      end
+      user_persisted_values[config_name] = evaluation.to_hash
+    end
+
+    private
+
+    def self.parse(values_string)
+      return JSON.parse(values_string)
+    rescue JSON::ParserError
+      return nil
+    end
+
+    def self.stringify(values_object)
+      return JSON.generate(values_object)
+    rescue StandardError
+      return nil
+    end
+
+    def self.get_storage_key(user, id_type)
+      "#{user.get_unit_id(id_type)}:#{id_type}"
+    end
+  end
+end