statsig 1.25.1 → 1.26.0

data/lib/statsig_driver.rb

@@ -30,19 +30,19 @@ class StatsigDriver
     end
 
     @err_boundary = Statsig::ErrorBoundary.new(secret_key)
-    @err_boundary.capture(-> {
-      @init_diagnostics = Statsig::Diagnostics.new("initialize")
-      @init_diagnostics.mark("overall", "start")
+    @err_boundary.capture(task: lambda {
+      @diagnostics = Statsig::Diagnostics.new('initialize')
+      tracker = @diagnostics.track('overall')
       @options = options || StatsigOptions.new
       @shutdown = false
       @secret_key = secret_key
       @net = Statsig::Network.new(secret_key, @options)
-      @logger = Statsig::StatsigLogger.new(@net, @options)
-      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @init_diagnostics)
-      @init_diagnostics.mark("overall", "end")
+      @logger = Statsig::StatsigLogger.new(@net, @options, @err_boundary)
+      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger)
+      tracker.end(success: true)
 
-      log_init_diagnostics
-    })
+      @logger.log_diagnostics_event(@diagnostics)
+    }, caller: __method__.to_s)
   end
 
   class CheckGateOptions < T::Struct
@@ -52,34 +52,37 @@ class StatsigDriver
   sig { params(user: StatsigUser, gate_name: String, options: CheckGateOptions).returns(T::Boolean) }
 
   def check_gate(user, gate_name, options = CheckGateOptions.new)
-    @err_boundary.capture(-> {
-      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
+    @err_boundary.capture(task: lambda {
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, gate_name, "gate_name")
 
-      if res == $fetch_from_server
-        res = check_gate_fallback(user, gate_name)
-        # exposure logged by the server
-      else
-        if options.log_exposure
-          @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
+        res = @evaluator.check_gate(user, gate_name)
+        if res.nil?
+          res = Statsig::ConfigResult.new(gate_name)
         end
-      end
 
-      res.gate_value
-    }, -> { false })
+        if res == $fetch_from_server
+          res = check_gate_fallback(user, gate_name)
+          # exposure logged by the server
+        else
+          if options.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
+      }, caller: __method__.to_s)
+    }, recover: -> { false }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, gate_name: String).void }
 
   def manually_log_gate_exposure(user, gate_name)
-    res = @evaluator.check_gate(user, gate_name)
-    context = {'is_manual_exposure' => true}
-    @logger.log_gate_exposure(user, gate_name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+    @err_boundary.capture(task: lambda {
+      res = @evaluator.check_gate(user, gate_name)
+      context = { 'is_manual_exposure' => true }
+      @logger.log_gate_exposure(user, gate_name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+    })
   end
 
   class GetConfigOptions < T::Struct
@@ -89,10 +92,12 @@ class StatsigDriver
   sig { params(user: StatsigUser, dynamic_config_name: String, options: GetConfigOptions).returns(DynamicConfig) }
 
   def get_config(user, dynamic_config_name, options = GetConfigOptions.new)
-    @err_boundary.capture(-> {
-      user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
-      get_config_impl(user, dynamic_config_name, options)
-    }, -> { DynamicConfig.new(dynamic_config_name) })
+    @err_boundary.capture(task: lambda {
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
+        get_config_impl(user, dynamic_config_name, options)
+      }, caller: __method__.to_s)
+    }, recover: -> { DynamicConfig.new(dynamic_config_name) }, caller: __method__.to_s)
   end
 
   class GetExperimentOptions < T::Struct
@@ -102,18 +107,22 @@ class StatsigDriver
   sig { params(user: StatsigUser, experiment_name: String, options: GetExperimentOptions).returns(DynamicConfig) }
 
   def get_experiment(user, experiment_name, options = GetExperimentOptions.new)
-    @err_boundary.capture(-> {
-      user = verify_inputs(user, experiment_name, "experiment_name")
-      get_config_impl(user, experiment_name, options)
-    }, -> { DynamicConfig.new(experiment_name) })
+    @err_boundary.capture(task: lambda {
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, experiment_name, "experiment_name")
+        get_config_impl(user, experiment_name, options)
+      }, caller: __method__.to_s)
+    }, recover: -> { DynamicConfig.new(experiment_name) }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, config_name: String).void }
 
   def manually_log_config_exposure(user, config_name)
