statsig 1.25.1 → 1.25.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1772b0fb47eaaf4b95950425eeba70ea7b792a8e5aad952b67e7aea8000d06b
-  data.tar.gz: 2e75c8c1c9e68817440dd73d98020f99f20e80255424fb499dff8d3464eb39ba
+  metadata.gz: c7f3c8522d7d8062daf248fd667fd0d8152a4194339fde799814a5da44812eda
+  data.tar.gz: 1fd5e67d4a75ab3b5b6c92c780841252a4610e18bc13310f9b11dbb583aaf16a
 SHA512:
-  metadata.gz: 5f291605da74348e702b8258ca52c6bb609d6359c961a862d76c50e7a53b348bb7705ed6ac2e3da2b68ea89c2db852feb50f5213d5c9543af665142e8cc2bc15
-  data.tar.gz: 3f1923846883e667b5f5ae14c9efd90fd295a3c0336be262ec879227b3af85b513f9dc407687e8f6273e911644b40bbde7324ff86fc3bc7b26e4a3fd9345992b
+  metadata.gz: 8f516ca6d221c9d789f1f358b550edeedf4203c01ead45374b97a3b81f4205d09f1c7c3e0214516cdcad314bacbdbde39a5df2053779679fe4df593c974c8300
+  data.tar.gz: a90846ef3c050c7c0b8bddbabd19ed7bff6236a15ed941f55d1a305f4c9cb5ff35f595a3d7ea4ab1560d7f7bae11c669c29d17f8041da9125524669703dc5370

data/lib/diagnostics.rb

@@ -12,33 +12,92 @@ module Statsig
     sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
     attr_reader :markers
 
-    sig { params(context: String).void }
-
     def initialize(context)
       @context = context
       @markers = []
     end
 
-    sig { params(key: String, action: String, step: T.any(String, NilClass), value: T.any(String, Integer, T::Boolean, NilClass)).void }
+    sig do
+      params(
+        key: String,
+        action: String,
+        step: T.any(String, NilClass),
+        value: T.any(String, Integer, T::Boolean, NilClass),
+        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+      ).void
+    end
 
-    def mark(key, action, step = nil, value = nil)
+    def mark(key, action, step = nil, value = nil, metadata = nil)
       @markers.push({
                       key: key,
                       step: step,
                       action: action,
                       value: value,
+                      metadata: metadata,
                       timestamp: (Time.now.to_f * 1000).to_i
                     })
     end
 
+    sig do
+      params(
+        key: String,
+        step: T.any(String, NilClass),
+        value: T.any(String, Integer, T::Boolean, NilClass),
+        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+      ).returns(Tracker)
+    end
+    def track(key, step = nil, value = nil, metadata = nil)
+      tracker = Tracker.new(self, key, step, metadata)
+      tracker.start(value)
+      tracker
+    end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
 
     def serialize
       {
-        context: @context,
-        markers: @markers
+        context: @context.clone,
+        markers: @markers.clone
       }
     end
-  end
 
-end
+    def clear_markers
+      @markers.clear
+    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
+      extend T::Sig
+
+      sig do
+        params(
+          diagnostics: Diagnostics,
+          key: String,
+          step: T.any(String, NilClass),
+          metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+        ).void
+      end
+      def initialize(diagnostics, key, step, metadata)
+        @diagnostics = diagnostics
+        @key = key
+        @step = step
+        @metadata = metadata
+      end
+
+      def start(value = nil)
+        @diagnostics.mark(@key, 'start', @step, value, @metadata)
+      end
+
+      def end(value = nil)
+        @diagnostics.mark(@key, 'end', @step, value, @metadata)
+      end
+    end
+  end
+end

data/lib/error_boundary.rb

@@ -1,25 +1,46 @@
-require "statsig_errors"
+# typed: true
+
+require 'statsig_errors'
+require 'sorbet-runtime'
 
 $endpoint = 'https://statsigapi.net/v1/sdk_exception'
 
 module Statsig
   class ErrorBoundary
+    extend T::Sig
+
+    sig { returns(T.any(StatsigLogger, NilClass)) }
+    attr_accessor :logger
+
+    sig { params(sdk_key: String).void }
     def initialize(sdk_key)
       @sdk_key = sdk_key
       @seen = Set.new
     end
 
