statsig 1.31.1 → 1.32.0

data/lib/evaluator.rb

@@ -1,6 +1,3 @@
-# typed: false
-
-require 'sorbet-runtime'
 require 'config_result'
 require 'country_lookup'
 require 'digest'
@@ -12,29 +9,17 @@ require 'ua_parser'
 require 'evaluation_details'
 require 'user_agent_parser/operating_system'
 require 'user_persistent_storage_utils'
+require 'constants'
 
 module Statsig
   class Evaluator
-    extend T::Sig
-
-    UNSUPPORTED_EVALUATION = :unsupported_eval
 
-    sig { returns(SpecStore) }
     attr_accessor :spec_store
 
-    sig { returns(StatsigOptions) }
     attr_accessor :options
 
-    sig { returns(UserPersistentStorageUtils) }
     attr_accessor :persistent_storage_utils
 
-    sig do
-      params(
-        store: SpecStore,
-        options: StatsigOptions,
-        persistent_storage_utils: UserPersistentStorageUtils,
-      ).void
-    end
     def initialize(store, options, persistent_storage_utils)
       UAParser.initialize_async
       CountryLookup.initialize_async
@@ -50,92 +35,111 @@ module Statsig
       @spec_store.maybe_restart_background_threads
     end
 
-    def check_gate(user, gate_name)
-      if @gate_overrides.has_key?(gate_name)
-        return Statsig::ConfigResult.new(
-          gate_name,
-          @gate_overrides[gate_name],
-          @gate_overrides[gate_name],
-          'override',
-          [],
-          evaluation_details: EvaluationDetails.local_override(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+    def check_gate(user, gate_name, end_result)
+      if @gate_overrides.key?(gate_name)
+        end_result.gate_value = @gate_overrides[gate_name]
+        end_result.rule_id = Const::OVERRIDE
+        unless end_result.disable_evaluation_details
+          end_result.evaluation_details = EvaluationDetails.local_override(
+            @spec_store.last_config_sync_time,
+            @spec_store.initial_config_sync_time
+          )
+        end
+        return
       end
 
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
-        return Statsig::ConfigResult.new(gate_name, evaluation_details: EvaluationDetails.uninitialized)
+        unless end_result.disable_evaluation_details
+          end_result.evaluation_details = EvaluationDetails.uninitialized
+        end
+        return
       end
 
       unless @spec_store.has_gate?(gate_name)
-        return Statsig::ConfigResult.new(gate_name, evaluation_details: EvaluationDetails.unrecognized(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+        unsupported_or_unrecognized(gate_name, end_result)
+        return
       end
 
-      eval_spec(user, @spec_store.get_gate(gate_name))
+      eval_spec(user, @spec_store.get_gate(gate_name), end_result)
     end
 
-    sig { params(user: StatsigUser, config_name: String, user_persisted_values: T.nilable(UserPersistedValues)).returns(ConfigResult) }
-    def get_config(user, config_name, user_persisted_values: nil)
+    def get_config(user, config_name, end_result, user_persisted_values: nil)
       if @config_overrides.key?(config_name)
-        id_type = @spec_store.has_config?(config_name) ? @spec_store.get_config(config_name)['idType'] : ''
-        return Statsig::ConfigResult.new(
-          config_name,
-          false,
-          @config_overrides[config_name],
-          'override',
-          [],
-          evaluation_details: EvaluationDetails.local_override(
+        id_type = @spec_store.has_config?(config_name) ? @spec_store.get_config(config_name).id_type : Const::EMPTY_STR
+        end_result.id_type = id_type
+        end_result.rule_id = Const::OVERRIDE
+        end_result.json_value = @config_overrides[config_name]
+        unless end_result.disable_evaluation_details
+          end_result.evaluation_details = EvaluationDetails.local_override(
             @spec_store.last_config_sync_time,
             @spec_store.initial_config_sync_time
-          ),
-          id_type: id_type
-        )
+          )
+        end
+        return
       end
 
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
-        return Statsig::ConfigResult.new(config_name, evaluation_details: EvaluationDetails.uninitialized)
+        unless end_result.disable_evaluation_details
+          end_result.evaluation_details = EvaluationDetails.uninitialized
+        end
+        return
       end
 
       unless @spec_store.has_config?(config_name)
-        return Statsig::ConfigResult.new(
-          config_name,
-          evaluation_details: EvaluationDetails.unrecognized(
-            @spec_store.last_config_sync_time,
-            @spec_store.initial_config_sync_time
-          )
-        )
+        unsupported_or_unrecognized(config_name, end_result)
+        return
       end
 
       config = @spec_store.get_config(config_name)
 
       # If persisted values is provided and the experiment is active, return sticky values if exists.
-      if !user_persisted_values.nil? && config['isActive'] == true
-        sticky_result = Statsig::ConfigResult.from_user_persisted_values(config_name, user_persisted_values)
-        return sticky_result unless sticky_result.nil?
+      if !user_persisted_values.nil? && config.is_active == true
+        sticky_values = user_persisted_values[config_name]
+        unless sticky_values.nil?
+          end_result.gate_value = sticky_values[Statsig::Const::GATE_VALUE]
+          end_result.json_value = sticky_values[Statsig::Const::JSON_VALUE]
+          end_result.rule_id = sticky_values[Statsig::Const::RULE_ID]
+          end_result.secondary_exposures = sticky_values[Statsig::Const::SECONDARY_EXPOSURES]
+          end_result.group_name = sticky_values[Statsig::Const::GROUP_NAME]
+          end_result.id_type = sticky_values[Statsig::Const::ID_TYPE]
+          end_result.target_app_ids = sticky_values[Statsig::Const::TARGET_APP_IDS]
+          unless end_result.disable_evaluation_details
+            end_result.evaluation_details = EvaluationDetails.persisted(
+              sticky_values[Statsig::Const::CONFIG_SYNC_TIME],
+              sticky_values[Statsig::Const::INIT_TIME]
+            )
+          end
+          return
+        end
 
         # If it doesn't exist, then save to persisted storage if the user was assigned to an experiment group.
-        evaluation = eval_spec(user, config)
-        if evaluation.is_experiment_group
-          @persistent_storage_utils.add_evaluation_to_user_persisted_values(user_persisted_values, config_name, evaluation)
-          @persistent_storage_utils.save_to_storage(user, config['idType'], user_persisted_values)
+        eval_spec(user, config, end_result)
+        if end_result.is_experiment_group
+          @persistent_storage_utils.add_evaluation_to_user_persisted_values(user_persisted_values, config_name,
+                                                                            end_result)
+          @persistent_storage_utils.save_to_storage(user, config.id_type, user_persisted_values)
         end
         # Otherwise, remove from persisted storage
       else
-        @persistent_storage_utils.remove_experiment_from_storage(user, config['idType'], config_name)
-        evaluation = eval_spec(user, config)
+        @persistent_storage_utils.remove_experiment_from_storage(user, config.id_type, config_name)
+        eval_spec(user, config, end_result)
       end
-
-      return evaluation
     end
 
-    def get_layer(user, layer_name)
+    def get_layer(user, layer_name, end_result)
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
-        return Statsig::ConfigResult.new(layer_name, evaluation_details: EvaluationDetails.uninitialized)
+        unless end_result.disable_evaluation_details
+          end_result.evaluation_details = EvaluationDetails.uninitialized
+        end
+        return
       end
 
       unless @spec_store.has_layer?(layer_name)
-        return Statsig::ConfigResult.new(layer_name, evaluation_details: EvaluationDetails.unrecognized(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+        unsupported_or_unrecognized(layer_name, end_result)
+        return
       end
 
-      eval_spec(user, @spec_store.get_layer(layer_name))
+      eval_spec(user, @spec_store.get_layer(layer_name), end_result)
     end
 
     def list_gates
@@ -143,65 +147,77 @@ module Statsig
     end
 
     def list_configs
-      @spec_store.configs.map { |name, config| name if config['entity'] == 'dynamic_config' }.compact
+      @spec_store.configs.map { |name, config| name if config.entity == :dynamic_config }.compact
     end
 
     def list_experiments
-      @spec_store.configs.map { |name, config| name if config['entity'] == 'experiment' }.compact
+      @spec_store.configs.map { |name, config| name if config.entity == :experiment }.compact
     end
 
     def list_autotunes
-      @spec_store.configs.map { |name, config| name if config['entity'] == 'autotune' }.compact
+      @spec_store.configs.map { |name, config| name if config.entity == :autotune }.compact
     end
 
     def list_layers
       @spec_store.layers.map { |name, _| name }
     end
 
-    def get_client_initialize_response(user, hash, client_sdk_key)
+    def get_client_initialize_response(user, hash_algo, client_sdk_key)
       if @spec_store.is_ready_for_checks == false
         return nil
       end
 
-      formatter = ClientInitializeHelpers::ResponseFormatter.new(self, user, hash, client_sdk_key)
-
       evaluated_keys = {}
       if user.user_id.nil? == false
-        evaluated_keys['userID'] = user.user_id
+        evaluated_keys[:userID] = user.user_id
       end
 
       if user.custom_ids.nil? == false
-        evaluated_keys['customIDs'] = user.custom_ids
+        evaluated_keys[:customIDs] = user.custom_ids
       end
 
       {
-        "feature_gates" => formatter.get_responses(:gates),
-        "dynamic_configs" => formatter.get_responses(:configs),
-        "layer_configs" => formatter.get_responses(:layers),
-        "sdkParams" => {},
-        "has_updates" => true,
-        "generator" => "statsig-ruby-sdk",
-        "evaluated_keys" => evaluated_keys,
-        "time" => 0,
-        "hash_used" => hash,
-        "user_hash" => user.to_hash_without_stable_id()
+        feature_gates: Statsig::ResponseFormatter
+                         .get_responses(@spec_store.gates, self, user, client_sdk_key, hash_algo),
+        dynamic_configs: Statsig::ResponseFormatter
+                           .get_responses(@spec_store.configs, self, user, client_sdk_key, hash_algo),
+        layer_configs: Statsig::ResponseFormatter
+                         .get_responses(@spec_store.layers, self, user, client_sdk_key, hash_algo),
+        sdkParams: {},
+        has_updates: true,
+        generator: Const::STATSIG_RUBY_SDK,
+        evaluated_keys: evaluated_keys,
+        time: 0,
+        hash_used: hash_algo,
+        user_hash: user.to_hash_without_stable_id
       }
     end
 
-    def clean_exposures(exposures)
-      seen = {}
-      exposures.reject do |exposure|
-        key = "#{exposure["gate"]}|#{exposure["gateValue"]}|#{exposure["ruleID"]}}"
-        should_reject = seen[key]
-        seen[key] = true
-        should_reject == true
-      end
-    end
-
     def shutdown
       @spec_store.shutdown
     end
 
+    def unsupported_or_unrecognized(config_name, end_result)
+      end_result.rule_id = Const::EMPTY_STR
+
+      if end_result.disable_evaluation_details
+        return
+      end
+
+      if @spec_store.unsupported_configs.include?(config_name)
+        end_result.evaluation_details = EvaluationDetails.unsupported(
+          @spec_store.last_config_sync_time,
+          @spec_store.initial_config_sync_time
+        )
+        return
+      end
+
+      end_result.evaluation_details = EvaluationDetails.unrecognized(
+        @spec_store.last_config_sync_time,
+        @spec_store.initial_config_sync_time
+      )
+    end
+
     def override_gate(gate, value)
       @gate_overrides[gate] = value
     end
@@ -210,256 +226,236 @@ module Statsig
       @config_overrides[config] = value
     end
 
-    sig { params(user: StatsigUser, config: Hash).returns(ConfigResult) }
-    def eval_spec(user, config)
-      default_rule_id = 'default'
-      exposures = []
-      if config['enabled']
-        i = 0
-        until i >= config['rules'].length do
-          rule = config['rules'][i]
-          result = eval_rule(user, rule)
-          return Statsig::ConfigResult.new(
-            config['name'],
-            false,
-            config['defaultValue'],
-            '',
-            exposures,
-            evaluation_details: EvaluationDetails.new(
-              @spec_store.last_config_sync_time,
-              @spec_store.initial_config_sync_time,
-              EvaluationReason::UNSUPPORTED,
-            ),
-            group_name: nil,
-            id_type: config['idType'],
-            target_app_ids: config['targetAppIDs']
-          ) if result == UNSUPPORTED_EVALUATION
-          exposures = exposures + result.secondary_exposures
-          if result.gate_value
-
-            if (delegated_result = eval_delegate(config['name'], user, rule, exposures))
-              return delegated_result
-            end
-
-            pass = eval_pass_percent(user, rule, config['salt'])
-            return Statsig::ConfigResult.new(
-              config['name'],
-              pass,
-              pass ? result.json_value : config['defaultValue'],
-              result.rule_id,
-              exposures,
-              evaluation_details: EvaluationDetails.new(
-                @spec_store.last_config_sync_time,
-                @spec_store.initial_config_sync_time,
-                @spec_store.init_reason
-              ),
-              is_experiment_group: result.is_experiment_group,
-              group_name: result.group_name,
-              id_type: config['idType'],
-              target_app_ids: config['targetAppIDs']
-            )
+    def eval_spec(user, config, end_result)
+      unless config.enabled
+        finalize_eval_result(config, end_result, did_pass: false, rule: nil)
+        return
+      end
+
+      config.rules.each do |rule|
+        eval_rule(user, rule, end_result)
+
+        if end_result.gate_value
+          if eval_delegate(config.name, user, rule, end_result)
+            return
           end
 
-          i += 1
+          pass = eval_pass_percent(user, rule, config.salt)
+          finalize_eval_result(config, end_result, did_pass: pass, rule: rule)
+          return
         end
+      end
+
+      finalize_eval_result(config, end_result, did_pass: false, rule: nil)
+    end
+
+    private
+
+    def finalize_eval_result(config, end_result, did_pass:, rule:)
+      end_result.id_type = config.id_type
+      end_result.target_app_ids = config.target_app_ids
+      end_result.gate_value = did_pass
+
+      if rule.nil?
+        end_result.json_value = config.default_value
+        end_result.group_name = nil
+        end_result.is_experiment_group = false
+        end_result.rule_id = config.enabled ? Const::DEFAULT : Const::DISABLED
       else
-        default_rule_id = 'disabled'
+        end_result.json_value = did_pass ? rule.return_value : config.default_value
+        end_result.group_name = rule.group_name
+        end_result.is_experiment_group = rule.is_experiment_group == true
+        end_result.rule_id = rule.id
       end
 
-      Statsig::ConfigResult.new(
-        config['name'],
-        false,
-        config['defaultValue'],
-        default_rule_id,
-        exposures,
-        evaluation_details: EvaluationDetails.new(
+      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
-        ),
-        group_name: nil,
-        id_type: config['idType'],
-        target_app_ids: config['targetAppIDs']
-      )
+        )
+      end
     end
 
-    private
-
-    def eval_rule(user, rule)
-      exposures = []
+    def eval_rule(user, rule, end_result)
       pass = true
       i = 0
-      until i >= rule['conditions'].length do
-        result = eval_condition(user, rule['conditions'][i])
-        if result == UNSUPPORTED_EVALUATION
-          return UNSUPPORTED_EVALUATION
-        end
+      until i >= rule.conditions.length
+        result = eval_condition(user, rule.conditions[i], end_result)
 
-        if result.is_a?(Hash)
-          exposures = exposures + result['exposures'] if result['exposures'].is_a? Array
-          pass = false if result['value'] == false
-        elsif result == false
-          pass = false
-        end
+        pass = false if result != true
         i += 1
       end
 
-      Statsig::ConfigResult.new(
-        '',
-        pass,
-        rule['returnValue'],
-        rule['id'],
-        exposures,
-        evaluation_details: EvaluationDetails.new(
-          @spec_store.last_config_sync_time,
-          @spec_store.initial_config_sync_time,
-          @spec_store.init_reason
-        ),
-        is_experiment_group: rule["isExperimentGroup"] == true,
-        group_name: rule['groupName']
-      )
+      end_result.gate_value = pass
     end
 
-    def eval_delegate(name, user, rule, exposures)
-      return nil unless (delegate = rule['configDelegate'])
-      return nil unless (config = @spec_store.get_config(delegate))
+    def eval_delegate(name, user, rule, end_result)
+      return false unless (delegate = rule.config_delegate)
+      return false unless (config = @spec_store.get_config(delegate))
+
+      end_result.undelegated_sec_exps = end_result.secondary_exposures.dup
+
+      eval_spec(user, config, end_result)
 
-      delegated_result = self.eval_spec(user, config)
-      return UNSUPPORTED_EVALUATION if delegated_result == UNSUPPORTED_EVALUATION
+      end_result.name = name
+      end_result.config_delegate = delegate
+      end_result.explicit_parameters = config.explicit_parameters
 
-      delegated_result.name = name
-      delegated_result.config_delegate = delegate
-      delegated_result.secondary_exposures = exposures + delegated_result.secondary_exposures
-      delegated_result.undelegated_sec_exps = exposures
-      delegated_result.explicit_parameters = config['explicitParameters']
-      delegated_result
+      true
     end
 
-    def eval_condition(user, condition)
+    def eval_condition(user, condition, end_result)
       value = nil
-      field = condition['field']
-      target = condition['targetValue']
-      type = condition['type']
-      operator = condition['operator']
-      additional_values = condition['additionalValues']
-      additional_values = Hash.new unless additional_values.is_a? Hash
-      id_type = condition['idType']
-
-      return UNSUPPORTED_EVALUATION unless type.is_a? String
-      type = type.downcase
+      field = condition.field
+      target = condition.target_value
+      type = condition.type
+      operator = condition.operator
+      additional_values = condition.additional_values
+      id_type = condition.id_type
 
       case type
-      when 'public'
+      when :public
         return true
-      when 'fail_gate', 'pass_gate'
-        other_gate_result = check_gate(user, target)
-        return UNSUPPORTED_EVALUATION if other_gate_result == UNSUPPORTED_EVALUATION
-
-        gate_value = other_gate_result&.gate_value == true
-        new_exposure = {
-          'gate' => target,
-          'gateValue' => gate_value ? 'true' : 'false',
-          'ruleID' => other_gate_result&.rule_id
-        }
-        exposures = other_gate_result&.secondary_exposures&.append(new_exposure)
-        return {
-          'value' => type == 'pass_gate' ? gate_value : !gate_value,
-          'exposures' => exposures
-        }
-      when 'ip_based'
+      when :fail_gate, :pass_gate
+        check_gate(user, target, end_result)
+
+        gate_value = end_result.gate_value
+
+        unless end_result.disable_exposures
+          new_exposure = {
+            gate: target,
+            gateValue: gate_value ? Const::TRUE : Const::FALSE,
+            ruleID: end_result.rule_id
+          }
+          end_result.secondary_exposures.append(new_exposure)
+        end
+        return type == :pass_gate ? gate_value : !gate_value
+      when :ip_based
         value = get_value_from_user(user, field) || get_value_from_ip(user, field)
-      when 'ua_based'
+      when :ua_based
         value = get_value_from_user(user, field) || get_value_from_ua(user, field)
-      when 'user_field'
+      when :user_field
         value = get_value_from_user(user, field)
-      when 'environment_field'
+      when :environment_field
         value = get_value_from_environment(user, field)
-      when 'current_time'
+      when :current_time
         value = Time.now.to_i # epoch time in seconds
-      when 'user_bucket'
+      when :user_bucket
         begin
-          salt = additional_values['salt']
-          unit_id = user.get_unit_id(id_type) || ''
+          salt = additional_values[:salt]
+          unit_id = user.get_unit_id(id_type) || Const::EMPTY_STR
           # there are only 1000 user buckets as opposed to 10k for gate pass %
           value = compute_user_hash("#{salt}.#{unit_id}") % 1000
-        rescue
+        rescue StandardError
           return false
         end
-      when 'unit_id'
+      when :unit_id
         value = user.get_unit_id(id_type)
-      else
-        return UNSUPPORTED_EVALUATION
       end
 
-      return UNSUPPORTED_EVALUATION if !operator.is_a?(String)
-      operator = operator.downcase
-
       case operator
         # numerical comparison
-      when 'gt'
-        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a > b })
-      when 'gte'
-        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a >= b })
-      when 'lt'
-        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a < b })
-      when 'lte'
-        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a <= b })
+      when :gt
+        return EvaluationHelpers.compare_numbers(value, target, ->(a, b) { a > b })
+      when :gte
+        return EvaluationHelpers.compare_numbers(value, target, ->(a, b) { a >= b })
+      when :lt
+        return EvaluationHelpers.compare_numbers(value, target, ->(a, b) { a < b })
+      when :lte
+        return EvaluationHelpers.compare_numbers(value, target, ->(a, b) { a <= b })
 
         # version comparison
         # need to check for nil or empty value because Version takes them as valid values
