featurevisor 1.1.0 → 3.0.0

data/lib/featurevisor/instance.rb

@@ -11,7 +11,8 @@ module Featurevisor
       schemaVersion: "2",
       revision: "unknown",
       segments: {},
-      features: {}
+      features: {},
+      variables: {}
     }.freeze
 
     # Initialize a new Featurevisor instance
@@ -19,26 +20,27 @@ module Featurevisor
     # @option options [Hash, String] :datafile Datafile content or JSON string
     # @option options [Hash] :context Initial context
     # @option options [String] :log_level Log level
-    # @option options [Hash] :sticky Sticky features
+    # @option options [Hash] :sticky_features Sticky features
     # @option options [Array<Hash, FeaturevisorModule>] :modules Array of modules
     # @option options [Proc] :on_diagnostic Diagnostic handler
     def initialize(options = {})
       # from options
       @context = options[:context] || {}
-      @logger = Logger.new(
+      @diagnostics = DiagnosticReporter.new(
         level: options[:log_level] || "info",
-        handler: method(:handle_internal_log)
+        handler: method(:handle_evaluation_diagnostic)
       )
       @on_diagnostic = options[:on_diagnostic] || options[:onDiagnostic]
       @emitter = Featurevisor::Emitter.new
-      @sticky = options[:sticky] || {}
+      @sticky_features = options[:sticky_features] || options[:stickyFeatures] || {}
+      @sticky_variables = options[:sticky_variables] || options[:stickyVariables] || {}
       @closed = false
       @module_diagnostic_subscriptions = []
 
       # datafile
-      @datafile_reader = DatafileReader.new(
+      @datafile = InstanceEvaluationDataProvider.new(
         datafile: EMPTY_DATAFILE,
-        logger: @logger
+        diagnostics: @diagnostics
       )
 
       @modules_manager = Featurevisor::Modules::ModulesManager.new(
@@ -62,21 +64,35 @@ module Featurevisor
     # Set the log level
     # @param level [String] Log level
     def set_log_level(level)
-      @logger.set_level(level)
+      @diagnostics.set_level(level)
     end
 
-    def handle_internal_log(level, message, details = nil)
+    def handle_evaluation_diagnostic(level, message, details = nil)
       details = (details || {}).dup
-      code = details[:reason] || details["reason"] || message
+      code = details.delete(:code) || details.delete("code") || details[:reason] || details["reason"] || message
       code = "deprecated_feature" if message == "feature is deprecated"
       code = "deprecated_variable" if message == "variable is deprecated"
       code = "feature_not_found" if message == "feature not found"
       code = "variable_not_found" if message == "variable schema not found"
       code = "no_variations" if message == "no variations"
       code = "invalid_bucket_by" if message == "invalid bucketBy"
-      report_diagnostic(level: level, code: code.to_s, message: message, details: details)
+      code = "evaluation_error" if message == "Error during evaluation"
+      code = "conditions_parse_error" if message == "Error parsing conditions"
+      original_error = details.delete(:error) || details.delete("error")
+      nested_details = details.delete(:details) || details.delete("details")
+      details.merge!(nested_details) if nested_details.is_a?(Hash)
+      if details.key?(:feature_key) && details.key?(:reason)
+        evaluation = details.dup
+        details = {
+          featureKey: evaluation[:feature_key],
+          variableKey: evaluation[:variable_key],
+          reason: evaluation[:reason],
+          evaluation: camelize_diagnostic_value(evaluation)
+        }
+      end
+      report_diagnostic(level: level, code: code.to_s, message: message, details: details, originalError: original_error)
     end
-    private :handle_internal_log
+    private :handle_evaluation_diagnostic
 
     # Set the datafile
     # @param datafile [Hash, String] Datafile content or JSON string
@@ -94,17 +110,18 @@ module Featurevisor
                           end
         unless parsed_datafile.is_a?(Hash) && parsed_datafile[:schemaVersion].is_a?(String) &&
                parsed_datafile[:revision].is_a?(String) && parsed_datafile[:segments].is_a?(Hash) &&
-               parsed_datafile[:features].is_a?(Hash)
+               parsed_datafile[:features].is_a?(Hash) &&
+               (!parsed_datafile.key?(:variables) || parsed_datafile[:variables].is_a?(Hash))
           raise ArgumentError, "Invalid datafile"
         end
-        next_datafile = replace ? parsed_datafile : merge_datafiles(@datafile_reader.get_datafile, parsed_datafile)
-        new_datafile_reader = DatafileReader.new(
+        next_datafile = replace ? parsed_datafile : merge_datafiles(@datafile.get_datafile, parsed_datafile)
+        new_datafile = InstanceEvaluationDataProvider.new(
           datafile: next_datafile,
-          logger: @logger
+          diagnostics: @diagnostics
         )
 
-        details = Featurevisor::Events.get_params_for_datafile_set_event(@datafile_reader, new_datafile_reader, replace)
-        @datafile_reader = new_datafile_reader
+        details = Featurevisor::Events.get_params_for_datafile_set_event(@datafile, new_datafile, replace)
+        @datafile = new_datafile
 
         report_diagnostic(
           level: "info",
@@ -126,60 +143,68 @@ module Featurevisor
     # Set sticky features
     # @param sticky [Hash] Sticky features
     # @param replace [Boolean] Whether to replace existing sticky features
-    def set_sticky(sticky, replace = false)
-      previous_sticky_features = @sticky || {}
+    def set_sticky_features(sticky, replace = false)
+      previous_sticky_features = @sticky_features || {}
 
       if replace
-        @sticky = sticky
+        @sticky_features = sticky
       else
-        @sticky = {
-          **@sticky,
+        @sticky_features = {
+          **@sticky_features,
           **sticky
         }
       end
 
-      params = Featurevisor::Events.get_params_for_sticky_set_event(previous_sticky_features, @sticky, replace)
+      params = Featurevisor::Events.get_params_for_sticky_features_set_event(previous_sticky_features, @sticky_features, replace)
 
       report_diagnostic(
         level: "info",
-        code: "sticky_set",
+        code: "sticky_features_set",
         message: "Sticky features set",
         details: params
       )
-      @emitter.trigger("sticky_set", params)
+      @emitter.trigger("sticky_features_set", params)
+    end
+
+    def set_sticky_variables(sticky, replace = false)
+      previous = @sticky_variables || {}
+      @sticky_variables = replace ? sticky : { **@sticky_variables, **sticky }
+      params = Featurevisor::Events.get_params_for_sticky_variables_set_event(previous, @sticky_variables, replace)
+      report_diagnostic(level: "info", code: "sticky_variables_set", message: "Sticky variables set", details: params)
+      @emitter.trigger("sticky_variables_set", params)
     end
 
     # Get the revision
     # @return [String] Revision string
     def get_revision
-      @datafile_reader.get_revision
+      @datafile.get_revision
     end
 
     def get_schema_version
-      @datafile_reader.get_schema_version
+      @datafile.get_schema_version
     end
 
     def get_segment(segment_key)
-      @datafile_reader.get_segment(segment_key)
+      @datafile.get_segment(segment_key)
     end
 
     def get_feature_keys
-      @datafile_reader.get_feature_keys
+      @datafile.get_feature_keys
     end
 
-    def get_variable_keys(feature_key)
-      @datafile_reader.get_variable_keys(feature_key)
+    def get_variable_keys(feature_key = nil)
+      @datafile.get_variable_keys(feature_key)
     end
 
     def has_variations?(feature_key)
-      @datafile_reader.has_variations?(feature_key)
+      @datafile.has_variations?(feature_key)
     end
 
     # Get a feature by key
     # @param feature_key [String] Feature key
     # @return [Hash, nil] Feature data or nil if not found
     def get_feature(feature_key)
-      @datafile_reader.get_feature(feature_key)
+      @datafile.get_feature(feature_key)
     end
 
     # Add a module
@@ -189,8 +214,8 @@ module Featurevisor
       @modules_manager.add(mod)
     end
 
-    def remove_module(name_or_module)
-      @modules_manager.remove(name_or_module)
+    def remove_module(name)
+      @modules_manager.remove(name)
     end
 
     # Subscribe to an event
@@ -198,11 +223,15 @@ module Featurevisor
     # @param callback [Proc] Callback function
     # @return [Proc] Unsubscribe function
     def on(event_name, callback)
+      return -> {} if @closed
+
       @emitter.on(event_name, callback)
     end
 
     # Close the instance
     def close
+      return if @closed
+
       @closed = true
       @modules_manager.close_all
       @module_diagnostic_subscriptions = []
@@ -257,7 +286,8 @@ module Featurevisor
       Featurevisor::ChildInstance.new(
         parent: self,
         context: get_context(context),
-        sticky: options[:sticky]
+        sticky_features: options[:sticky_features] || options[:stickyFeatures],
+        sticky_variables: options[:sticky_variables] || options[:stickyVariables]
       )
     end
 
@@ -285,7 +315,7 @@ module Featurevisor
         evaluation = evaluate_flag(feature_key, context, options)
         evaluation[:enabled] == true
       rescue => e
-        @logger.error("isEnabled", { feature_key: feature_key, error: e })
+        report_diagnostic(level: "error", code: "evaluation_error", message: "isEnabled failed", originalError: e, details: { featureKey: feature_key })
         false
       end
     end
@@ -313,7 +343,7 @@ module Featurevisor
       begin
         evaluation = evaluate_variation(feature_key, context, options)
 
-        if evaluation[:variation_value]
+        if evaluation.key?(:variation_value)
           evaluation[:variation_value]
         elsif evaluation[:variation]
           evaluation[:variation][:value]
@@ -321,7 +351,7 @@ module Featurevisor
           nil
         end
       rescue => e
-        @logger.error("getVariation", { feature_key: feature_key, error: e })
+        report_diagnostic(level: "error", code: "evaluation_error", message: "getVariation failed", originalError: e, details: { featureKey: feature_key })
         nil
       end
     end
@@ -332,12 +362,17 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Hash] Evaluation result
-    def evaluate_variable(feature_key, variable_key, context = {}, options = {})
+    def evaluate_variable(feature_or_variable_key, variable_key_or_context = nil, context_or_options = {}, options = {})
+      if variable_key_or_context.nil? || variable_key_or_context.is_a?(Hash)
+        context = variable_key_or_context || {}
+        return evaluate_variable_without_feature(feature_or_variable_key, context, context_or_options)
+      end
+
       Featurevisor::Evaluate.evaluate_with_modules(
-        get_evaluation_dependencies(context, options).merge(
+        get_evaluation_dependencies(context_or_options, options).merge(
           type: "variable",
-          feature_key: feature_key,
-          variable_key: variable_key
+          feature_key: feature_or_variable_key,
+          variable_key: variable_key_or_context
         )
       )
     end
@@ -348,13 +383,13 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Object, nil] Variable value or nil
-    def get_variable(feature_key, variable_key, context = {}, options = {})
+    def get_variable(feature_or_variable_key, variable_key_or_context = nil, context_or_options = {}, options = {})
       begin
-        evaluation = evaluate_variable(feature_key, variable_key, context, options)
+        evaluation = evaluate_variable(feature_or_variable_key, variable_key_or_context, context_or_options, options)
 
-        if !evaluation[:variable_value].nil?
-          if evaluation[:variable_schema] &&
-             evaluation[:variable_schema][:type] == "json" &&
+        if evaluation.key?(:variable_value)
+          variable_type = evaluation.dig(:variable_schema, :type) || evaluation.dig(:variable, :type)
+          if variable_type == "json" &&
              evaluation[:variable_value].is_a?(String)
             JSON.parse(evaluation[:variable_value], symbolize_names: true)
           else
@@ -364,7 +399,7 @@ module Featurevisor
           nil
         end
       rescue => e
-        @logger.error("getVariable", { feature_key: feature_key, variable_key: variable_key, error: e })
+        report_diagnostic(level: "error", code: "evaluation_error", message: "getVariable failed", originalError: e, details: { variableKey: variable_key_or_context || feature_or_variable_key })
         nil
       end
     end
@@ -375,8 +410,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Boolean, nil] Boolean value or nil
-    def get_variable_boolean(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_boolean(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "boolean")
     end
 
@@ -386,8 +421,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [String, nil] String value or nil
-    def get_variable_string(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_string(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "string")
     end
 
@@ -397,8 +432,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Integer, nil] Integer value or nil
-    def get_variable_integer(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_integer(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "integer")
     end
 
@@ -408,8 +443,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Float, nil] Float value or nil
-    def get_variable_double(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_double(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "double")
     end
 
@@ -419,8 +454,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Array, nil] Array value or nil
-    def get_variable_array(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_array(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "array")
     end
 
@@ -430,8 +465,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Hash, nil] Object value or nil
-    def get_variable_object(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_object(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "object")
     end
 
@@ -441,8 +476,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Object, nil] JSON value or nil
-    def get_variable_json(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_json(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "json")
     end
 
@@ -451,10 +486,10 @@ module Featurevisor
     # @param feature_keys [Array<String>] Feature keys to evaluate
     # @param options [Hash] Override options
     # @return [Hash] All evaluations
-    def get_all_evaluations(context = {}, feature_keys = [], options = {})
+    def get_feature_evaluations(context = {}, feature_keys = [], options = {})
       result = {}
 
-              keys = feature_keys.size > 0 ? feature_keys : @datafile_reader.get_feature_keys
+      keys = feature_keys.size > 0 ? feature_keys : @datafile.get_feature_keys
 
       keys.each do |feature_key|
         # Convert symbol keys to strings for evaluation functions
@@ -466,13 +501,13 @@ module Featurevisor
         }
 
         # variation
-        if @datafile_reader.has_variations?(feature_key_str)
+        if @datafile.has_variations?(feature_key_str)
           variation = get_variation(feature_key_str, context, options)
-          evaluated_feature[:variation] = variation if variation
+          evaluated_feature[:variation] = variation unless variation.nil?
         end
 
         # variables
-        variable_keys = @datafile_reader.get_variable_keys(feature_key_str)
+        variable_keys = @datafile.get_variable_keys(feature_key_str)
         if variable_keys.size > 0
           evaluated_feature[:variables] = {}
 
@@ -492,8 +527,100 @@ module Featurevisor
       result
     end
 
+    def get_variable_evaluations(context = {}, variable_keys = [], options = {})
+      keys = variable_keys.empty? ? @datafile.get_variable_keys : variable_keys
+      keys.to_h { |key| [key, get_variable(key.to_s, context, options)] }
+    end
+
     private
 
+    def evaluate_variable_without_feature(variable_key, context = {}, options = {})
+      evaluation_options = {
+        type: "variable",
+        variable_key: variable_key.to_s,
+        context: get_context(context)
+      }
+      evaluation_options[:default_variable_value] = options[:default_variable_value] if options.key?(:default_variable_value)
+      begin
+        evaluation_options = @modules_manager.run_before_evaluation_modules(evaluation_options)
+        resolved_key = evaluation_options[:variable_key]
+        variable = @datafile.get_global_variable(resolved_key)
+        sticky = options[:__featurevisor_child_sticky_variables] || @sticky_variables
+        evaluation = { type: "variable", variable_key: resolved_key, reason: Featurevisor::EvaluationReason::VARIABLE_NOT_FOUND }
+
+        if sticky.key?(resolved_key) || sticky.key?(resolved_key.to_sym)
+          sticky_value = sticky.key?(resolved_key) ? sticky[resolved_key] : sticky[resolved_key.to_sym]
+          evaluation.merge!(reason: Featurevisor::EvaluationReason::STICKY, variable: variable,
+                            variable_value: sticky_value)
+        elsif variable
+          unless required_features_are_matched(variable[:requiredFeatures], evaluation_options[:context], options)
+            value_key = variable[:useDefaultWhenDisabled] ? :defaultValue : :disabledValue
+            evaluation.merge!(reason: Featurevisor::EvaluationReason::REQUIRED_FEATURES_UNMET,
+                              variable: variable)
+            evaluation[:variable_value] = variable[value_key] if variable.key?(value_key)
+          else
+            (variable[:overrides] || []).each_with_index do |override, index|
+              next unless required_features_are_matched(override[:requiredFeatures], evaluation_options[:context], options)
+              conditions_match = !override[:conditions] || @datafile.all_conditions_are_matched(
+                @datafile.parse_conditions_if_stringified(override[:conditions]), evaluation_options[:context]
+              )
+              segments_match = !override[:segments] || @datafile.all_segments_are_matched(
+                @datafile.parse_segments_if_stringified(override[:segments]), evaluation_options[:context]
+              )
+              next unless conditions_match && segments_match
+
+              evaluation.merge!(reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_RULE,
+                                variable: variable,
+                                variable_override_index: index, variable_override_key: override[:key],
+                                variable_override_path: override[:keyPath])
+              evaluation[:variable_value] = override[:value] if override.key?(:value)
+              break
+            end
+            if evaluation[:reason] == Featurevisor::EvaluationReason::VARIABLE_NOT_FOUND
+              evaluation.merge!(reason: Featurevisor::EvaluationReason::VARIABLE_DEFAULT,
+                                variable: variable)
+              evaluation[:variable_value] = variable[:defaultValue] if variable.key?(:defaultValue)
+            end
+          end
+          report_diagnostic(level: "warn", code: "variable_deprecated", message: "Variable \"#{resolved_key}\" is deprecated",
+                            details: { variableKey: resolved_key, evaluation: evaluation }) if variable[:deprecated]
+        end
+
+        if !evaluation.key?(:variable_value) && evaluation_options.key?(:default_variable_value)
+          evaluation[:variable_value] = evaluation_options[:default_variable_value]
+        end
+        evaluation = @modules_manager.run_global_after_modules(evaluation, evaluation_options)
+        report_diagnostic(level: "debug", code: evaluation[:reason], message: "Global variable evaluated", details: evaluation)
+        evaluation
+      rescue => e
+        evaluation = { type: "variable", variable_key: evaluation_options[:variable_key],
+                       reason: Featurevisor::EvaluationReason::ERROR, error: e }
+        report_diagnostic(level: "error", code: "evaluation_error", message: "Global variable evaluation failed",
+                          originalError: e, details: evaluation)
+        evaluation
+      end
+    end
+
+    def required_features_are_matched(requirements, context, options)
+      return true if requirements.nil?
+
+      items = requirements.is_a?(Array) ? requirements : [requirements]
+      clean_options = options.reject { |key, _| %i[default_variation_value default_variable_value].include?(key) }
+      items.all? do |required|
+        if required.is_a?(String)
+          key = required
+          expected_enabled = true
+          expected_variation = nil
+        else
+          key = required[:feature]
+          expected_enabled = required.key?(:enabled) ? required[:enabled] : true
+          expected_variation = required[:variation]
+        end
+        next false unless is_enabled(key, context, clean_options) == expected_enabled
+        expected_variation.nil? || get_variation(key, context, clean_options) == expected_variation
+      end
+    end
+
     # Get evaluation dependencies
     # @param context [Hash] Context
     # @param options [Hash] Override options
@@ -501,13 +628,15 @@ module Featurevisor
     def get_evaluation_dependencies(context, options = {})
       {
         context: get_context(context),
-        logger: @logger,
+        diagnostics: @diagnostics,
         modules_manager: @modules_manager,
-        datafile_reader: @datafile_reader,
-        sticky: options[:__featurevisor_child_sticky] || @sticky,
-        default_variation_value: options[:default_variation_value],
-        default_variable_value: options[:default_variable_value]
-      }
+        datafile: @datafile,
+        sticky: options[:__featurevisor_child_sticky_features] || @sticky_features,
+        sticky_variables: options[:__featurevisor_child_sticky_variables] || @sticky_variables,
+      }.tap do |dependencies|
+        dependencies[:default_variation_value] = options[:default_variation_value] if options.key?(:default_variation_value)
+        dependencies[:default_variable_value] = options[:default_variable_value] if options.key?(:default_variable_value)
+      end
     end
 
     # Get value by type
@@ -554,6 +683,10 @@ module Featurevisor
         features: {
           **(previous[:features] || {}),
           **(incoming[:features] || {})
+        },
+        variables: {
+          **(previous[:variables] || {}),
+          **(incoming[:variables] || {})
         }
       }.compact
     end
@@ -584,7 +717,7 @@ module Featurevisor
       diagnostic = (diagnostic || {}).dup
       diagnostic[:level] ||= "info"
       diagnostic[:module] = source_module.name if source_module && source_module.name
-      details = (diagnostic[:details] || {}).dup
+      details = camelize_diagnostic_value((diagnostic[:details] || {}).dup)
       legacy_module_name = diagnostic.delete(:module_name)
       legacy_original_error = diagnostic.delete(:original_error)
       diagnostic[:moduleName] = legacy_module_name if !diagnostic.key?(:moduleName) && !legacy_module_name.nil?
@@ -609,7 +742,7 @@ module Featurevisor
       end
 
       if @on_diagnostic
-        if should_report_diagnostic?(diagnostic[:level], @logger.level)
+        if should_report_diagnostic?(diagnostic[:level], @diagnostics.level)
           begin
             @on_diagnostic.call(diagnostic)
           rescue => e
@@ -617,7 +750,7 @@ module Featurevisor
           end
         end
       else
-        Logger.new(level: @logger.level).log(
+        DiagnosticReporter.new(level: @diagnostics.level).log(
           diagnostic[:level],
           diagnostic[:message],
           diagnostic
@@ -638,6 +771,21 @@ module Featurevisor
 
       subscriber_index >= diagnostic_index
     end
+
+    def camelize_diagnostic_value(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, item), result|
+          normalized_key = key.to_s.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }.to_sym
+          result[normalized_key] = camelize_diagnostic_value(item)
+        end
+      when Array
+        value.map { |item| camelize_diagnostic_value(item) }
+      else
+        value
+      end
+    end
+    private :camelize_diagnostic_value
   end
 
   # Create a new Featurevisor instance

data/lib/featurevisor/modules.rb

@@ -13,9 +13,11 @@ module Featurevisor
         @name = options[:name]
         @setup = options[:setup]
         @before = options[:before]
+        @before_evaluation = options[:before_evaluation] || options[:beforeEvaluation]
         @bucket_key = options[:bucket_key]
         @bucket_value = options[:bucket_value]
         @after = options[:after]
+        @after_evaluation = options[:after_evaluation] || options[:afterEvaluation]
         @close = options[:close]
       end
 
@@ -29,6 +31,12 @@ module Featurevisor
         @before.call(options)
       end
 
+      def call_before_evaluation(options)
+        return options unless @before_evaluation
+
+        @before_evaluation.call(options)
+      end
+
       def call_bucket_key(options)
         return options[:bucket_key] unless @bucket_key
 
@@ -47,6 +55,12 @@ module Featurevisor
         @after.call(evaluation, options)
       end
 
+      def call_after_evaluation(evaluation, options)
+        return evaluation unless @after_evaluation
+
+        @after_evaluation.call(evaluation, options)
+      end
+
       def call_close
         @close.call if @close
       end
@@ -124,6 +138,43 @@ module Featurevisor
       end
 
       def run_before_modules(options)
+        result = @modules.reduce(options) do |current, mod|
+          mod.call_before(current)
+        end
+        @modules.reduce(result) do |current, mod|
+          mod.call_before_evaluation(current)
+        end
+      end
+
+      def run_before_evaluation_modules(options)
+        @modules.reduce(options) do |result, mod|
+          mod.call_before_evaluation(result)
+        end
+      end
+
+      def run_after_evaluation_modules(evaluation, options)
+        @modules.reduce(evaluation) do |result, mod|
+          mod.call_after_evaluation(result, options)
+        end
+      end
+
+      def run_after_modules(evaluation, options)
+        result = @modules.reduce(evaluation) do |current, mod|
+          mod.call_after_evaluation(current, options)
+        end
+        @modules.reduce(result) do |current, mod|
+          mod.call_after(current, options)
+        end
+      end
+
+      # Deprecated feature-only callbacks are intentionally excluded here.
+      def run_global_after_modules(evaluation, options)
+        @modules.reduce(evaluation) do |result, mod|
+          mod.call_after_evaluation(result, options)
+        end
+      end
+
+      def run_legacy_before_modules(options)
         @modules.reduce(options) do |result, mod|
           mod.call_before(result)
         end
@@ -145,12 +196,6 @@ module Featurevisor
         bucket_value
       end
 
-      def run_after_modules(evaluation, options)
-        @modules.reduce(evaluation) do |result, mod|
-          mod.call_after(result, options)
-        end
-      end
-
       def close_all
         @modules.each do |mod|
           @clear_module_diagnostic_subscriptions.call(mod) if @clear_module_diagnostic_subscriptions