-    res = @evaluator.get_config(user, config_name)
-    context = {'is_manual_exposure' => true}
-    @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+    @err_boundary.capture(task: lambda {
+      res = @evaluator.get_config(user, config_name)
+      context = { 'is_manual_exposure' => true }
+      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+    }, caller: __method__.to_s)
   end
 
   class GetLayerOptions < T::Struct
@@ -123,42 +132,44 @@ class StatsigDriver
   sig { params(user: StatsigUser, layer_name: String, options: GetLayerOptions).returns(Layer) }
 
   def get_layer(user, layer_name, options = GetLayerOptions.new)
-    @err_boundary.capture(-> {
-      user = verify_inputs(user, layer_name, "layer_name")
+    @err_boundary.capture(task: lambda {
+      run_with_diagnostics(task: lambda {
+        user = verify_inputs(user, layer_name, "layer_name")
 
-      res = @evaluator.get_layer(user, layer_name)
-      if res.nil?
-        res = Statsig::ConfigResult.new(layer_name)
-      end
+        res = @evaluator.get_layer(user, layer_name)
+        if res.nil?
+          res = Statsig::ConfigResult.new(layer_name)
+        end
 
-      if res == $fetch_from_server
-        if res.config_delegate.empty?
-          return Layer.new(layer_name)
+        if res == $fetch_from_server
+          if res.config_delegate.empty?
+            return Layer.new(layer_name)
+          end
+          res = get_config_fallback(user, res.config_delegate)
+          # exposure logged by the server
         end
-        res = get_config_fallback(user, res.config_delegate)
-        # exposure logged by the server
-      end
-      
-      exposure_log_func = options.log_exposure ? lambda { |layer, parameter_name|
-        @logger.log_layer_exposure(user, layer, parameter_name, res)
-      } : nil
-      Layer.new(res.name, res.json_value, res.rule_id, exposure_log_func)
-    }, -> {
-      Layer.new(layer_name)
-    })
+
+        exposure_log_func = options.log_exposure ? lambda { |layer, parameter_name|
+          @logger.log_layer_exposure(user, layer, parameter_name, res)
+        } : nil
+        Layer.new(res.name, res.json_value, res.rule_id, exposure_log_func)
+      }, caller: __method__.to_s)
+    }, recover: lambda { Layer.new(layer_name) }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, layer_name: String, parameter_name: String).void }
 
   def manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
-    res = @evaluator.get_layer(user, layer_name)
-    layer = Layer.new(layer_name, res.json_value, res.rule_id)
-    context = {'is_manual_exposure' => true}
-    @logger.log_layer_exposure(user, layer, parameter_name, res, context)
+    @err_boundary.capture(task: lambda {
+      res = @evaluator.get_layer(user, layer_name)
+      layer = Layer.new(layer_name, res.json_value, res.rule_id)
+      context = { 'is_manual_exposure' => true }
+      @logger.log_layer_exposure(user, layer, parameter_name, res, context)
+    }, caller: __method__.to_s)
   end
 
   def log_event(user, event_name, value = nil, metadata = nil)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       if !user.nil? && !user.instance_of?(StatsigUser)
         raise Statsig::ValueError.new('Must provide a valid StatsigUser or nil')
       end
@@ -171,37 +182,38 @@ class StatsigDriver
       event.value = value
       event.metadata = metadata
       @logger.log_event(event)
-    })
+    }, caller: __method__.to_s)
   end
 
   def shutdown
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @shutdown = true
       @logger.shutdown
       @evaluator.shutdown
-    })
+    }, caller: __method__.to_s)
   end
 
   def override_gate(gate_name, gate_value)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.override_gate(gate_name, gate_value)
-    })
+    }, caller: __method__.to_s)
   end
 
   def override_config(config_name, config_value)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.override_config(config_name, config_value)
-    })
+    }, caller: __method__.to_s)
   end
 
   # @param [StatsigUser] user
+  # @param [String | nil] client_sdk_key
   # @return [Hash]
-  def get_client_initialize_response(user)
-    @err_boundary.capture(-> {
+  def get_client_initialize_response(user, hash, client_sdk_key)
+    @err_boundary.capture(task: lambda {
       validate_user(user)
       normalize_user(user)
-      @evaluator.get_client_initialize_response(user)
-    }, -> { nil })
+      @evaluator.get_client_initialize_response(user, hash, client_sdk_key)
+    }, recover: -> { nil }, caller: __method__.to_s)
   end
 
   def maybe_restart_background_threads
