statsig 2.1.0 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd554df4ba15f0d1addaecc5e76502c1218c1b08842152eeeffd0f6e121dbcba
-  data.tar.gz: b1d19d91608685488db9705e213559c4a36c21731b0822137b55fab0693a871d
+  metadata.gz: 20ee1f5defc13286856fb81276a04db5e1078cc0b0c88223a4a361e71e8c2949
+  data.tar.gz: fd32bbe80668331c751091a7d9ddfad05c50eb1c2c37c037a50672731415af30
 SHA512:
-  metadata.gz: b360f7fb18b06e87b538eb005ce0f7344f8a633a1cb9915d3e6f74e5b0fab3b7d87d46ab4b4498548e66766d00a4f60a9bb5f502c270e09925e67c24575da7ca
-  data.tar.gz: 337e0fd5ecfc11fa5565980df91d21ee17cc6586d49f1a18b333eaa4de1da29094c453a00daf1671ce8e6872d03882b85c169df6709aa41e543500cdc5c78057
+  metadata.gz: c42d83f65d9689eb181d54eb23e703962550270fd82950c808f34d5e1ce45098ebaa1e89860cc35e0fff20c5efd528bf335cb06a897ef7b0486159c4a3a0af22
+  data.tar.gz: 0c41f82dc93999a11e9419cd008d7dcdeb74c42c2d11208ce3ed13168ec3e13a42d2fc4fd6314b5717a51ea1d57ba2c6880b010b4ae3fb131a59bbf2b9def55e

data/lib/api_config.rb

@@ -1,4 +1,4 @@
-require 'constants'
+require_relative 'constants'
 
 class UnsupportedConfigException < StandardError
 end

data/lib/client_initialize_helpers.rb

@@ -1,7 +1,6 @@
+require_relative 'constants'
 require_relative 'hash_utils'
 
-require 'constants'
-
 module Statsig
   class ResponseFormatter
     def self.get_responses(
@@ -31,7 +30,6 @@ module Statsig
     end
 
     def self.to_response(config_name, config_spec, evaluator, user, client_sdk_key, hash_algo, include_exposures, include_local_overrides)
-      config_name_str = config_name.to_s
       category = config_spec[:type]
       entity_type = config_spec[:entity]
       if entity_type == Const::TYPE_SEGMENT || entity_type == Const::TYPE_HOLDOUT
@@ -47,11 +45,13 @@ module Statsig
         end
       end
 
+      config_name_str = config_name.to_s
       if local_override.nil?
         eval_result = ConfigResult.new(
           name: config_name,
           disable_evaluation_details: true,
-          disable_exposures: !include_exposures
+          disable_exposures: !include_exposures,
+          include_local_overrides: include_local_overrides
         )
         evaluator.eval_spec(config_name_str, user, config_spec, eval_result)
       else
@@ -73,6 +73,7 @@ module Statsig
         result[:value] = eval_result.json_value
         result[:group] = eval_result.rule_id
         result[:is_device_based] = id_type.is_a?(String) && id_type.downcase == Statsig::Const::STABLEID
+        result[:passed] = eval_result.gate_value
       else
         return nil
       end
@@ -122,14 +123,6 @@ module Statsig
 
       result[:is_in_layer] = true
       result[:explicit_parameters] = config_spec[:explicitParameters] || []
-
-      layer_name = evaluator.spec_store.experiment_to_layer[config_name]
-      if layer_name.nil? || evaluator.spec_store.layers[layer_name].nil?
-        return
-      end
-
-      layer = evaluator.spec_store.layers[layer_name]
-      result[:value] = layer[:defaultValue].merge(result[:value])
     end
 
     def self.populate_layer_fields(config_spec, eval_result, result, evaluator, hash_algo, include_exposures)
@@ -151,13 +144,15 @@ module Statsig
     end
 
     def self.hash_name(name, hash_algo)
-      case hash_algo
-      when Statsig::Const::NONE
-        return name
-      when Statsig::Const::DJB2
-        return Statsig::HashUtils.djb2(name)
-      else
-        return Statsig::HashUtils.sha256(name)
+      Statsig::Memo.for_global(:hash_name, "#{hash_algo}|#{name}") do
+        case hash_algo
+        when Statsig::Const::NONE
+          name
+        when Statsig::Const::DJB2
+          Statsig::HashUtils.djb2(name)
+        else
+          Statsig::HashUtils.sha256(name)
+        end
       end
     end
   end

data/lib/config_result.rb

@@ -16,6 +16,12 @@ module Statsig
     attr_accessor :target_app_ids
     attr_accessor :disable_evaluation_details
     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
+    attr_accessor :override_config_name
 
     def initialize(
       name:,
@@ -31,7 +37,13 @@ module Statsig
       id_type: nil,
       target_app_ids: nil,
       disable_evaluation_details: false,
-      disable_exposures: false
+      disable_exposures: false,
+      config_version: nil,
+      include_local_overrides: true,
+      forward_all_exposures: false,
+      sampling_rate: nil,
+      has_seen_analytical_gates: false,
+      override_config_name: nil
     )
       @name = name
       @gate_value = gate_value
@@ -48,6 +60,12 @@ module Statsig
       @target_app_ids = target_app_ids
       @disable_evaluation_details = disable_evaluation_details
       @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
+      @override_config_name = override_config_name
     end
 
     def self.from_user_persisted_values(config_name, user_persisted_values)
@@ -67,7 +85,8 @@ module Statsig
         init_time: @init_time,
         group_name: @group_name,
         id_type: @id_type,
-        target_app_ids: @target_app_ids
+        target_app_ids: @target_app_ids,
+        override_config_name: @override_config_name
       }
     end
   end

