statsig 2.2.2 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24c2882bd3f5fbf4aeaaac8889ec9eff344202c962b655ce5f638b0beb0d4118
-  data.tar.gz: fe2d3822d6ff0fea02710b5c2f07b7ba6ca900cc2b1abc52269b8b0a2e26f585
+  metadata.gz: 1591515ecdce353516857952fae0e460997315f7c764f680a30df065821d36c4
+  data.tar.gz: 4818db100a200ade728aa7b3db42008313b975ed951e37ff9d72f46fe269580d
 SHA512:
-  metadata.gz: 723cd162782fcad1dda2858102ea92a21c1b58989e6f8d7a399d64f5f0944bdc044fbfe1aa53110745b4a821779ea8b371963834db9e72e20af4c90f71ede860
-  data.tar.gz: 45c320a711d630d1b25e36094ba1f2007e287457609635dcd6d27ea3ab85e802a85517d62d926cd1108a0f453ba7dd39e4941ff6fea7ead4cdfac605365170ba
+  metadata.gz: fe639606633dce22ad66d8216149c2f3db9136c1c2a33799320671df9dc839e06554a91688bc0baf0a638bd29a0258822cc169cc5e01ce8630c5a108d8e883f9
+  data.tar.gz: 31912d0a1c2113ce74716987a666695cda53b5532ed154677135332fe17983b145c39d182cc193a510e857083f0290491dfea90df6efe5850935071b3f3dbb64

data/lib/config_result.rb

@@ -18,6 +18,9 @@ module Statsig
     attr_accessor :disable_exposures
     attr_accessor :config_version
     attr_accessor :include_local_overrides
+    attr_accessor :forward_all_exposures
+    attr_accessor :sampling_rate
+    attr_accessor :has_seen_analytical_gates
 
     def initialize(
       name:,
@@ -35,7 +38,10 @@ module Statsig
       disable_evaluation_details: false,
       disable_exposures: false,
       config_version: nil,
-      include_local_overrides: true
+      include_local_overrides: true,
+      forward_all_exposures: false,
+      sampling_rate: nil,
+      has_seen_analytical_gates: false
     )
       @name = name
       @gate_value = gate_value
@@ -54,6 +60,9 @@ module Statsig
       @disable_exposures = disable_exposures
       @config_version = config_version
       @include_local_overrides = include_local_overrides
+      @forward_all_exposures = forward_all_exposures
+      @sampling_rate = sampling_rate
+      @has_seen_analytical_gates = has_seen_analytical_gates
     end
 
     def self.from_user_persisted_values(config_name, user_persisted_values)

data/lib/evaluator.rb

@@ -302,6 +302,7 @@ module Statsig
 
     def eval_spec(config_name, user, config, end_result, is_nested: false)
       config[:rules].each do |rule|
+        end_result.sampling_rate = rule[:samplingRate]
         eval_rule(user, rule, end_result)
 
         if end_result.gate_value
@@ -325,6 +326,7 @@ module Statsig
       end_result.id_type = config[:idType]
       end_result.target_app_ids = config[:targetAppIDs]
       end_result.gate_value = did_pass
+      end_result.forward_all_exposures = config[:forwardAllExposures]
       if config[:entity] == Const::TYPE_FEATURE_GATE
         end_result.gate_value = did_pass ? rule[:returnValue] == true : config[:defaultValue] == true
       end
@@ -340,6 +342,7 @@ module Statsig
         end_result.group_name = rule[:groupName]
         end_result.is_experiment_group = rule[:isExperimentGroup] == true
         end_result.rule_id = rule[:id]
+        end_result.sampling_rate = rule[:samplingRate]
       end
 
       unless end_result.disable_evaluation_details
@@ -425,6 +428,9 @@ module Statsig
         return true
       when Const::CND_PASS_GATE, Const::CND_FAIL_GATE
         result = eval_nested_gate(target, user, end_result)
