statsig 1.25.1 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1772b0fb47eaaf4b95950425eeba70ea7b792a8e5aad952b67e7aea8000d06b
-  data.tar.gz: 2e75c8c1c9e68817440dd73d98020f99f20e80255424fb499dff8d3464eb39ba
+  metadata.gz: 42f5328314de8727a2baaf89da54999627a5505ad95cd5ab816877741e02dd55
+  data.tar.gz: f6af1d20f540ceae4e24c70bdc702fbd9db3acc38776b71ecc50ded6ef40f67d
 SHA512:
-  metadata.gz: 5f291605da74348e702b8258ca52c6bb609d6359c961a862d76c50e7a53b348bb7705ed6ac2e3da2b68ea89c2db852feb50f5213d5c9543af665142e8cc2bc15
-  data.tar.gz: 3f1923846883e667b5f5ae14c9efd90fd295a3c0336be262ec879227b3af85b513f9dc407687e8f6273e911644b40bbde7324ff86fc3bc7b26e4a3fd9345992b
+  metadata.gz: 8c4375a325bf7dd1afaa584951b31eca2fd19422301b72397729fdca89e1ef8ae9b7a979aff562889cf49fc98fcd7db3edfc022ca66eb063b2680645c90df2db
+  data.tar.gz: ab23702707825b1ed5ada0df1982d765b97b75e8d813aeeaa9f24ae31974bb0cafa58249e82cc041eaa845bea9ee7639189c8778f8e21e0908b7ec3174d41661

data/lib/client_initialize_helpers.rb

@@ -1,4 +1,7 @@
 # typed: true
+
+require_relative 'hash_utils'
+
 $empty_eval_result = {
   :gate_value => false,
   :json_value => {},
@@ -9,10 +12,12 @@ $empty_eval_result = {
 
 module ClientInitializeHelpers
   class ResponseFormatter
-    def initialize(evaluator, user)
+    def initialize(evaluator, user, hash, client_sdk_key)
       @evaluator = evaluator
       @user = user
       @specs = evaluator.spec_store.get_raw_specs
+      @hash = hash
+      @client_sdk_key = client_sdk_key
     end
 
     def get_responses(key)
@@ -24,6 +29,13 @@ module ClientInitializeHelpers
     private
 
     def to_response(config_name, config_spec)
+      target_app_id = @evaluator.spec_store.get_app_id_for_sdk_key(@client_sdk_key)
+      config_target_apps = config_spec['targetAppIDs']
+
+      unless target_app_id.nil? || config_target_apps.nil? || config_target_apps.include?(target_app_id)
+        return nil
+      end
+
       eval_result = @evaluator.eval_spec(@user, config_spec)
       if eval_result.nil?
         return nil
@@ -33,6 +45,8 @@ module ClientInitializeHelpers
         :gate_value => eval_result.gate_value,
         :json_value => eval_result.json_value,
         :rule_id => eval_result.rule_id,
+        :group_name => eval_result.group_name,
+        :id_type => eval_result.id_type,
         :config_delegate => eval_result.config_delegate,
         :is_experiment_group => eval_result.is_experiment_group,
         :secondary_exposures => eval_result.secondary_exposures,
@@ -52,10 +66,14 @@ module ClientInitializeHelpers
         end
 
         result['value'] = safe_eval_result[:gate_value]
+        result["group_name"] = safe_eval_result[:group_name]
+        result["id_type"] = safe_eval_result[:id_type]
       when 'dynamic_config'
         id_type = config_spec['idType']
         result['value'] = safe_eval_result[:json_value]
         result["group"] = safe_eval_result[:rule_id]
+        result["group_name"] = safe_eval_result[:group_name]
+        result["id_type"] = safe_eval_result[:id_type]
         result["is_device_based"] = id_type.is_a?(String) && id_type.downcase == 'stableid'
       else
         return nil
@@ -67,6 +85,7 @@ module ClientInitializeHelpers
 
       if entity_type == 'layer'
         populate_layer_fields(config_spec, safe_eval_result, result)
+        result.delete('id_type') # not exposed for layer configs in /initialize
       end
 
       hashed_name = hash_name(config_name)
@@ -126,7 +145,14 @@ module ClientInitializeHelpers
     end
 
     def hash_name(name)
-      Digest::SHA256.base64digest(name)
+      case @hash
+      when 'none'
+        return name
+      when 'sha256'
+        return Statsig::HashUtils.sha256(name)
+      when 'djb2'
+        return Statsig::HashUtils.djb2(name)
+      end
     end
   end
-end
+end

data/lib/diagnostics.rb

@@ -12,33 +12,100 @@ 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),
+        tags: T::Hash[Symbol, T.untyped]
+      ).void
+    end
+
+    def mark(key, action, step, tags)
+      marker = {
+        key: key,
+        action: action,
+        timestamp: (Time.now.to_f * 1000).to_i
+      }
+      if !step.nil?
+        marker[:step] = step
+      end
+      tags.each do |key, val|
+        unless val.nil?
+          marker[key] = val
+        end
+      end
+      @markers.push(marker)
+    end
 