data/lib/constants.rb

@@ -29,6 +29,8 @@ module Statsig
     DISABLED = 'disabled'.freeze
     DJB2 = 'djb2'.freeze
     EMAIL = 'email'.freeze
+    EXPLORE = ':explore'.freeze
+    FAILS_TARGETING = 'inlineTargetingRules'.freeze
     FALSE = 'false'.freeze
     IP = 'ip'.freeze
     LAYER = :layer
@@ -39,6 +41,7 @@ module Statsig
     OSNAME = 'osname'.freeze
     OSVERSION = 'osversion'.freeze
     OVERRIDE = 'override'.freeze
+    PRESTART = 'prestart'.freeze
     Q_RIGHT_CHEVRON = 'Q>'.freeze
     STABLEID = 'stableid'.freeze
     STATSIG_RUBY_SDK = 'statsig-ruby-sdk'.freeze

data/lib/error_boundary.rb

@@ -1,4 +1,4 @@
-require 'statsig_errors'
+require_relative 'statsig_errors'
 
 $endpoint = 'https://statsigapi.net/v1/sdk_exception'
 

data/lib/evaluator.rb

@@ -1,15 +1,15 @@
-require 'config_result'
 require 'country_lookup'
 require 'digest'
-require 'evaluation_helpers'
-require 'client_initialize_helpers'
-require 'spec_store'
 require 'time'
-require 'ua_parser'
-require 'evaluation_details'
 require 'user_agent_parser/operating_system'
-require 'user_persistent_storage_utils'
-require 'constants'
+require_relative 'client_initialize_helpers'
+require_relative 'config_result'
+require_relative 'constants'
+require_relative 'evaluation_details'
+require_relative 'evaluation_helpers'
+require_relative 'spec_store'
+require_relative 'ua_parser'
+require_relative 'user_persistent_storage_utils'
 
 module Statsig
   class Evaluator
@@ -20,6 +20,8 @@ module Statsig
 
     attr_accessor :config_overrides
 
+    attr_accessor :experiment_overrides
+
     attr_accessor :options
 
     attr_accessor :persistent_storage_utils
