featurevisor 3.0.0 → 4.0.0

data/lib/featurevisor/evaluate.rb

@@ -6,8 +6,6 @@ module Featurevisor
     # Feature specific
     FEATURE_NOT_FOUND = "feature_not_found" # feature is not found in datafile
     DISABLED = "disabled" # feature is disabled
-    REQUIRED = "required" # required features are not enabled
-    OUT_OF_RANGE = "out_of_range" # out of range when mutually exclusive experiments are involved via Groups
 
     # Variations specific
     NO_VARIATIONS = "no_variations" # feature has no variations
@@ -19,7 +17,8 @@ module Featurevisor
     VARIABLE_DISABLED = "variable_disabled" # feature is disabled, and variable's disabledValue is used
     VARIABLE_OVERRIDE_VARIATION = "variable_override_variation" # variable overridden from inside a variation
     VARIABLE_OVERRIDE_RULE = "variable_override_rule" # variable overridden from inside a rule
-    REQUIRED_FEATURES_UNMET = "required_features_unmet"
+    CONDITIONS_UNMET = "conditions_unmet"
+    VARIABLE_COMPOSED = "variable_composed"
 
     # Common
     NO_MATCH = "no_match" # no rules matched
@@ -36,49 +35,8 @@ module Featurevisor
 
   # Evaluation module for feature flag evaluation
   module Evaluate
-    def self.required_features_are_matched(requirements, datafile, options)
-      return true if requirements.nil?
-
-      items = requirements.is_a?(Array) ? requirements : [requirements]
-      clean_options = options.reject do |key, _|
-        %i[feature_key variable_key default_variation_value default_variable_value].include?(key)
-      end
-      items.all? do |required|
-        if required.is_a?(String)
-          key = required
-          enabled = true
-          variation = nil
-        elsif required.key?(:feature)
-          key = required[:feature]
-          enabled = required.key?(:enabled) ? required[:enabled] : true
-          variation = required[:variation]
-        else
-          key = required[:key]
-          enabled = true
-          variation = required[:variation]
-        end
-
-        flag = evaluate_with_modules(clean_options.merge(type: "flag", feature_key: key, datafile: datafile))
-        next false unless (flag[:enabled] == true) == enabled
-        next true if variation.nil?
-
-        evaluated_variation = evaluate_with_modules(clean_options.merge(type: "variation", feature_key: key, datafile: datafile))
-        value = evaluated_variation.key?(:variation_value) ? evaluated_variation[:variation_value] : evaluated_variation.dig(:variation, :value)
-        value == variation
-      end
-    end
-
     def self.variable_override_matches?(override, datafile, context, options)
-      return false unless required_features_are_matched(override[:requiredFeatures], datafile, options)
-
-      conditions_match = !override[:conditions] || datafile.all_conditions_are_matched(
-        datafile.parse_conditions_if_stringified(override[:conditions]), context
-      )
-      segments_match = !override[:segments] || datafile.all_segments_are_matched(
-        datafile.parse_segments_if_stringified(override[:segments]), context
-      )
-      conditions_match && segments_match &&
-        (override.key?(:conditions) || override.key?(:segments) || override.key?(:requiredFeatures))
+      override.key?(:conditions) && UnifiedConditions.matches?(override[:conditions], options)
     end
 
     # Evaluate with modules
@@ -86,13 +44,36 @@ module Featurevisor
     # @return [Hash] Evaluation result
     def self.evaluate_with_modules(options)
       begin
+        session = options[:__featurevisor_session] || EvaluationSession.new
+        options = options.merge(__featurevisor_session: session)
+        if options[:__featurevisor_prerequisite]
+          options[:sticky] = options[:__featurevisor_sticky_features_source].call if options[:__featurevisor_sticky_features_source]
+          options[:sticky_variables] = options[:__featurevisor_sticky_variables_source].call if options[:__featurevisor_sticky_variables_source]
+          options[:datafile] = options[:__featurevisor_datafile_source].call if options[:__featurevisor_datafile_source]
+        end
+        options[:dependency_of] = session.dependency_of if options[:__featurevisor_prerequisite]
+        options[:dependency_purpose] ||= "condition" if options[:__featurevisor_prerequisite]
+        return session.run(options, prerequisite: options[:__featurevisor_prerequisite]) do
         modules_manager = options[:modules_manager]