-      when 'version_gt'
+      when :version_gt
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) > Gem::Version.new(target) rescue false)
-      when 'version_gte'
+
+        return begin
+                 Gem::Version.new(value) > Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
+      when :version_gte
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) >= Gem::Version.new(target) rescue false)
-      when 'version_lt'
+
+        return begin
+                 Gem::Version.new(value) >= Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
+      when :version_lt
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) < Gem::Version.new(target) rescue false)
-      when 'version_lte'
+
+        return begin
+                 Gem::Version.new(value) < Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
+      when :version_lte
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) <= Gem::Version.new(target) rescue false)
-      when 'version_eq'
+
+        return begin
+                 Gem::Version.new(value) <= Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
+      when :version_eq
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) == Gem::Version.new(target) rescue false)
-      when 'version_neq'
+
+        return begin
+                 Gem::Version.new(value) == Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
+      when :version_neq
         return false if value.to_s.empty?
-        return (Gem::Version.new(value) != Gem::Version.new(target) rescue false)
+
+        return begin
+                 Gem::Version.new(value) != Gem::Version.new(target)
+               rescue StandardError
+                 false
+               end
 
         # array operations
-      when 'any'
-        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
-      when 'none'
-        return !EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
-      when 'any_case_sensitive'
-        return EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
-      when 'none_case_sensitive'
-        return !EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
+      when :any
+        return EvaluationHelpers::equal_string_in_array(target, value, true)
+      when :none
+        return !EvaluationHelpers::equal_string_in_array(target, value, true)
+      when :any_case_sensitive
+        return EvaluationHelpers::equal_string_in_array(target, value, false)
+      when :none_case_sensitive
+        return !EvaluationHelpers::equal_string_in_array(target, value, false)
 
         # string