@@ -31,6 +33,7 @@ module Statsig
       @spec_store = store
       @gate_overrides = {}
       @config_overrides = {}
+      @experiment_overrides = {}
       @options = options
       @persistent_storage_utils = persistent_storage_utils
     end
@@ -58,19 +61,76 @@ module Statsig
 
     def lookup_config_override(config_name)
       config_name_sym = config_name.to_sym
+      if @experiment_overrides.key?(config_name_sym)
+        override = @experiment_overrides[config_name_sym]
+        return ConfigResult.new(
+          name: config_name,
+          json_value: override[:value],
+          group_name: override[:group_name],
+          rule_id: override[:rule_id],
+          evaluation_details: EvaluationDetails.local_override(
+            @spec_store.last_config_sync_time,
+            @spec_store.initial_config_sync_time
+          )
+        )
+      end
       if @config_overrides.key?(config_name_sym)
+        override = @config_overrides[config_name_sym]
         return ConfigResult.new(
           name: config_name,
-          json_value: @config_overrides[config_name_sym],
+          json_value: override,
           rule_id: Const::OVERRIDE,
-          id_type: @spec_store.has_config?(config_name) ? @spec_store.get_config(config_name)[:idType] : Const::EMPTY_STR,
           evaluation_details: EvaluationDetails.local_override(
             @spec_store.last_config_sync_time,
             @spec_store.initial_config_sync_time
           )
         )
       end
-      return nil
+      nil
+    end
+
+    def try_apply_config_mapping(gate_name, user, end_result, type, salt)
+      gate_name_sym = gate_name.to_sym
+      return false unless @spec_store.overrides.key?(gate_name_sym)
+
+      mapping_list = @spec_store.overrides[gate_name_sym]
+      mapping_list.each do |mapping|
+        rules = mapping[:rules]
+        rules.each do |rule|
+          start_time = rule[:start_time]
+          if !start_time.nil? && start_time > (Time.now.to_i * 1000)
+            next
+          end
+
+          rule_name = rule[:rule_name].to_sym
+          next unless @spec_store.override_rules.key?(rule_name)
+
+          override_rule = @spec_store.override_rules[rule_name]
+          eval_rule(user, override_rule, end_result)
+          unless end_result.gate_value
+            next
+          end
+
+          pass = eval_pass_percent(user, override_rule, salt)
+          unless pass
+            next
+          end
+
+          new_config_name = mapping[:new_config_name]
+          end_result.override_config_name = new_config_name
+          if type == Const::TYPE_FEATURE_GATE
+            check_gate(user, new_config_name, end_result)
+          end
+          if [Const::TYPE_EXPERIMENT, Const::TYPE_DYNAMIC_CONFIG, Const::TYPE_AUTOTUNE].include?(type)
+            get_config(user, new_config_name, end_result)
+          end
+          if type == Const::TYPE_LAYER
+            get_layer(user, new_config_name, end_result)
+          end
+          return true
+        end
+      end
+      false
     end
 
     def check_gate(user, gate_name, end_result, ignore_local_overrides: false, is_nested: false)
@@ -87,6 +147,7 @@ module Statsig
       end
 
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
+        end_result.gate_value = false
         unless end_result.disable_evaluation_details
           end_result.evaluation_details = EvaluationDetails.uninitialized
         end
@@ -94,11 +155,20 @@ module Statsig
       end
 
       unless @spec_store.has_gate?(gate_name)
+        if try_apply_config_mapping(gate_name, user, end_result, Const::TYPE_FEATURE_GATE, Const::EMPTY_STR)
+          return
+        end
+
         unsupported_or_unrecognized(gate_name, end_result)
         return
       end
 
-      eval_spec(gate_name, user, @spec_store.get_gate(gate_name), end_result, is_nested: is_nested)
+      spec = @spec_store.get_gate(gate_name)
+      if try_apply_config_mapping(gate_name, user, end_result, spec[:entity], spec[:salt])
+        return
+      end
+
+      eval_spec(gate_name, user, spec, end_result, is_nested: is_nested)
     end
 
     def get_config(user, config_name, end_result, user_persisted_values: nil, ignore_local_overrides: false)
