Merge pull request #19 from statsig-io/releases/v1.25.2

v1.25.2

Author: kenny-statsig

.rubocop.yml

@@ -17,4 +17,10 @@ Style/Documentation:
 Style/IfUnlessModifier:
   Enabled: false
 Style/ConditionalAssignment:
+  Enabled: false
+Style/RedundantReturn:
+  Enabled: false
+Style/SlicingWithRange:
+  Enabled: false
+Style/AccessorGrouping:
   Enabled: false

lib/diagnostics.rb

@@ -12,33 +12,92 @@ class Diagnostics
     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

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 @@ def log_exception(exception)
         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

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
 

lib/network.rb

@@ -4,6 +4,7 @@
 require 'json'
 require 'securerandom'
 require 'sorbet-runtime'
+require 'uri_helper'
 
 $retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
 
@@ -24,12 +25,8 @@ class Network
 
     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,16 +64,17 @@ def post_helper(endpoint, body, retries = 0, backoff = 1)
           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
         sleep backoff_adjusted
         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)