-      when 'str_starts_with_any'
-        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.start_with?(b) })
-      when 'str_ends_with_any'
-        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.end_with?(b) })
-      when 'str_contains_any'
-        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
-      when 'str_contains_none'
-        return !EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
-      when 'str_matches'
-        return (value.is_a?(String) && !(value =~ Regexp.new(target)).nil? rescue false)
-      when 'eq'
+      when :str_starts_with_any
+        return EvaluationHelpers.match_string_in_array(target, value, true, ->(a, b) { a.start_with?(b) })
+      when :str_ends_with_any
+        return EvaluationHelpers.match_string_in_array(target, value, true, ->(a, b) { a.end_with?(b) })
+      when :str_contains_any
+        return EvaluationHelpers.match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
+      when :str_contains_none
+        return !EvaluationHelpers.match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
+      when :str_matches
+        return begin
+                 value&.is_a?(String) && !(value =~ Regexp.new(target)).nil?
+               rescue StandardError
+                 false
+               end
+      when :eq
         return value == target
-      when 'neq'
+      when :neq
         return value != target
 
         # dates
-      when 'before'
-        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a < b })
-      when 'after'
-        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a > b })
-      when 'on'
-        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a.year == b.year && a.month == b.month && a.day == b.day })
-      when 'in_segment_list', 'not_in_segment_list'
+      when :before
+        return EvaluationHelpers.compare_times(value, target, ->(a, b) { a < b })
+      when :after
+        return EvaluationHelpers.compare_times(value, target, ->(a, b) { a > b })
+      when :on
+        return EvaluationHelpers.compare_times(value, target, lambda { |a, b|
+          a.year == b.year && a.month == b.month && a.day == b.day
+        })
+      when :in_segment_list, :not_in_segment_list
         begin
           is_in_list = false
           id_list = @spec_store.get_id_list(target)
