statsig 1.25.2 → 1.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f3c8522d7d8062daf248fd667fd0d8152a4194339fde799814a5da44812eda
-  data.tar.gz: 1fd5e67d4a75ab3b5b6c92c780841252a4610e18bc13310f9b11dbb583aaf16a
+  metadata.gz: 72119a11268473774b98457f89017155813cdaab4c19b8f07e1aad370ae6dd17
+  data.tar.gz: 69cb96c04c6b9c322bb239332b8c406a6b543bb42b0cab6da9e641d44fa15371
 SHA512:
-  metadata.gz: 8f516ca6d221c9d789f1f358b550edeedf4203c01ead45374b97a3b81f4205d09f1c7c3e0214516cdcad314bacbdbde39a5df2053779679fe4df593c974c8300
-  data.tar.gz: a90846ef3c050c7c0b8bddbabd19ed7bff6236a15ed941f55d1a305f4c9cb5ff35f595a3d7ea4ab1560d7f7bae11c669c29d17f8041da9125524669703dc5370
+  metadata.gz: d75c0a0d9c6529843c554d05b3ae49e6d863cd01da11f932e679bddddffab4287ef036af37c3cd8fff9310c10cd6758bc6e5435f78626245c5d1f315b91e09eb
+  data.tar.gz: b9886d0b78d1491393cfacdea4c1f4cdeae1d2a993a0f5a0875011be1083bb63e4a7721fb3a007869eaa7eaf69ad300438d8038c099e88277958d4daf6d226f7

data/lib/client_initialize_helpers.rb

@@ -1,4 +1,8 @@
 # typed: true
+
+require_relative 'hash_utils'
+require 'sorbet-runtime'
+
 $empty_eval_result = {
   :gate_value => false,
   :json_value => {},
@@ -9,10 +13,14 @@ $empty_eval_result = {
 
 module ClientInitializeHelpers
   class ResponseFormatter
-    def initialize(evaluator, user)
+    extend T::Sig
+
+    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)
@@ -23,7 +31,21 @@ module ClientInitializeHelpers
 
     private
 
+    sig { params(secondary_exposures: T::Array[T::Hash[String, String]]).returns(T::Array[T::Hash[String, String]]) }
+    def filter_segments_from_secondary_exposures(secondary_exposures)
+      secondary_exposures.reject do |exposure|
+        exposure['gate'].to_s.start_with?('segment:')
+      end
+    end
+
     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,9 +55,11 @@ 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,
+        :secondary_exposures => filter_segments_from_secondary_exposures(eval_result.secondary_exposures),
         :undelegated_sec_exps => eval_result.undelegated_sec_exps
       }
 
@@ -52,10 +76,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 +95,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)
@@ -75,7 +104,7 @@ module ClientInitializeHelpers
           "name" => hashed_name,
           "rule_id" => safe_eval_result[:rule_id],
           "secondary_exposures" => clean_exposures(safe_eval_result[:secondary_exposures])
-        })]
+        }).compact]
     end
 
     def clean_exposures(exposures)
@@ -126,7 +155,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/config_result.rb

@@ -1,6 +1,11 @@
 # typed: true
+
+require 'sorbet-runtime'
+
 module Statsig
   class ConfigResult
+    extend T::Sig
+
     attr_accessor :name
     attr_accessor :gate_value
     attr_accessor :json_value
@@ -13,6 +18,7 @@ module Statsig
     attr_accessor :evaluation_details
     attr_accessor :group_name
     attr_accessor :id_type
+    attr_accessor :target_app_ids
 
     def initialize(
       name,
@@ -20,12 +26,13 @@ module Statsig
       json_value = {},
       rule_id = '',
       secondary_exposures = [],
-      config_delegate = '',
+      config_delegate = nil,
       explicit_parameters = [],
       is_experiment_group: false,
       evaluation_details: nil,
       group_name: nil,
-      id_type: '')
+      id_type: '',
+      target_app_ids: nil)
       @name = name
       @gate_value = gate_value
       @json_value = json_value
@@ -38,6 +45,45 @@ module Statsig
       @evaluation_details = evaluation_details
       @group_name = group_name
       @id_type = id_type