-    def mark(key, action, step = nil, value = nil)
-      @markers.push({
-                      key: key,
-                      step: step,
-                      action: action,
-                      value: value,
-                      timestamp: (Time.now.to_f * 1000).to_i
-                    })
+    sig do
+      params(
+        key: String,
+        step: T.any(String, NilClass),
+        tags: T::Hash[Symbol, T.untyped]
+      ).returns(Tracker)
+    end
+    def track(key, step = nil, tags = {})
+      tracker = Tracker.new(self, key, step, tags)
+      tracker.start(**tags)
+      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
+
+    def self.sample(rate)
+      rand(rate).zero?
+    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),
+          tags: T::Hash[Symbol, T.untyped]
+        ).void
+      end
+      def initialize(diagnostics, key, step, tags = {})
+        @diagnostics = diagnostics
+        @key = key
+        @step = step
+        @tags = tags
+      end
+
+      def start(**tags)
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags))
+      end
+
+      def end(**tags)
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags))
+      end
+    end
+  end
+end

data/lib/error_boundary.rb

@@ -1,57 +1,64 @@
-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 { params(sdk_key: String).void }
     def initialize(sdk_key)
       @sdk_key = sdk_key
       @seen = Set.new
     end
 
-    def capture(task, recover = -> {})
+    def capture(task:, recover: -> {}, caller: nil)
       begin
-        return task.call
+        res = task.call
       rescue StandardError => e
-        if e.is_a?(Statsig::UninitializedError) or e.is_a?(Statsig::ValueError)
+        if e.is_a?(Statsig::UninitializedError) || e.is_a?(Statsig::ValueError)
           raise e
         end
-        puts "[Statsig]: An unexpected exception occurred."
-        log_exception(e)
-        return recover.call
+
+        puts '[Statsig]: An unexpected exception occurred.'
+        log_exception(e, tag: caller)
+        res = recover.call
       end
+      return res
     end
 
     private
 
-    def log_exception(exception)
-      begin
-        name = exception.class.name
-        if @seen.include?(name)
-          return
-        end
-
-        @seen << name
-        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"
-          }).accept(:json)
-        body = {
-          "exception" => name,
-          "info" => {
-            "trace" => exception.backtrace.to_s,
-            "message" => exception.message
-          }.to_s,
-          "statsigMetadata" => meta
-        }
-        http.post($endpoint, body: JSON.generate(body))
-      rescue
+    def log_exception(exception, tag: nil)
+      name = exception.class.name
+      if @seen.include?(name)
         return
       end
+
+      @seen << name
+      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'
+        }).accept(:json)
+      body = {
+        'exception' => name,
+        'info' => {
+          'trace' => exception.backtrace.to_s,
+          'message' => exception.message
+        }.to_s,
+        'statsigMetadata' => meta,
+        'tag' => tag
+      }
+      http.post($endpoint, body: JSON.generate(body))
+    rescue StandardError
+      return
     end
   end
-end
+end

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, error_boundary, logger)
+      @spec_store = Statsig::SpecStore.new(network, options, error_callback, diagnostics, error_boundary, logger)
       UAParser.initialize_async
       CountryLookup.initialize_async
 
@@ -98,12 +98,12 @@ module Statsig
       eval_spec(user, @spec_store.get_layer(layer_name))
     end
 
-    def get_client_initialize_response(user)
+    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 +123,7 @@ module Statsig
         "generator" => "statsig-ruby-sdk",
         "evaluated_keys" => evaluated_keys,
         "time" => 0,
+        "hash_used" => hash
       }
     end
 
@@ -199,7 +200,7 @@ module Statsig
           @spec_store.initial_config_sync_time,
           @spec_store.init_reason
         ),
-        group_name: nil,
+        group_name: 'default',
         id_type: config['idType']
       )
     end

data/lib/hash_utils.rb

@@ -0,0 +1,17 @@
+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.sha256(input_str)
+      return Digest::SHA256.base64digest(input_str)
+    end
+  end
+end

data/lib/network.rb

@@ -4,8 +4,10 @@ require 'http'
 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
@@ -24,41 +26,44 @@ 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
       @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.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
+          client = client.timeout(@timeout)
+        end
+
+        client
+      end
     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_helper(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
@@ -67,49 +72,55 @@ 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 = @connection_pool.with do |conn|
+          conn.headers('STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s).post(url, body: body)
+        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)
       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)
+
+      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)
     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_helper('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_helper('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_helper('log_event', json_body, @post_logs_retry_limit)
+    rescue StandardError
+
     end
   end
-end
+end