-
-        # Run before modules
+        # The usual read has no modules. Keep its evaluation options intact so
+        # it does not allocate two filtered hashes and a merged hash.
         result_options = options
-        if modules_manager
-          result_options = modules_manager.run_before_modules(result_options)
+        if modules_manager && !modules_manager.get_all.empty?
+          private_options = options.select { |key, _| private_evaluation_option?(key) }
+          public_options = options.reject { |key, _| private_evaluation_option?(key) }
+          result_options = modules_manager.run_before_evaluation_modules(public_options)
+          result_options = result_options.reject { |key, _| private_evaluation_option?(key) }.merge(private_options)
         end
+        { sticky: :__featurevisor_sticky_features_source,
+          sticky_variables: :__featurevisor_sticky_variables_source }.each do |field, source|
+          if result_options[field].equal?(options[field])
+            result_options[field] = options[source].call if options[source]
+          else
+            replacement = result_options[field]
+            result_options[source] = -> { replacement }
+          end
+        end
+        session.update_current(result_options)
 
         # Evaluate
         evaluation = evaluate(result_options)
@@ -113,12 +94,18 @@ module Featurevisor
         end
 
         # Run after modules
-        if modules_manager
-          evaluation = modules_manager.run_after_modules(evaluation, result_options)
+        # A callback during evaluation may add a module. In that case its
+        # after hook still receives only public options.
+        if modules_manager && !modules_manager.get_all.empty?
+          evaluation = modules_manager.run_after_evaluation_modules(
+            evaluation, result_options.reject { |key, _| private_evaluation_option?(key) }
+          )
         end
 
         evaluation
+        end
       rescue => e
+        raise if e.is_a?(RequirementError) && options[:__featurevisor_prerequisite]
         type = options[:type]
         feature_key = options[:feature_key]
         variable_key = options[:variable_key]
@@ -132,12 +119,18 @@ module Featurevisor
           error: e
         }
 
+        session.remember(options, evaluation) if session
+
         diagnostics.error("Error during evaluation", evaluation)
 
         evaluation
       end
     end
 
+    def self.private_evaluation_option?(key)
+      key.to_s.start_with?("__featurevisor_")
+    end
+
     # Main evaluation function
     # @param options [Hash] Evaluation options
     # @return [Hash] Evaluation result
@@ -228,7 +221,7 @@ module Featurevisor
               type: type,
               feature_key: feature_key,
               reason: Featurevisor::EvaluationReason::STICKY,
-              sticky: sticky_feature,
+              sticky_feature: sticky_feature,
               enabled: sticky_feature[:enabled]
             }
 
@@ -341,7 +334,7 @@ module Featurevisor
         end
 
         # Forced
-        force_result = datafile.get_matched_force(feature, context)
+        force_result = datafile.get_matched_force(feature, context, options)
         force = force_result[:force]
         force_index = force_result[:forceIndex]
 
@@ -402,25 +395,17 @@ module Featurevisor
           end
         end
 
-        # Required
-        required_features = feature[:requiredFeatures] || feature[:required]
-        if type == "flag" && required_features && !Array(required_features).empty?
-          required_features_are_enabled = required_features_are_matched(required_features, datafile, options)
-
-          unless required_features_are_enabled
-            evaluation = {
-              type: type,
-              feature_key: feature_key,
-              reason: Featurevisor::EvaluationReason::REQUIRED,
-              required: feature[:required],
-              required_features: feature[:requiredFeatures],
-              enabled: required_features_are_enabled
-            }
-
-            diagnostics.debug("required features not enabled", evaluation)
-
-            return evaluation
-          end
+        if type == "flag" && feature.key?(:conditions) &&
+           !UnifiedConditions.matches?(feature[:conditions], options)
+          evaluation = {
+            type: type,
+            feature_key: feature_key,
+            reason: Featurevisor::EvaluationReason::CONDITIONS_UNMET,
+            conditions: feature[:conditions],
+            enabled: false
+          }
+          diagnostics.debug("conditions did not match", evaluation)
+          return evaluation
         end
 
         # Bucketing
@@ -455,13 +440,13 @@ module Featurevisor
         matched_allocation = nil
 
         if type != "flag"
-          matched_traffic = datafile.get_matched_traffic(feature[:traffic], context)
+          matched_traffic = datafile.get_matched_traffic(feature[:traffic], context, options)
 
           if matched_traffic
             matched_allocation = datafile.get_matched_allocation(matched_traffic, bucket_value)
           end
         else