-    def capture(task, recover = -> {})
+    def sample_diagnostics
+      rand(10_000).zero?
+    end
+
+    def capture(task:, recover: -> {}, caller: nil)
+      if !caller.nil? && Diagnostics::API_CALL_KEYS.include?(caller) && sample_diagnostics
+        diagnostics = Diagnostics.new('api_call')
+        tracker = diagnostics.track(caller)
+      end
       begin
-        return task.call
+        res = task.call
+        tracker&.end(true)
       rescue StandardError => e
+        tracker&.end(false)
         if e.is_a?(Statsig::UninitializedError) or e.is_a?(Statsig::ValueError)
           raise e
         end
-        puts "[Statsig]: An unexpected exception occurred."
+        puts '[Statsig]: An unexpected exception occurred.'
         log_exception(e)
-        return recover.call
+        res = recover.call
       end
+      @logger&.log_diagnostics_event(diagnostics)
+      return res
     end
 
     private
@@ -35,18 +56,18 @@ module Statsig
         meta = Statsig.get_statsig_metadata
         http = HTTP.headers(
           {
-            "STATSIG-API-KEY" => @sdk_key,
-            "STATSIG-SDK-TYPE" => meta['sdkType'],
-            "STATSIG-SDK-VERSION" => meta['sdkVersion'],
-            "Content-Type" => "application/json; charset=UTF-8"
+            'STATSIG-API-KEY' => @sdk_key,
+            'STATSIG-SDK-TYPE' => meta['sdkType'],
+            'STATSIG-SDK-VERSION' => meta['sdkVersion'],
+            'Content-Type' => 'application/json; charset=UTF-8'
           }).accept(:json)
         body = {
-          "exception" => name,
-          "info" => {
-            "trace" => exception.backtrace.to_s,
-            "message" => exception.message
+          'exception' => name,
+          'info' => {
+            'trace' => exception.backtrace.to_s,
+            'message' => exception.message
           }.to_s,
-          "statsigMetadata" => meta
+          'statsigMetadata' => meta
         }
         http.post($endpoint, body: JSON.generate(body))
       rescue

data/lib/evaluator.rb

@@ -17,8 +17,8 @@ module Statsig
   class Evaluator
     attr_accessor :spec_store
 
-    def initialize(network, options, error_callback, init_diagnostics = nil)
-      @spec_store = Statsig::SpecStore.new(network, options, error_callback, init_diagnostics)
+    def initialize(network, options, error_callback, diagnostics)
+      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics)
       UAParser.initialize_async
       CountryLookup.initialize_async
 

data/lib/network.rb

@@ -4,6 +4,7 @@ require 'http'
 require 'json'
 require 'securerandom'
 require 'sorbet-runtime'
+require 'uri_helper'
 
 $retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
 
@@ -24,12 +25,8 @@ module Statsig
 
     def initialize(server_secret, options, backoff_mult = 10)
       super()
-      api = options.api_url_base
-      unless api.end_with?('/')
-        api += '/'
-      end
+      URIHelper.initialize(options)
       @server_secret = server_secret
-      @api = api
       @local_mode = options.local_mode
       @timeout = options.network_timeout
       @backoff_multiplier = backoff_mult
@@ -67,8 +64,9 @@ module Statsig
           backoff_adjusted = @post_logs_retry_backoff.call(retries)
         end
       end
+      url = URIHelper.build_url(endpoint)
       begin
-        res = http.post(@api + endpoint, body: body)
+        res = http.post(url, body: body)
       rescue StandardError => e
         ## network error retry
         return nil, e unless retries > 0
@@ -76,7 +74,7 @@ module Statsig
         return post_helper(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 #{@api + endpoint}: #{res.to_s}", res.status.to_i) unless retries > 0 && $retry_codes.include?(res.code)
+      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)
       ## status code retry
       sleep backoff_adjusted
       post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)

data/lib/spec_store.rb

@@ -12,7 +12,7 @@ module Statsig
     attr_accessor :initial_config_sync_time
     attr_accessor :init_reason
 
-    def initialize(network, options, error_callback, init_diagnostics = nil)
+    def initialize(network, options, error_callback, diagnostics)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -29,6 +29,7 @@ module Statsig
         :id_lists => {},
         :experiment_to_layer => {}
       }