@@ -467,44 +463,57 @@ module Statsig
             hashed_id = Digest::SHA256.base64digest(value.to_s)[0, 8]
             is_in_list = id_list.ids.include?(hashed_id)
           end
-          return is_in_list if operator == 'in_segment_list'
+          return is_in_list if operator == :in_segment_list
+
           return !is_in_list
-        rescue
+        rescue StandardError
           return false
         end
-      else
-        return UNSUPPORTED_EVALUATION
       end
+      return false
     end
 
     def get_value_from_user(user, field)
-      return nil unless user.instance_of?(StatsigUser) && field.is_a?(String)
+      return nil unless field.is_a?(String)
 
-      user_lookup_table = user&.value_lookup
-      return nil unless user_lookup_table.is_a?(Hash)
-      return user_lookup_table[field.downcase] if user_lookup_table.has_key?(field.downcase) && !user_lookup_table[field.downcase].nil?
+      value = get_value_from_user_field(user, field)
+      value ||= get_value_from_user_field(user, field.downcase)
 
-      user_custom = user_lookup_table['custom']
-      if user_custom.is_a?(Hash)
-        user_custom.each do |key, value|
-          return value if key.to_s.downcase.casecmp?(field.downcase) && !value.nil?
-        end
+      if value.nil?
+        value = user.custom[field] if user.custom.is_a?(Hash)
+        value = user.custom[field.to_sym] if value.nil? && user.custom.is_a?(Hash)
+        value = user.private_attributes[field] if value.nil? && user.private_attributes.is_a?(Hash)
+        value = user.private_attributes[field.to_sym] if value.nil? && user.private_attributes.is_a?(Hash)
       end