@@ -108,6 +178,8 @@ module Statsig
           end_result.id_type = local_override.id_type
           end_result.rule_id = local_override.rule_id
           end_result.json_value = local_override.json_value
+          end_result.group_name = local_override.group_name
+          end_result.is_experiment_group = local_override.is_experiment_group
           unless end_result.disable_evaluation_details
             end_result.evaluation_details = local_override.evaluation_details
           end
@@ -122,13 +194,25 @@ module Statsig
         return
       end
 
+      if eval_cmab(config_name, user, end_result)
+        return
+      end
+
       unless @spec_store.has_config?(config_name)
+        if try_apply_config_mapping(config_name, user, end_result, Const::TYPE_DYNAMIC_CONFIG, Const::EMPTY_STR)
+          return
+        end
+
         unsupported_or_unrecognized(config_name, end_result)
         return
       end
 
       config = @spec_store.get_config(config_name)
 
+      if try_apply_config_mapping(config_name, user, end_result, config[:entity], config[:salt])
+        return
+      end
+
       # If persisted values is provided and the experiment is active, return sticky values if exists.
       if !user_persisted_values.nil? && config[:isActive] == true
         sticky_values = user_persisted_values[config_name]
@@ -163,6 +247,149 @@ module Statsig
       end
     end
 
+    def eval_cmab(config_name, user, end_result)
+      return false unless @spec_store.has_cmab_config?(config_name)
+
+      cmab = @spec_store.get_cmab_config(config_name)
+
+      if !cmab[:enabled] || cmab[:groups].length.zero?
+        end_result.rule_id = Const::PRESTART
+        end_result.json_value = cmab[:defaultValue]
+        finalize_cmab_eval_result(cmab, end_result, did_pass: false)
+        return true
+      end
+
+      targeting_gate = cmab[:targetingGateName]
+      unless targeting_gate.nil?
+        check_gate(user, targeting_gate, end_result, is_nested: true)
+
+        gate_value = end_result.gate_value
+
+        unless end_result.disable_exposures
+          new_exposure = {
+            gate: targeting_gate,
+            gateValue: gate_value ? Const::TRUE : Const::FALSE,
+            ruleID: end_result.rule_id
+          }
+          end_result.secondary_exposures.append(new_exposure)
+        end
+
+        if gate_value == false
+          end_result.rule_id = Const::FAILS_TARGETING
+          end_result.json_value = cmab[:defaultValue]
+          finalize_cmab_eval_result(cmab, end_result, did_pass: false)
+          return true
+        end
+      end
+
+      cmab_config = cmab[:config]
+      unit_id = user.get_unit_id(cmab[:idType]) || Const::EMPTY_STR
+      salt = cmab[:salt] || config_name
+      hash = compute_user_hash("#{salt}.#{unit_id}")
+
+      # If there is no config assign the user to a random group
+      if cmab_config.nil?
+        group_size = 10_000.0 / cmab[:groups].length
+        group = cmab[:groups][(hash % 10_000) / group_size]
+        end_result.json_value = group[:parameterValues]
+        end_result.rule_id = group[:id] + Const::EXPLORE
+        end_result.group_name = group[:name]
+        end_result.is_experiment_group = true
+        finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+        return true
+      end
+
+      should_sample = (hash % 10_000) < cmab[:sampleRate] * 10_000
+      if should_sample && apply_cmab_sampling(cmab, cmab_config, end_result)
+        finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+        return true
+      end
+      apply_cmab_best_group(cmab, cmab_config, user, end_result)
+      finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+      true
+    end
+
+    def apply_cmab_best_group(cmab, cmab_config, user, end_result)
+      higher_better = cmab[:higherIsBetter]
+      best_score = higher_better ? -1_000_000_000 : 1_000_000_000
+      has_score = false
+      best_group = nil
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        next if config.nil?
+
+        weights_numerical = config[:weightsNumerical]
+        weights_categorical = config[:weightsCategorical]
+
+        next if weights_numerical.length.zero? && weights_categorical.length.zero?
+
+        score = 0
+        score += config[:alpha] + config[:intercept]
+
+        weights_categorical.each do |key, weights|
+          value = get_value_from_user(user, key.to_s)
+          next if value.nil?
+
+          if weights.key?(value.to_sym)
+            score += weights[value.to_sym]
+          end
+        end
+
+        weights_numerical.each do |key, weight|
+          value = get_value_from_user(user, key.to_s)
+          if value.is_a?(Numeric)
+            score += weight * value
+          end
+        end
+        if !has_score || (higher_better && score > best_score) || (!higher_better && score < best_score)
+          best_score = score
+          best_group = group
+        end
+        has_score = true
+      end
+      if best_group.nil?
+        best_group = cmab[:groups][Random.rand(cmab[:groups].length)]
+      end
+      end_result.json_value = best_group[:parameterValues]
+      end_result.rule_id = best_group[:id]
+      end_result.group_name = best_group[:name]
+      end_result.is_experiment_group = true
+    end
+
+    def apply_cmab_sampling(cmab, cmab_config, end_result)
+      total_records = 0.0
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        cur_count = 1.0
+        unless config.nil?
+          cur_count += config[:records]
+        end
+        total_records += 1.0 / cur_count
+      end
+
+      sum = 0.0
+      value = Random.rand
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        cur_count = 1.0
+        unless config.nil?
+          cur_count += config[:records]
+        end
+        sum += 1.0 / (cur_count / total_records)
+        next unless value < sum
+
+        end_result.json_value = group[:parameterValues]
+        end_result.rule_id = group[:id] + Const::EXPLORE
+        end_result.group_name = group[:name]
+        end_result.is_experiment_group = true
+        return true
+      end
+      false
+    end
+
     def get_layer(user, layer_name, end_result)
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
         unless end_result.disable_evaluation_details