+      @diagnostics = diagnostics
 
       @id_list_thread_pool = Concurrent::FixedThreadPool.new(
         options.idlist_threadpool_size,
@@ -42,11 +43,11 @@ module Statsig
           if !@options.data_store.nil?
             puts 'data_store gets priority over bootstrap_values. bootstrap_values will be ignored'
           else
-            init_diagnostics&.mark("bootstrap", "start", "load")
+            tracker = @diagnostics.track('bootstrap', 'process')
             if process_specs(options.bootstrap_values)
               @init_reason = EvaluationReason::BOOTSTRAP
             end
-            init_diagnostics&.mark("bootstrap", "end", "load", @init_reason == EvaluationReason::BOOTSTRAP)
+            tracker.end(@init_reason == EvaluationReason::BOOTSTRAP)
           end
         rescue
           puts 'the provided bootstrapValues is not a valid JSON string'
@@ -54,21 +55,19 @@ module Statsig
       end
 
       unless @options.data_store.nil?
-        init_diagnostics&.mark("data_store", "start", "load")
         @options.data_store.init
-        load_config_specs_from_storage_adapter(init_diagnostics: init_diagnostics)
-        init_diagnostics&.mark("data_store", "end", "load", @init_reason == EvaluationReason::DATA_ADAPTER)
+        load_config_specs_from_storage_adapter
       end
 
       if @init_reason == EvaluationReason::UNINITIALIZED
-        download_config_specs(init_diagnostics)
+        download_config_specs
       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(init_diagnostics)
+        get_id_lists_from_adapter
       else
-        get_id_lists_from_network(init_diagnostics)
+        get_id_lists_from_network
       end
 
       @config_sync_thread = sync_config_specs
@@ -135,20 +134,20 @@ module Statsig
 
     private
 
-    def load_config_specs_from_storage_adapter(init_diagnostics: nil)
-      init_diagnostics&.mark("download_config_specs", "start", "fetch_from_adapter")
+    def load_config_specs_from_storage_adapter
+      tracker = @diagnostics.track('data_store_config_specs', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::CONFIG_SPECS_KEY)
-      init_diagnostics&.mark("download_config_specs", "end", "fetch_from_adapter", true)
+      tracker.end(true)
       return if cached_values.nil?
 
-      init_diagnostics&.mark("download_config_specs", "start", "process")
+      tracker = @diagnostics.track('data_store_config_specs', 'process')
       process_specs(cached_values, from_adapter: true)
       @init_reason = EvaluationReason::DATA_ADAPTER
-      init_diagnostics&.mark("download_config_specs", "end", "process", @init_reason)
+      tracker.end(true)
     rescue StandardError
       # Fallback to network
-      init_diagnostics&.mark("download_config_specs", "end", "fetch_from_adapter", false)
-      download_config_specs(init_diagnostics)
+      tracker.end(false)
+      download_config_specs
     end
 
     def save_config_specs_to_storage_adapter(specs_string)
@@ -160,6 +159,7 @@ module Statsig
 
     def sync_config_specs
       Thread.new do
+        @diagnostics = Diagnostics.new('config_sync')
         loop do
           sleep @options.rulesets_sync_interval
           if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::CONFIG_SPECS_KEY)
@@ -173,6 +173,7 @@ module Statsig
 
     def sync_id_lists
       Thread.new do
+        @diagnostics = Diagnostics.new('config_sync')
         loop do
           sleep @id_lists_sync_interval
           if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::ID_LISTS_KEY)
@@ -184,8 +185,8 @@ module Statsig
       end
     end
 
-    def download_config_specs(init_diagnostics = nil)
-      init_diagnostics&.mark("download_config_specs", "start", "network_request")
+    def download_config_specs
+      tracker = @diagnostics.track('download_config_specs', 'network_request')
 
       error = nil
       begin
@@ -194,18 +195,17 @@ module Statsig
         if e.is_a? NetworkError
           code = e.http_code
         end
-        init_diagnostics&.mark("download_config_specs", "end", "network_request", code)
+        tracker.end(code)
 
         if e.nil?
           unless response.nil?
-            init_diagnostics&.mark("download_config_specs", "start", "process")
-
+            tracker = @diagnostics.track('download_config_specs', 'process')
             if process_specs(response.body.to_s)
               @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?
             end
+            tracker.end(@init_reason == EvaluationReason::NETWORK)
 