+        if end_result.sampling_rate == nil && !target.start_with?("segment")
+          end_result.has_seen_analytical_gates = true
+        end
         return type == Const::CND_PASS_GATE ? result : !result
       when Const::CND_MULTI_PASS_GATE, Const::CND_MULTI_FAIL_GATE
         return eval_nested_gates(target, type, user, end_result)
@@ -612,7 +618,9 @@ module Statsig
       is_multi_pass_gate_type = condition_type == Const::CND_MULTI_PASS_GATE
       gate_names.each { |gate_name|
         result = eval_nested_gate(gate_name, user, end_result)
-
+        if end_result.sampling_rate == nil && !target.start_with?("segment")
+          end_result.has_seen_analytical_gates = true
+        end
         if is_multi_pass_gate_type == result
           has_passing_gate = true
           break

data/lib/hash_utils.rb

@@ -1,4 +1,8 @@
 require 'json'
+require 'digest'
+
+TWO_TO_THE_63 = 1 << 63
+TWO_TO_THE_64 = 1 << 64
 module Statsig
   class HashUtils
     def self.djb2(input_str)
@@ -32,5 +36,46 @@ module Statsig
       end
       return dictionary
     end
+
+    def self.bigquery_hash(string)
+      digest = Digest::SHA256.digest(string)
+      num = digest[0...8].unpack('Q>')[0]
+      
+      if num >= TWO_TO_THE_63
+        num - TWO_TO_THE_64
+      else
+        num
+      end
+    end
+
+    def self.is_hash_in_sampling_rate(key, sampling_rate)
+      hash_key = bigquery_hash(key)
+      hash_key % sampling_rate == 0
+    end
+
+    def self.compute_dedupe_key_for_gate(gate_name, rule_id, value, user_id, custom_ids = nil)
+      user_key = compute_user_key(user_id, custom_ids)
+      "n:#{gate_name};u:#{user_key}r:#{rule_id};v:#{value}"
+    end
+
+    def self.compute_dedupe_key_for_config(config_name, rule_id, user_id, custom_ids = nil)
+      user_key = compute_user_key(user_id, custom_ids)
+      "n:#{config_name};u:#{user_key}r:#{rule_id}"
+    end
+
+    def self.compute_dedupe_key_for_layer(layer_name, experiment_name, parameter_name, rule_id, user_id, custom_ids = nil)
+      user_key = compute_user_key(user_id, custom_ids)
+      "n:#{layer_name};e:#{experiment_name};p:#{parameter_name};u:#{user_key}r:#{rule_id}"
+    end
+
+    def self.compute_user_key(user_id, custom_ids = nil)
+      user_key = "u:#{user_id};"
+      if custom_ids
+        custom_ids.each do |k, v|
+          user_key += "#{k}:#{v};"
+        end
+      end
+      user_key
+    end
   end
 end

data/lib/sdk_configs.rb

@@ -0,0 +1,37 @@
+require 'concurrent-ruby'
+
+module Statsig
+  class SDKConfigs
+    def initialize
+      @configs = Concurrent::Hash.new
+      @flags = Concurrent::Hash.new
+    end
+
+    def set_flags(new_flags)
+      @flags = new_flags || Concurrent::Hash.new
+    end
+
+    def set_configs(new_configs)
+      @configs = new_configs || Concurrent::Hash.new
+    end
+
+    def on(flag)
+      @flags[flag.to_sym] == true
+    end
+
+    def get_config_num_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(Numeric) ? value.to_f : nil
+    end
+
+    def get_config_string_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(String) ? value : nil
+    end
+
+    def get_config_int_value(config)
+      value = @configs[config.to_sym]
+      value.is_a?(Integer) ? value : nil
+    end
+  end
+end

data/lib/spec_store.rb

@@ -20,7 +20,7 @@ module Statsig
     attr_accessor :hashed_sdk_keys_to_app_ids
     attr_accessor :unsupported_configs
 
-    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key)
+    def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key, sdk_config)
       @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
       @options = options