+      @target_app_ids = target_app_ids
+    end
+
+    sig { params(config_name: String, user_persisted_values: UserPersistedValues).returns(T.nilable(ConfigResult)) }
+    def self.from_user_persisted_values(config_name, user_persisted_values)
+      sticky_values = user_persisted_values[config_name]
+      return nil if sticky_values.nil?
+
+      from_hash(config_name, sticky_values)
+    end
+
+    sig { params(config_name: String, hash: Hash).returns(ConfigResult) }
+    def self.from_hash(config_name, hash)
+      new(
+        config_name,
+        hash['gate_value'],
+        hash['json_value'],
+        hash['rule_id'],
+        hash['secondary_exposures'],
+        evaluation_details: EvaluationDetails.persisted(hash['config_sync_time'], hash['init_time']),
+        group_name: hash['group_name'],
+        id_type: hash['id_type'],
+        target_app_ids: hash['target_app_ids']
+      )
+    end
+
+    sig { returns(Hash) }
+    def to_hash
+      {
+        json_value: @json_value,
+        gate_value: @gate_value,
+        rule_id: @rule_id,
+        secondary_exposures: @secondary_exposures,
+        config_sync_time: @evaluation_details.config_sync_time,
+        init_time: @init_time,
+        group_name: @group_name,
+        id_type: @id_type,
+        target_app_ids: @target_app_ids
+      }
     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/dynamic_config.rb

@@ -26,13 +26,26 @@ class DynamicConfig
   sig { returns(String) }
   attr_accessor :id_type
 
-  sig { params(name: String, value: T::Hash[String, T.untyped], rule_id: String, group_name: T.nilable(String), id_type: String).void }
-  def initialize(name, value = {}, rule_id = '', group_name = nil, id_type = '')
+  sig { returns(T.nilable(Statsig::EvaluationDetails)) }
+  attr_accessor :evaluation_details
+
+  sig do
+    params(
+      name: String,
+      value: T::Hash[String, T.untyped],
+      rule_id: String,
+      group_name: T.nilable(String),
+      id_type: String,
+      evaluation_details: T.nilable(Statsig::EvaluationDetails)
+    ).void
+  end
+  def initialize(name, value = {}, rule_id = '', group_name = nil, id_type = '', evaluation_details = nil)
     @name = name
     @value = value
     @rule_id = rule_id
     @group_name = group_name
     @id_type = id_type
+    @evaluation_details = evaluation_details
   end
 
   sig { params(index: String, default_value: T.untyped).returns(T.untyped) }

data/lib/error_boundary.rb

@@ -9,70 +9,58 @@ 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)
+        puts e.message
+        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'],
+          'STATSIG-SDK-LANGUAGE-VERSION' => meta['languageVersion'],
+          '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/evaluation_details.rb

@@ -2,12 +2,13 @@
 module Statsig
 
   module EvaluationReason
-    NETWORK = "Network"
-    LOCAL_OVERRIDE = "LocalOverride"
-    UNRECOGNIZED = "Unrecognized"
-    UNINITIALIZED = "Uninitialized"
-    BOOTSTRAP = "Bootstrap"
-    DATA_ADAPTER = "DataAdapter"
+    NETWORK = 'Network'.freeze
+    LOCAL_OVERRIDE = 'LocalOverride'.freeze
+    UNRECOGNIZED = 'Unrecognized'.freeze
+    UNINITIALIZED = 'Uninitialized'.freeze
+    BOOTSTRAP = 'Bootstrap'.freeze
+    DATA_ADAPTER = 'DataAdapter'.freeze
+    PERSISTED = 'Persisted'.freeze
   end
 
   class EvaluationDetails
@@ -38,5 +39,9 @@ module Statsig
     def self.local_override(config_sync_time, init_time)
       EvaluationDetails.new(config_sync_time, init_time, EvaluationReason::LOCAL_OVERRIDE)
     end
+
+    def self.persisted(config_sync_time, init_time)
+      EvaluationDetails.new(config_sync_time, init_time, EvaluationReason::PERSISTED)
+    end
   end
-end
+end