-          matched_traffic = datafile.get_matched_traffic(feature[:traffic], context)
+          matched_traffic = datafile.get_matched_traffic(feature[:traffic], context, options)
         end
 
         if matched_traffic
@@ -485,45 +470,6 @@ module Featurevisor
 
           # flag
           if type == "flag"
-            # flag: check if mutually exclusive
-            if feature[:ranges] && feature[:ranges].length > 0
-              matched_range = feature[:ranges].find do |range|
-                bucket_value >= range[0] && bucket_value < range[1]
-              end
-
-              # matched
-              if matched_range
-                evaluation = {
-                  type: type,
-                  feature_key: feature_key,
-                  reason: Featurevisor::EvaluationReason::ALLOCATED,
-                  bucket_key: bucket_key,
-                  bucket_value: bucket_value,
-                  rule_key: matched_traffic[:key],
-                  traffic: matched_traffic,
-                  enabled: matched_traffic[:enabled].nil? ? true : matched_traffic[:enabled]
-                }
-
-                diagnostics.debug("matched", evaluation)
-
-                return evaluation
-              end
-
-              # no match
-              evaluation = {
-                type: type,
-                feature_key: feature_key,
-                reason: Featurevisor::EvaluationReason::OUT_OF_RANGE,
-                bucket_key: bucket_key,
-                bucket_value: bucket_value,
-                enabled: false
-              }
-
-              diagnostics.debug("not matched", evaluation)
-
-              return evaluation
-            end
-
             # flag: override from rule
             if matched_traffic.key?(:enabled)
               evaluation = {
@@ -634,7 +580,8 @@ module Featurevisor
                 variable_schema: variable_schema,
                 variable_value: override[:value],
                 variable_override_index: override_index,
-                variable_override_key: override[:key]
+                variable_override_key: override[:key],
+                variable_override_path: override[:keyPath]
               }
 
               diagnostics.debug("variable override from rule", evaluation)
@@ -698,7 +645,8 @@ module Featurevisor
                   variable_schema: variable_schema,
                   variable_value: override[:value],
                   variable_override_index: override_index,
-                  variable_override_key: override[:key]
+                  variable_override_key: override[:key],
+                  variable_override_path: override[:keyPath]
                 }
 
                 diagnostics.debug("variable override from variation", evaluation)
@@ -791,6 +739,7 @@ module Featurevisor
 
         evaluation
       rescue => e