@@ -43,6 +43,7 @@ module Statsig
       @logger = logger
       @secret_key = secret_key
       @unsupported_configs = Set.new
+      @sdk_configs = sdk_config
 
       startTime = (Time.now.to_f * 1000).to_i
 
@@ -342,6 +343,8 @@ module Statsig
         @experiment_to_layer = specs_json[:experiment_to_layer]
         @sdk_keys_to_app_ids = specs_json[:sdk_keys_to_app_ids] || {}
         @hashed_sdk_keys_to_app_ids = specs_json[:hashed_sdk_keys_to_app_ids] || {}
+        @sdk_configs.set_flags(specs_json[:sdk_flags])
+        @sdk_configs.set_configs(specs_json[:sdk_configs])
 
         unless from_adapter
           save_rulesets_to_storage_adapter(specs_string)

data/lib/statsig.rb

@@ -370,7 +370,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '2.2.2',
+      'sdkVersion' => '2.3.1',
       'languageVersion' => RUBY_VERSION
     }
   end

data/lib/statsig_driver.rb

@@ -13,6 +13,7 @@ require 'error_boundary'
 require 'layer'
 require 'memo'
 require 'diagnostics'
+require 'sdk_configs'
 
 class StatsigDriver
 
@@ -27,15 +28,16 @@ class StatsigDriver
 
     @err_boundary = Statsig::ErrorBoundary.new(secret_key, !options.nil? && options.local_mode)
     @err_boundary.capture(caller: __method__) do
-      @diagnostics = Statsig::Diagnostics.new()
+      @diagnostics = Statsig::Diagnostics.new
+      @sdk_configs = Statsig::SDKConfigs.new
       tracker = @diagnostics.track('initialize', 'overall')
       @options = options || StatsigOptions.new
       @shutdown = false
       @secret_key = secret_key
       @net = Statsig::Network.new(secret_key, @options)
-      @logger = Statsig::StatsigLogger.new(@net, @options, @err_boundary)
+      @logger = Statsig::StatsigLogger.new(@net, @options, @err_boundary, @sdk_configs)
       @persistent_storage_utils = Statsig::UserPersistentStorageUtils.new(@options)
-      @store = Statsig::SpecStore.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger, secret_key)
+      @store = Statsig::SpecStore.new(@net, @options, error_callback, @diagnostics, @err_boundary, @logger, secret_key, @sdk_configs)
       @evaluator = Statsig::Evaluator.new(@store, @options, @persistent_storage_utils)
       tracker.end(success: true)
 

data/lib/statsig_logger.rb

@@ -1,15 +1,24 @@
 require 'constants'
 require 'statsig_event'
+require 'ttl_set'
 require 'concurrent-ruby'
+require 'hash_utils'
 
 $gate_exposure_event = 'statsig::gate_exposure'
 $config_exposure_event = 'statsig::config_exposure'
 $layer_exposure_event = 'statsig::layer_exposure'
 $diagnostics_event = 'statsig::diagnostics'
 $ignored_metadata_keys = [:serverTime, :configSyncTime, :initTime, :reason]
+
+class EntityType
+  GATE = "gate"
+  CONFIG = "config"
+  LAYER = "layer"
+end
+
 module Statsig
   class StatsigLogger
-    def initialize(network, options, error_boundary)
+    def initialize(network, options, error_boundary, sdk_configs)
       @network = network
       @events = []
       @options = options
@@ -25,10 +34,12 @@ module Statsig
 
       @error_boundary = error_boundary
       @background_flush = periodic_flush
-      @deduper = Concurrent::Set.new()
+      @deduper = Concurrent::Set.new
+      @sampling_key_set = Statsig::TTLSet.new
       @interval = 0
       @flush_mutex = Mutex.new
       @debug_info = nil