-            init_diagnostics&.mark("download_config_specs", "end", "process", @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?
           end
 
           nil
@@ -259,18 +259,18 @@ module Statsig
       true
     end
 
-    def get_id_lists_from_adapter(init_diagnostics = nil)
-      init_diagnostics&.mark("get_id_lists", "start", "fetch_from_adapter")
+    def get_id_lists_from_adapter
+      tracker = @diagnostics.track('data_store_id_lists', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::ID_LISTS_KEY)
       return if cached_values.nil?
 
-      init_diagnostics&.mark("get_id_lists", "end", "fetch_from_adapter", true)
+      tracker.end(true)
       id_lists = JSON.parse(cached_values)
-      process_id_lists(id_lists, init_diagnostics, from_adapter: true)
+      process_id_lists(id_lists, from_adapter: true)
     rescue StandardError
       # Fallback to network
-      init_diagnostics&.mark("get_id_lists", "end", "fetch_from_adapter", false)
-      get_id_lists_from_network(init_diagnostics)
+      tracker.end(false)
+      get_id_lists_from_network
     end
 
     def save_id_lists_to_adapter(id_lists_raw_json)
@@ -280,36 +280,45 @@ module Statsig
       @options.data_store.set(Interfaces::IDataStore::ID_LISTS_KEY, id_lists_raw_json)
     end
 
-    def get_id_lists_from_network(init_diagnostics = nil)
-      init_diagnostics&.mark("get_id_lists", "start", "network_request")
+    def get_id_lists_from_network
+      tracker = @diagnostics.track('get_id_list_sources', 'network_request')
       response, e = @network.post_helper('get_id_lists', JSON.generate({ 'statsigMetadata' => Statsig.get_statsig_metadata }))
+      code = response&.status.to_i
+      if e.is_a? NetworkError
+        code = e.http_code
+      end
+      tracker.end(code)
       if !e.nil? || response.nil?
         return
       end
-      init_diagnostics&.mark("get_id_lists", "end", "network_request", response.status.to_i)
 
       begin
         server_id_lists = JSON.parse(response)
-        process_id_lists(server_id_lists, init_diagnostics)
+        process_id_lists(server_id_lists)
         save_id_lists_to_adapter(response.body.to_s)
       rescue
         # Ignored, will try again
       end
     end
 
-    def process_id_lists(new_id_lists, init_diagnostics, from_adapter: false)
+    def process_id_lists(new_id_lists, 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 = []
 
-      if new_id_lists.length == 0
+      tracker = @diagnostics.track(
+        from_adapter ? 'data_store_id_lists' : 'get_id_list_sources',
+        'process',
+        new_id_lists.length
+      )
+
+      if new_id_lists.empty?
+        tracker.end
         return
       end
 
-      init_diagnostics&.mark("get_id_lists", "start", "process", new_id_lists.length)
-
       delete_lists = []
       local_id_lists.each do |list_name, list|
         unless new_id_lists.key? list_name
@@ -357,14 +366,17 @@ module Statsig
       end
 
       result = Concurrent::Promise.all?(*tasks).execute.wait(@id_lists_sync_interval)
-      init_diagnostics&.mark("get_id_lists", "end", "process", result.state == :fulfilled)
+      tracker.end(result.state == :fulfilled)
     end
 
     def get_single_id_list_from_adapter(list)
+      tracker = @diagnostics.track('data_store_id_list', 'fetch', nil, { url: list.url })
       cached_values = @options.data_store.get("#{Interfaces::IDataStore::ID_LISTS_KEY}::#{list.name}")
+      tracker.end(true)
       content = cached_values.to_s
-      process_single_id_list(list, content)
+      process_single_id_list(list, content, from_adapter: true)
     rescue StandardError
+      tracker.end(false)
       nil
     end
 
@@ -378,7 +390,9 @@ module Statsig
       nil unless list.is_a? IDList
       http = HTTP.headers({ 'Range' => "bytes=#{list&.size || 0}-" }).accept(:json)
       begin
+        tracker = @diagnostics.track('get_id_list', 'network_request', nil, { url: list.url })
         res = http.get(list.url)
+        tracker.end(res.status.code)
         nil unless res.status.success?
         content_length = Integer(res['content-length'])
         nil if content_length.nil? || content_length <= 0
@@ -390,11 +404,13 @@ module Statsig
       end
     end
 
-    def process_single_id_list(list, content, content_length = nil)
+    def process_single_id_list(list, 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', nil, { url: list.url })
         unless content.is_a?(String) && (content[0] == '-' || content[0] == '+')
           @specs[:id_lists].delete(list.name)
+          tracker.end(false)
           return false
         end
         ids_clone = list.ids # clone the list, operate on the new list, and swap out the old list, so the operation is thread-safe
@@ -416,8 +432,10 @@ module Statsig
                     else
                       list.size + content_length
                     end
+        tracker.end(true)
         return true
       rescue
+        tracker.end(false)
         return false
       end
     end

data/lib/statsig.rb

@@ -227,7 +227,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.25.1',
+      'sdkVersion' => '1.25.2',
     }
   end
 

data/lib/statsig_driver.rb

@@ -30,19 +30,20 @@ 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")
+      @evaluator = Statsig::Evaluator.new(@net, @options, error_callback, @diagnostics)
+      tracker.end('success')
 
-      log_init_diagnostics
+      @logger.log_diagnostics_event(@diagnostics)
     })