+      value
+    end
 
-      private_attributes = user_lookup_table['privateAttributes']
-      if private_attributes.is_a?(Hash)
-        private_attributes.each do |key, value|
-          return value if key.to_s.downcase.casecmp?(field.downcase) && !value.nil?
-        end
+    def get_value_from_user_field(user, field)
+      return nil unless field.is_a?(String)
+
+      case field
+      when Const::USERID, Const::USER_ID
+        user.user_id
+      when Const::EMAIL
+        user.email
+      when Const::IP
+        user.ip
+      when Const::USERAGENT, Const::USER_AGENT
+        user.user_agent
+      when Const::COUNTRY
+        user.country
+      when Const::LOCALE
+        user.locale
+      when Const::APPVERSION, Const::APP_VERSION
+        user.app_version
+      else
+        nil
       end
-
-      nil
     end
 
     def get_value_from_environment(user, field)
-      return nil unless user.instance_of?(StatsigUser) && field.is_a?(String)
-      field = field.downcase
-      return nil unless user.statsig_environment.is_a? Hash
+      return nil unless user.statsig_environment.is_a?(Hash) && field.is_a?(String)
+
       user.statsig_environment.each do |key, value|
         return value if key.to_s.downcase == (field)
       end
@@ -512,50 +521,46 @@ module Statsig
     end
 
     def get_value_from_ip(user, field)