+      @sdk_configs = sdk_configs
     end
 
     def log_event(event)
@@ -39,6 +50,8 @@ module Statsig
     end
 
     def log_gate_exposure(user, result, context = nil)
+      should_log, logged_sampling_rate, shadow_logged = determine_sampling(EntityType::GATE, result.name, result, user)
+      return unless should_log
       event = StatsigEvent.new($gate_exposure_event)
       event.user = user
       metadata = {
@@ -54,15 +67,19 @@ module Statsig
       end
       return false if not is_unique_exposure(user, $gate_exposure_event, metadata)
       event.metadata = metadata
+      event.statsig_metadata = {}
 
       event.secondary_exposures = result.secondary_exposures.is_a?(Array) ? result.secondary_exposures : []
 
       safe_add_eval_details(result.evaluation_details, event)
       safe_add_exposure_context(context, event)
+      safe_add_sampling_metadata(event, logged_sampling_rate, shadow_logged)
       log_event(event)
     end
 
     def log_config_exposure(user, result, context = nil)
+      should_log, logged_sampling_rate, shadow_logged = determine_sampling(EntityType::CONFIG, result.name, result, user)
+      return unless should_log
       event = StatsigEvent.new($config_exposure_event)
       event.user = user
       metadata = {
@@ -79,9 +96,11 @@ module Statsig
       return false if not is_unique_exposure(user, $config_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = result.secondary_exposures.is_a?(Array) ? result.secondary_exposures : []
+      event.statsig_metadata = {}
 
       safe_add_eval_details(result.evaluation_details, event)
       safe_add_exposure_context(context, event)
+      safe_add_sampling_metadata(event, logged_sampling_rate, shadow_logged)
       log_event(event)
     end
 
@@ -94,6 +113,9 @@ module Statsig
         exposures = config_evaluation.secondary_exposures
       end
 
+      should_log, logged_sampling_rate, shadow_logged = determine_sampling(EntityType::LAYER, config_evaluation.name, config_evaluation, user, allocated_experiment, parameter_name)
+      return unless should_log
+
       event = StatsigEvent.new($layer_exposure_event)
       event.user = user
       metadata = {
@@ -112,9 +134,11 @@ module Statsig
       return false unless is_unique_exposure(user, $layer_exposure_event, metadata)
       event.metadata = metadata
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
+      event.statsig_metadata = {}
 
       safe_add_eval_details(config_evaluation.evaluation_details, event)
       safe_add_exposure_context(context, event)
+      safe_add_sampling_metadata(event, logged_sampling_rate, shadow_logged)
       log_event(event)
     end
 
@@ -150,6 +174,7 @@ module Statsig
 
     def shutdown
       @background_flush&.exit
+      @sampling_key_set.shutdown
       @logging_pool.shutdown
       @logging_pool.wait_for_termination(timeout = 3)
       flush
@@ -207,6 +232,18 @@ module Statsig
       end
     end
 
+    def safe_add_sampling_metadata(event, logged_sampling_rate = nil, shadow_logged = nil)
+      unless logged_sampling_rate.nil?
+        event.statsig_metadata["samplingRate"] = logged_sampling_rate
+      end
+
+      unless shadow_logged.nil?
+        event.statsig_metadata["shadowLogged"] = shadow_logged
+      end
+
+      event.statsig_metadata["samplingMode"] = @sdk_configs.get_config_string_value("sampling_mode")
+    end
+
     def is_unique_exposure(user, event_name, metadata)
       return true if user.nil?
       @deduper.clear if @deduper.size > 10000
@@ -224,5 +261,69 @@ module Statsig
       @deduper.add(key)
       true
     end
+
+    def determine_sampling(type, name, result, user, exp_name = "", param_name = "")
+      begin
+        shadow_should_log, logged_sampling_rate = true, nil
+        env = @options.environment&.dig(:tier)
+        sampling_mode = @sdk_configs.get_config_string_value("sampling_mode")
+        special_case_sampling_rate = @sdk_configs.get_config_int_value("special_case_sampling_rate")
+        special_case_rules = ["disabled", "default", ""]
+
+        if sampling_mode.nil? || sampling_mode == "none" || env != "production"
+          return true, nil, nil
+        end
+
+        return true, nil, nil if result.forward_all_exposures
+        return true, nil, nil if result.rule_id.end_with?(":override", ":id_override")
+        return true, nil, nil if result.has_seen_analytical_gates
+
+        sampling_set_key = "#{name}_#{result.rule_id}"
+        unless @sampling_key_set.contains?(sampling_set_key)
+          @sampling_key_set.add(sampling_set_key)
+          return true, nil, nil
+        end
+
+        should_sample = result.sampling_rate || special_case_rules.include?(result.rule_id)
+        unless should_sample
+          return true, nil, nil
+        end
+
+        exposure_key = ""
+        case type
+        when EntityType::GATE
+          exposure_key = Statsig::HashUtils.compute_dedupe_key_for_gate(name, result.rule_id, result.gate_value, user.user_id, user.custom_ids)
+        when EntityType::CONFIG
+          exposure_key = Statsig::HashUtils.compute_dedupe_key_for_config(name, result.rule_id, user.user_id, user.custom_ids)
+        when EntityType::LAYER
+          exposure_key = Statsig::HashUtils.compute_dedupe_key_for_layer(name, exp_name, param_name, result.rule_id, user.user_id, user.custom_ids)
+        end
+
+        if result.sampling_rate
+          shadow_should_log = Statsig::HashUtils.is_hash_in_sampling_rate(exposure_key, result.sampling_rate)
+          logged_sampling_rate = result.sampling_rate
+        elsif special_case_rules.include?(result.rule_id) && special_case_sampling_rate
+          shadow_should_log = Statsig::HashUtils.is_hash_in_sampling_rate(exposure_key, special_case_sampling_rate)
+          logged_sampling_rate = special_case_sampling_rate
+        end
+
+        shadow_logged = if logged_sampling_rate.nil?
+                          nil
+                        else
+                          shadow_should_log ? "logged" : "dropped"
+                        end
+        if sampling_mode == "on"
+          return shadow_should_log, logged_sampling_rate, shadow_logged
+        elsif sampling_mode == "shadow"
+          return true, logged_sampling_rate, shadow_logged
+        end
+
+        return true, nil, nil
+      rescue => e
+        @error_boundary.log_exception(e, "__determine_sampling")
+        return true, nil, nil
+      end
+    end
+
   end
 end

data/lib/ttl_set.rb

@@ -0,0 +1,36 @@
+require 'concurrent-ruby'
+
+RESET_INTERVAL = 60
+
+module Statsig
+  class TTLSet
+    def initialize
+      @store = Concurrent::Set.new
+      @reset_interval = RESET_INTERVAL
+      @background_reset = periodic_reset
+    end
+
+    def add(key)
+      @store.add(key)
+    end
+
+    def contains?(key)
+      @store.include?(key)
+    end
+
+    def shutdown
+      @background_reset&.exit
+    end
+
+    def periodic_reset
+      Thread.new do
+        loop do
+          sleep @reset_interval
+          @store.clear
+        end
+      end
+    end
+  end
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.3.1
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -340,6 +340,7 @@ files:
 - lib/layer.rb
 - lib/memo.rb
 - lib/network.rb
+- lib/sdk_configs.rb
 - lib/spec_store.rb
 - lib/statsig.rb
 - lib/statsig_driver.rb
@@ -348,6 +349,7 @@ files:
 - lib/statsig_logger.rb
 - lib/statsig_options.rb
 - lib/statsig_user.rb
+- lib/ttl_set.rb
 - lib/ua_parser.rb
 - lib/user_persistent_storage_utils.rb
 homepage: https://rubygems.org/gems/statsig