@@ -172,11 +399,20 @@ module Statsig
       end
 
       unless @spec_store.has_layer?(layer_name)
+        if try_apply_config_mapping(layer_name, user, end_result, Const::LAYER, Const::EMPTY_STR)
+          return
+        end
+
         unsupported_or_unrecognized(layer_name, end_result)
         return
       end
 
-      eval_spec(layer_name, user, @spec_store.get_layer(layer_name), end_result)
+      layer = @spec_store.get_layer(layer_name)
+      if try_apply_config_mapping(layer_name, user, end_result, layer[:entity], layer[:salt])
+        return
+      end
+
+      eval_spec(layer_name, user, layer, end_result)
     end
 
     def list_gates
@@ -257,6 +493,7 @@ module Statsig
 
     def unsupported_or_unrecognized(config_name, end_result)
       end_result.rule_id = Const::EMPTY_STR
+      end_result.gate_value = false
 
       if end_result.disable_evaluation_details
         return
@@ -300,8 +537,44 @@ module Statsig
       @config_overrides.clear
     end
 
+    def override_experiment_by_group_name(experiment_name, group_name)
+      return unless @spec_store.has_config?(experiment_name)
+
+      config = @spec_store.get_config(experiment_name)
+      return unless config[:entity] == Const::TYPE_EXPERIMENT
+
+      config[:rules].each do |rule|
+        if rule[:groupName] == group_name
+          @experiment_overrides[experiment_name.to_sym] = {
+            value: rule[:returnValue],
+            group_name: rule[:groupName],
+            rule_id: rule[:id],
+            evaluation_details: EvaluationDetails.local_override(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time)
+          }
+          return
+        end
+      end
+
+      # If no matching rule is found, create a default override with empty value
+      @experiment_overrides[experiment_name.to_sym] = {
+        value: {},
+        group_name: group_name,
+        rule_id: "#{experiment_name}:override",
+        evaluation_details: EvaluationDetails.local_override(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time)
+      }
+    end
+
+    def clear_experiment_overrides
+      @experiment_overrides.clear
+    end
+
+    def remove_experiment_override(experiment_name)
+      @experiment_overrides.delete(experiment_name.to_sym)
+    end
+
     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