+        raise if e.is_a?(RequirementError)
         evaluation = {
           type: type,
           feature_key: feature_key,

data/lib/featurevisor/evaluation_data_provider.rb

@@ -5,7 +5,8 @@ require "json"
 module Featurevisor
   # Private datafile and matching adapter used by the evaluator.
   class InstanceEvaluationDataProvider
-    attr_reader :schema_version, :revision, :featurevisor_version, :segments, :features, :variables, :diagnostics, :regex_cache
+    attr_reader :schema_version, :revision, :featurevisor_version, :segments, :features, :variables, :diagnostics, :regex_cache, :normalized
+    attr_accessor :dependency_index
 
     # Initialize a new evaluation data provider.
     # @param options [Hash] Options hash containing datafile and diagnostics
@@ -21,38 +22,14 @@ module Featurevisor
       @segments = (datafile[:segments] || {}).transform_keys(&:to_sym)
       @features = (datafile[:features] || {}).transform_keys(&:to_sym)
       @variables = (datafile[:variables] || {}).transform_keys(&:to_sym)
-
-      # Transform nested structures to use symbol keys
-      @features.each do |_key, feature|
-        if feature[:variablesSchema]
-          feature[:variablesSchema] = feature[:variablesSchema].transform_keys(&:to_sym)
-        end
-        if feature[:variations]
-          feature[:variations].each do |variation|
-            if variation[:variables]
-              variation[:variables] = variation[:variables].transform_keys(&:to_sym)
-            end
-            if variation[:variableOverrides]
-              variation[:variableOverrides] = variation[:variableOverrides].transform_keys(&:to_sym)
-            end
-          end
-        end
-        if feature[:force]
-          feature[:force].each do |force_rule|
-            if force_rule[:variables]
-              force_rule[:variables] = force_rule[:variables].transform_keys(&:to_sym)
-            end
-          end
-        end
-        if feature[:traffic]
-          feature[:traffic].each do |traffic_rule|
-            if traffic_rule[:variables]
-              traffic_rule[:variables] = traffic_rule[:variables].transform_keys(&:to_sym)
-            end
-          end
-        end
-      end
+      @normalized = { feature: {}, segment: {}, variable: {} }
+      @normalization_slots = { feature: {}, segment: {}, variable: {} }
+      @normalization_mutex = Mutex.new
       @regex_cache = {}
+      @conditions_cache = {}
+      @segments_cache = {}
+      @attribute_conditions_cache = {}
+      @get_regex = method(:get_regex)
     end
 
     # Get the revision of the datafile
@@ -82,12 +59,7 @@ module Featurevisor
     # @param segment_key [String] Segment key to retrieve
     # @return [Hash, nil] Segment data or nil if not found
     def get_segment(segment_key)
-      segment = @segments[segment_key.to_sym] || @segments[segment_key]
-
-      return nil unless segment
-
-      segment[:conditions] = parse_conditions_if_stringified(segment[:conditions])
-      segment
+      read_entity(:segment, segment_key, @segments)
     end
 
     def get_segment_keys
@@ -104,7 +76,7 @@ module Featurevisor
     # @param feature_key [String] Feature key to retrieve
     # @return [Hash, nil] Feature data or nil if not found
     def get_feature(feature_key)
-      @features[feature_key.to_sym] || @features[feature_key]
+      read_entity(:feature, feature_key, @features)
     end
 
     # Get variable keys for a feature
@@ -121,7 +93,60 @@ module Featurevisor
     end
 
     def get_global_variable(variable_key)
-      @variables[variable_key.to_sym] || @variables[variable_key]
+      read_entity(:variable, variable_key, @variables)
+    end
+
+    def attribute_only_conditions?(conditions)
+      key = conditions.object_id
+      cached = @attribute_conditions_cache[key]
+      return cached[1] if cached
+
+      # Retain the syntax with its identity. Cache classification, never matches.
+      @attribute_conditions_cache[key] = [conditions, UnifiedConditions.send(:attribute_only?, conditions)]
+      @attribute_conditions_cache[key][1]
+    end
+
+    def retain_normalized(previous, incoming)
+      @normalization_mutex, @normalization_slots, @normalized = previous.normalization_snapshot
+      { feature: :features, segment: :segments, variable: :variables }.each do |kind, name|
+        (incoming[name] || {}).each_key do |key|
+          @normalization_slots[kind][key.to_sym] = []
+          @normalized[kind].delete(key.to_sym)
+        end
+      end
+    end
+
+    # Share individual cold slots, never a chain of previous providers.
+    def normalization_snapshot
+      @normalization_mutex.synchronize do
+        { feature: @features, segment: @segments, variable: @variables }.each do |kind, definitions|
+          next if @normalization_slots[kind].size == definitions.size
+          definitions.each_key { |key| @normalization_slots[kind][key] ||= [] }
+        end
+        [@normalization_mutex, @normalization_slots.transform_values(&:dup), @normalized.transform_values(&:dup)]
+      end
+    end
+
+    def read_entity(kind, key, definitions)
+      name = key.to_sym
+      cached = @normalized[kind][name]
+      return cached if cached
+      source = definitions[name] || definitions[key]
+      return nil unless source
+      errors = []
+      value = @normalization_mutex.synchronize do
+        slot = @normalization_slots[kind][name] ||= []
+        if slot.empty?
+          normalized, errors = Normalize.entity(kind, name, source)
+          slot << normalized
+        end
+        @normalized[kind][name] = slot.first
+      end
+      # Publication precedes diagnostics, and application callbacks never hold the mutex.
+      errors.each do |error|
+        @diagnostics.error(error[:message], { code: error[:code], error: error[:original_error], details: error[:details] })
+      end
+      value
     end
 
     # Check if a feature has variations
@@ -153,7 +178,7 @@ module Featurevisor
       invalid_flags = flags.delete("gimsuy")
       raise ArgumentError, "invalid regular expression flags: #{invalid_flags}" unless invalid_flags.empty?
 
-      regex = Regexp.new(regex_string, ruby_flags)
+      regex = Regexp.new(Conditions.normalize_portable_regex(regex_string), ruby_flags)
       @regex_cache[cache_key] = regex
       @regex_cache[cache_key]
     end
@@ -168,11 +193,9 @@ module Featurevisor
         return false
       end
 
-      get_regex_proc = ->(regex_string, regex_flags) { get_regex(regex_string, regex_flags) }
-
       if conditions.is_a?(Hash) && (conditions[:attribute] || conditions["attribute"])
         begin
-          result = Conditions.condition_is_matched(conditions, context, get_regex_proc)
+          result = Conditions.condition_is_matched(conditions, context, @get_regex)
           return result
         rescue => e
           @diagnostics.warn(e.message, {
@@ -186,11 +209,11 @@ module Featurevisor
       end
 
       if conditions.is_a?(Hash) && conditions[:and] && conditions[:and].is_a?(Array)
-        return conditions[:and].all? { |c| all_conditions_are_matched(c, context) }
+        return !conditions[:and].empty? && conditions[:and].all? { |c| all_conditions_are_matched(c, context) }
       end
 
       if conditions.is_a?(Hash) && conditions["and"] && conditions["and"].is_a?(Array)
-        return conditions["and"].all? { |c| all_conditions_are_matched(c, context) }
+        return !conditions["and"].empty? && conditions["and"].all? { |c| all_conditions_are_matched(c, context) }
       end
 
       if conditions.is_a?(Hash) && conditions[:or] && conditions[:or].is_a?(Array)
@@ -214,7 +237,7 @@ module Featurevisor
 
 
       if conditions.is_a?(Array)
-        return conditions.all? { |c| all_conditions_are_matched(c, context) }
+        return !conditions.empty? && conditions.all? { |c| all_conditions_are_matched(c, context) }
       end
 
       false
@@ -288,8 +311,9 @@ module Featurevisor
     # @param traffic [Array<Hash>] Traffic array to search
     # @param context [Hash] Context to evaluate against
     # @return [Hash, nil] Matched traffic or nil
-    def get_matched_traffic(traffic, context)
+    def get_matched_traffic(traffic, context, options = nil)
       traffic.find do |t|
+        next t.key?(:conditions) && UnifiedConditions.matches?(t[:conditions], options) if options
         segments = parse_segments_if_stringified(t[:segments])
         matched = all_segments_are_matched(segments, context)
         next false unless matched
@@ -314,7 +338,7 @@ module Featurevisor
     # @param feature_key [String, Hash] Feature key or feature object
     # @param context [Hash] Context to evaluate against
     # @return [Hash] Force result with force and forceIndex
-    def get_matched_force(feature_key, context)
+    def get_matched_force(feature_key, context, options = nil)
       result = {
         force: nil,
         forceIndex: nil
@@ -325,6 +349,14 @@ module Featurevisor
       return result unless feature && feature[:force]
 
       feature[:force].each_with_index do |current_force, i|
+        if options
+          if current_force.key?(:conditions) && UnifiedConditions.matches?(current_force[:conditions], options)
+            result[:force] = current_force
+            result[:forceIndex] = i
+            break
+          end
+          next
+        end
         if current_force[:conditions] && all_conditions_are_matched(
           parse_conditions_if_stringified(current_force[:conditions]), context
         )
@@ -352,9 +384,10 @@ module Featurevisor
       return conditions unless conditions.is_a?(String)
 
       return conditions if conditions == "*"
+      return @conditions_cache[conditions] if @conditions_cache.key?(conditions)
 
       begin
-        JSON.parse(conditions)
+        @conditions_cache[conditions] = JSON.parse(conditions)
       rescue => e
         @diagnostics.error("Error parsing conditions", {
           error: e,
@@ -371,11 +404,27 @@ module Featurevisor
     # @return [Array, Hash, String] Parsed segments
     def parse_segments_if_stringified(segments)
       if segments.is_a?(String) && (segments.start_with?("{") || segments.start_with?("["))
-        return JSON.parse(segments)
+        return @segments_cache[segments] if @segments_cache.key?(segments)
+
+        return @segments_cache[segments] = JSON.parse(segments)
       end
 
       segments
     end
+
+    # Cache parsed expressions, never context dependent matching results.
+    # A new provider owns a new generation after each datafile update.
+    def clear_caches
+      @dependency_index = nil
+      @normalization_mutex.synchronize do
+        @normalized.each_value(&:clear)
+        @normalization_slots.each_value(&:clear)
+      end
+      @regex_cache.clear
+      @conditions_cache.clear
+      @segments_cache.clear
+      @attribute_conditions_cache.clear
+    end
   end
 
   private_constant :InstanceEvaluationDataProvider