statsig 1.25.2 → 1.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f3c8522d7d8062daf248fd667fd0d8152a4194339fde799814a5da44812eda
-  data.tar.gz: 1fd5e67d4a75ab3b5b6c92c780841252a4610e18bc13310f9b11dbb583aaf16a
+  metadata.gz: f4d0e32be6be9e6110bf6237eb4ba33728dfde66385272bb9a15412662455873
+  data.tar.gz: '03408269143b235e02fc8be9f650ed2d4fc778ddf3cc7ffb7242ed9b9494ab73'
 SHA512:
-  metadata.gz: 8f516ca6d221c9d789f1f358b550edeedf4203c01ead45374b97a3b81f4205d09f1c7c3e0214516cdcad314bacbdbde39a5df2053779679fe4df593c974c8300
-  data.tar.gz: a90846ef3c050c7c0b8bddbabd19ed7bff6236a15ed941f55d1a305f4c9cb5ff35f595a3d7ea4ab1560d7f7bae11c669c29d17f8041da9125524669703dc5370
+  metadata.gz: dac08983696816714e346ff1381fa2e83847375d5cee5bd33eb533a83e92be53f33a8fc5217a63b6856f723ca9063a631d4beee260bff95673329f6bfcdd5097
+  data.tar.gz: 8ad5c492697b2b8cb7c06eac670b03230190dbbe9210f4f8ab9bd951bd73ed0c3c91f45353fc4466d2d1295c09366ae95cae109521d98d1041c629d61202c092

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

@@ -7,14 +7,18 @@ module Statsig
     extend T::Sig
 
     sig { returns(String) }
-    attr_reader :context
+    attr_accessor :context
 
     sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
     attr_reader :markers
 
+    sig { returns(T::Hash[String, Numeric]) }
+    attr_accessor :sample_rates
+
     def initialize(context)
       @context = context
       @markers = []
+      @sample_rates = {}
     end
 
     sig do
@@ -22,33 +26,37 @@ module Statsig
         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)
+        tags: T::Hash[Symbol, T.untyped]
       ).void
     end
 
-    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
-                    })
+    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
 
     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)
+        tags: T::Hash[Symbol, T.untyped]
       ).returns(Tracker)
     end
-    def track(key, step = nil, value = nil, metadata = nil)
-      tracker = Tracker.new(self, key, step, metadata)
-      tracker.start(value)
+    def track(key, step = nil, tags = {})
+      tracker = Tracker.new(self, key, step, tags)
+      tracker.start(**tags)
       tracker
     end
 
@@ -61,10 +69,29 @@ module Statsig
       }
     end
 
+    def serialize_with_sampling
+      marker_keys = @markers.map { |e| e[:key] }
+      unique_marker_keys = marker_keys.uniq { |e| e }
+      sampled_marker_keys = unique_marker_keys.select do |key|
+        @sample_rates.key?(key) && !self.class.sample(@sample_rates[key])
+      end
+      final_markers = @markers.select do |marker|
+        !sampled_marker_keys.include?(marker[:key])
+      end
+      {
+        context: @context.clone,
+        markers: final_markers
+      }
+    end
+
     def clear_markers
       @markers.clear
     end
 
+    def self.sample(rate_over_ten_thousand)
+      rand * 10_000 < rate_over_ten_thousand
+    end
+
     class Context
       INITIALIZE = 'initialize'.freeze
       CONFIG_SYNC = 'config_sync'.freeze
@@ -81,22 +108,22 @@ module Statsig
           diagnostics: Diagnostics,
           key: String,
           step: T.any(String, NilClass),
-          metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
+          tags: T::Hash[Symbol, T.untyped]
         ).void
       end
-      def initialize(diagnostics, key, step, metadata)
+      def initialize(diagnostics, key, step, tags = {})
         @diagnostics = diagnostics
         @key = key
         @step = step
-        @metadata = metadata
+        @tags = tags
       end
 
-      def start(value = nil)
-        @diagnostics.mark(@key, 'start', @step, value, @metadata)
+      def start(**tags)
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags))
       end
 
-      def end(value = nil)
-        @diagnostics.mark(@key, 'end', @step, value, @metadata)
+      def end(**tags)
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags))
       end
     end
   end

data/lib/error_boundary.rb

@@ -9,70 +9,56 @@ 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 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
         res = task.call
-        tracker&.end(true)
-      rescue StandardError => e
-        tracker&.end(false)
-        if e.is_a?(Statsig::UninitializedError) or e.is_a?(Statsig::ValueError)
+      rescue StandardError, SystemStackError => e
+        if e.is_a?(Statsig::UninitializedError) || e.is_a?(Statsig::ValueError)
           raise e
         end
+
         puts '[Statsig]: An unexpected exception occurred.'
-        log_exception(e)
+        log_exception(e, tag: caller)
         res = recover.call
       end
-      @logger&.log_diagnostics_event(diagnostics)
       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, diagnostics)
-      @spec_store = Statsig::SpecStore.new(network, options, error_callback, 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

@@ -5,8 +5,9 @@ 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
@@ -22,7 +23,6 @@ module Statsig
     extend T::Sig
 
     sig { params(server_secret: String, options: StatsigOptions, backoff_mult: Integer).void }
-
     def initialize(server_secret, options, backoff_mult = 10)
       super()
       URIHelper.initialize(options)
@@ -33,29 +33,35 @@ module Statsig
       @post_logs_retry_backoff = options.post_logs_retry_backoff
       @post_logs_retry_limit = options.post_logs_retry_limit
       @session_id = SecureRandom.uuid
-    end
+      @connection_pool = ConnectionPool.new(size: 3) do
+        meta = Statsig.get_statsig_metadata
+        client = HTTP.use(:auto_inflate).headers(
+          {
+            'STATSIG-API-KEY' => @server_secret,
+            'STATSIG-SERVER-SESSION-ID' => @session_id,
+            'Content-Type' => 'application/json; charset=UTF-8',
+            'STATSIG-SDK-TYPE' => meta['sdkType'],
+            'STATSIG-SDK-VERSION' => meta['sdkVersion'],
+            'Accept-Encoding' => 'gzip'
+          }
+        ).accept(:json)
+        if @timeout
+          client = client.timeout(@timeout)
+        end
 
-    sig { params(endpoint: String, body: String, retries: Integer, backoff: Integer)
-            .returns([T.any(HTTP::Response, NilClass), T.any(StandardError, NilClass)]) }
+        client
+      end
+    end
 
+    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
@@ -66,48 +72,53 @@ module Statsig
       end
       url = URIHelper.build_url(endpoint)
       begin
-        res = http.post(url, 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 #{url}: #{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