@@ -209,14 +221,32 @@ class StatsigDriver
       return
     end
 
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.maybe_restart_background_threads
       @logger.maybe_restart_background_threads
-    })
+    }, caller: __method__.to_s)
   end
 
   private
 
+  def run_with_diagnostics(task:, caller:)
+    diagnostics = nil
+    if Statsig::Diagnostics::API_CALL_KEYS.include?(caller) && Statsig::Diagnostics.sample(10_000)
+      diagnostics = Statsig::Diagnostics.new('api_call')
+      tracker = diagnostics.track(caller)
+    end
+    begin
+      res = task.call
+      tracker&.end(success: true)
+    rescue StandardError => e
+      tracker&.end(success: false)
+      raise e
+    ensure
+      @logger.log_diagnostics_event(diagnostics)
+    end
+    return res
+  end
+
   sig { params(user: StatsigUser, config_name: String, variable_name: String).returns(StatsigUser) }
 
   def verify_inputs(user, config_name, variable_name)
@@ -302,12 +332,4 @@ class StatsigDriver
       network_result['rule_id'],
     )
   end
-
-  def log_init_diagnostics
-    if @options.disable_diagnostics_logging
-      return
-    end
-
-    @logger.log_diagnostics_event(@init_diagnostics)
-  end
 end

data/lib/statsig_errors.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Statsig
   class UninitializedError < StandardError
     def initialize(msg="Must call initialize first.")

data/lib/statsig_logger.rb

@@ -9,7 +9,7 @@ $diagnostics_event = 'statsig::diagnostics'
 $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)
@@ -97,20 +99,26 @@ module Statsig
     end
 
     def log_diagnostics_event(diagnostics, user = nil)
+      return if @options.disable_diagnostics_logging
+      return if diagnostics.nil? || diagnostics.markers.empty?
+
       event = StatsigEvent.new($diagnostics_event)
       event.user = user
       event.metadata = diagnostics.serialize
       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
 
@@ -128,18 +136,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

data/lib/statsig_options.rb

@@ -19,6 +19,11 @@ class StatsigOptions
   # 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
@@ -97,6 +102,7 @@ class StatsigOptions
     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),
@@ -118,6 +124,7 @@ class StatsigOptions
   def initialize(
     environment = nil,
     api_url_base = 'https://statsigapi.net/v1',
+    api_url_download_config_specs: nil,
     rulesets_sync_interval: 10,
     idlists_sync_interval: 60,
     logging_interval_seconds: 60,
@@ -135,6 +142,7 @@ class StatsigOptions
     post_logs_retry_backoff: nil)
     @environment = environment.is_a?(Hash) ? environment : nil
     @api_url_base = api_url_base
+    @api_url_download_config_specs = api_url_download_config_specs
     @rulesets_sync_interval = rulesets_sync_interval
     @idlists_sync_interval = idlists_sync_interval
     @logging_interval_seconds = logging_interval_seconds

data/lib/ua_parser.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'user_agent_parser'
 
 module UAParser

data/lib/uri_helper.rb

@@ -0,0 +1,37 @@
+# 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)
+      end
+      unless api.end_with?('/')
+        api += '/'
+      end
+      "#{api}#{endpoint}"
+    end
+  end
+
+  def self.initialize(options)
+    @uri_builder = URIBuilder.new(options)
+  end
+
+  def self.build_url(endpoint)
+    @uri_builder.build_url(endpoint)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.25.1
+  version: 1.26.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-31 00:00:00.000000000 Z
+date: 2023-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.14.0
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: minitest-suite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: spy
   requirement: !ruby/object:Gem::Requirement
@@ -226,6 +254,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
 - !ruby/object:Gem::Dependency
   name: ip3country
   requirement: !ruby/object:Gem::Requirement
@@ -282,6 +330,7 @@ files:
 - lib/evaluation_details.rb
 - lib/evaluation_helpers.rb
 - lib/evaluator.rb
+- lib/hash_utils.rb
 - lib/id_list.rb
 - lib/interfaces/data_store.rb
 - lib/layer.rb
@@ -295,6 +344,7 @@ files:
 - lib/statsig_options.rb
 - lib/statsig_user.rb
 - lib/ua_parser.rb
+- lib/uri_helper.rb
 homepage: https://rubygems.org/gems/statsig
 licenses:
 - ISC