-      return nil unless user.is_a?(StatsigUser) && field.is_a?(String) && field.downcase == 'country'
-      ip = get_value_from_user(user, 'ip')
+      return nil unless field == Const::COUNTRY
+
+      ip = get_value_from_user(user, Const::IP)
       return nil unless ip.is_a?(String)
 
       CountryLookup.lookup_ip_string(ip)
     end
 
     def get_value_from_ua(user, field)
-      return nil unless user.is_a?(StatsigUser) && field.is_a?(String)
-      ua = get_value_from_user(user, 'userAgent')
+      return nil unless field.is_a?(String)
+
+      ua = get_value_from_user(user, Const::USER_AGENT)
       return nil unless ua.is_a?(String)
 
       case field.downcase
-      when 'os_name', 'osname'
+      when Const::OSNAME, Const::OS_NAME
         os = UAParser.parse_os(ua)
         return os&.family
-      when 'os_version', 'osversion'
+      when Const::OS_VERSION, Const::OSVERSION
         os = UAParser.parse_os(ua)
         return os&.version unless os&.version.nil?
-      when 'browser_name', 'browsername'
+      when Const::BROWSERNAME, Const::BROWSER_NAME
         parsed = UAParser.parse_ua(ua)
         return parsed.family
-      when 'browser_version', 'browserversion'
+      when Const::BROWSERVERSION, Const::BROWSER_VERSION
         parsed = UAParser.parse_ua(ua)
         return parsed.version.to_s
-      else
-        nil
       end
     end
 
     def eval_pass_percent(user, rule, config_salt)
-      return false unless config_salt.is_a?(String) && !rule['passPercentage'].nil?
-      begin
-        unit_id = user.get_unit_id(rule['idType']) || ''
-        rule_salt = rule['salt'] || rule['id'] || ''
-        hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
-        return (hash % 10000) < (rule['passPercentage'].to_f * 100)
-      rescue
-        return false
-      end
+      unit_id = user.get_unit_id(rule.id_type) || Const::EMPTY_STR
+      rule_salt = rule.salt || rule.id || Const::EMPTY_STR
+      hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
+      return (hash % 10_000) < (rule.pass_percentage * 100)
     end
 
     def compute_user_hash(user_hash)
-      Digest::SHA256.digest(user_hash).unpack('Q>')[0]
+      Digest::SHA256.digest(user_hash).unpack1(Const::Q_RIGHT_CHEVRON)
     end
+
   end
-end
+end