@@ -324,7 +597,12 @@ module Statsig
     def finalize_eval_result(config, end_result, did_pass:, rule:, is_nested: false)
       end_result.id_type = config[:idType]
       end_result.target_app_ids = config[:targetAppIDs]
-      end_result.gate_value = did_pass ? rule[:returnValue] == true : config[:defaultValue] == true
+      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
+      end_result.config_version = config[:version]
 
       if rule.nil?
         end_result.json_value = config[:defaultValue]
@@ -336,6 +614,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
@@ -351,6 +630,21 @@ module Statsig
       end
     end
 
+    def finalize_cmab_eval_result(config, end_result, did_pass:)
+      end_result.id_type = config[:idType]
+      end_result.target_app_ids = config[:targetAppIDs]
+      end_result.gate_value = did_pass
+
+      unless end_result.disable_evaluation_details
+        end_result.evaluation_details = EvaluationDetails.new(
+          @spec_store.last_config_sync_time,
+          @spec_store.initial_config_sync_time,
+          @spec_store.init_reason
+        )
+      end
+      end_result.config_version = config[:version]
+    end
+
     def finalize_secondary_exposures(end_result)
       end_result.secondary_exposures = clean_exposures(end_result.secondary_exposures)
       end_result.undelegated_sec_exps = clean_exposures(end_result.undelegated_sec_exps)
@@ -373,11 +667,35 @@ module Statsig
     def eval_rule(user, rule, end_result)
       pass = true
       i = 0
+      memo = user.get_memo
 
       until i >= rule[:conditions].length
         condition_hash = rule[:conditions][i]
+
+        eval_rule_memo = memo[:eval_rule] || {}
+        result = eval_rule_memo[condition_hash]
+
+        if !result.nil?
+          pass = false if result != true
+          i += 1
+          next
+        end
+
         condition = @spec_store.get_condition(condition_hash)
-        result = eval_condition(user, condition, end_result)
+        result = if condition.nil?
+          puts "[Statsig]: Warning - Condition with hash #{condition_hash} could not be found."
+          false
+        else
+          eval_condition(user, condition, end_result)
+        end
+
+        if !@options.disable_evaluation_memoization &&
+          condition && condition[:type] != Const::CND_PASS_GATE && condition[:type] != Const::CND_FAIL_GATE
+          eval_rule_memo[condition_hash] = result
+        end
+
+        memo[:eval_rule] = eval_rule_memo
+
         pass = false if result != true
         i += 1
       end
@@ -413,7 +731,14 @@ module Statsig
       when Const::CND_PUBLIC
         return true
       when Const::CND_PASS_GATE, Const::CND_FAIL_GATE
+        if !target.is_a?(String) || target.empty?
+          return type == Const::CND_FAIL_GATE
+        end
+
         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)
@@ -580,7 +905,8 @@ module Statsig
     end
 
     def eval_nested_gate(gate_name, user, end_result)
-      check_gate(user, gate_name, end_result, is_nested: true)
+      check_gate(user, gate_name, end_result, is_nested: true,
+                                              ignore_local_overrides: !end_result.include_local_overrides)
       gate_value = end_result.gate_value
 
       unless end_result.disable_exposures
@@ -600,7 +926,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
@@ -691,7 +1019,7 @@ module Statsig
       pass_percentage = rule[:passPercentage]
       return true if pass_percentage == 100.0
       return false if pass_percentage == 0.0
-    
+
       unit_id = user.get_unit_id(rule[:idType]) || Const::EMPTY_STR
       rule_salt = rule[:salt] || rule[:id] || Const::EMPTY_STR
       hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")