+    @err_boundary.logger = @logger
   end
 
   class CheckGateOptions < T::Struct
@@ -52,7 +53,7 @@ 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(-> {
+    @err_boundary.capture(task: lambda {
       user = verify_inputs(user, gate_name, "gate_name")
 
       res = @evaluator.check_gate(user, gate_name)
@@ -70,8 +71,7 @@ class StatsigDriver
       end
 
       res.gate_value
-    }, -> { false })
-
+    }, recover: -> { false }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, gate_name: String).void }
@@ -89,10 +89,10 @@ 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(-> {
+    @err_boundary.capture(task: lambda {
       user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
       get_config_impl(user, dynamic_config_name, options)
-    }, -> { DynamicConfig.new(dynamic_config_name) })
+    }, recover: -> { DynamicConfig.new(dynamic_config_name) }, caller: __method__.to_s)
   end
 
   class GetExperimentOptions < T::Struct
@@ -102,10 +102,10 @@ 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(-> {
+    @err_boundary.capture(task: lambda {
       user = verify_inputs(user, experiment_name, "experiment_name")
       get_config_impl(user, experiment_name, options)
-    }, -> { DynamicConfig.new(experiment_name) })
+    }, recover: -> { DynamicConfig.new(experiment_name) }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, config_name: String).void }
@@ -123,7 +123,7 @@ 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(-> {
+    @err_boundary.capture(task: lambda {
       user = verify_inputs(user, layer_name, "layer_name")
 
       res = @evaluator.get_layer(user, layer_name)
@@ -143,9 +143,9 @@ class StatsigDriver
         @logger.log_layer_exposure(user, layer, parameter_name, res)
       } : nil
       Layer.new(res.name, res.json_value, res.rule_id, exposure_log_func)
-    }, -> {
+    }, recover: lambda {
       Layer.new(layer_name)
-    })
+    }, caller: __method__.to_s)
   end
 
   sig { params(user: StatsigUser, layer_name: String, parameter_name: String).void }
@@ -158,7 +158,7 @@ class StatsigDriver
   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
@@ -175,7 +175,7 @@ class StatsigDriver
   end
 
   def shutdown
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @shutdown = true
       @logger.shutdown
       @evaluator.shutdown
@@ -183,13 +183,13 @@ class StatsigDriver
   end
 
   def override_gate(gate_name, gate_value)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.override_gate(gate_name, gate_value)
     })
   end
 
   def override_config(config_name, config_value)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.override_config(config_name, config_value)
     })
   end
@@ -197,11 +197,11 @@ class StatsigDriver
   # @param [StatsigUser] user
   # @return [Hash]
   def get_client_initialize_response(user)
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       validate_user(user)
       normalize_user(user)
       @evaluator.get_client_initialize_response(user)
-    }, -> { nil })
+    }, recover: -> { nil })
   end
 
   def maybe_restart_background_threads
@@ -209,7 +209,7 @@ class StatsigDriver
       return
     end
 
-    @err_boundary.capture(-> {
+    @err_boundary.capture(task: lambda {
       @evaluator.maybe_restart_background_threads
       @logger.maybe_restart_background_threads
     })
@@ -302,12 +302,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_logger.rb

@@ -97,10 +97,14 @@ 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

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/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.25.2
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-31 00:00:00.000000000 Z
+date: 2023-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -295,6 +295,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