featurevisor 0.2.0 → 1.0.0

data/lib/featurevisor/datafile_reader.rb

@@ -5,7 +5,7 @@ require "json"
 module Featurevisor
   # DatafileReader class for reading and processing Featurevisor datafiles
   class DatafileReader
-    attr_reader :schema_version, :revision, :segments, :features, :logger, :regex_cache
+    attr_reader :schema_version, :revision, :featurevisor_version, :segments, :features, :logger, :regex_cache
 
     # Initialize a new DatafileReader
     # @param options [Hash] Options hash containing datafile and logger
@@ -17,6 +17,7 @@ module Featurevisor
 
       @schema_version = datafile[:schemaVersion]
       @revision = datafile[:revision]
+      @featurevisor_version = datafile[:featurevisorVersion]
       @segments = (datafile[:segments] || {}).transform_keys(&:to_sym)
       @features = (datafile[:features] || {}).transform_keys(&:to_sym)
 
@@ -65,6 +66,16 @@ module Featurevisor
       @schema_version
     end
 
+    def get_datafile
+      {
+        schemaVersion: @schema_version,
+        revision: @revision,
+        featurevisorVersion: @featurevisor_version,
+        segments: @segments,
+        features: @features
+      }.compact
+    end
+
     # Get a segment by key
     # @param segment_key [String] Segment key to retrieve
     # @return [Hash, nil] Segment data or nil if not found
@@ -172,15 +183,11 @@ module Featurevisor
       end
 
       if conditions.is_a?(Hash) && conditions[:not] && conditions[:not].is_a?(Array)
-        return conditions[:not].all? do
-          all_conditions_are_matched({ and: conditions[:not] }, context) == false
-        end
+        return !all_conditions_are_matched({ and: conditions[:not] }, context)
       end
 
       if conditions.is_a?(Hash) && conditions["not"] && conditions["not"].is_a?(Array)
-        return conditions["not"].all? do
-          all_conditions_are_matched({ "and" => conditions["not"] }, context) == false
-        end
+        return !all_conditions_are_matched({ "and" => conditions["not"] }, context)
       end
 
 
@@ -237,15 +244,11 @@ module Featurevisor
         end
 
         if group_segments[:not] && group_segments[:not].is_a?(Array)
-          return group_segments[:not].all? do
-            all_segments_are_matched({ and: group_segments[:not] }, context) == false
-          end
+          return !all_segments_are_matched({ and: group_segments[:not] }, context)
         end
 
         if group_segments["not"] && group_segments["not"].is_a?(Array)
-          return group_segments["not"].all? do
-            all_segments_are_matched({ "and" => group_segments["not"] }, context) == false
-          end
+          return !all_segments_are_matched({ "and" => group_segments["not"] }, context)
         end
 
 
@@ -351,4 +354,6 @@ module Featurevisor
       segments
     end
   end
+
+  private_constant :DatafileReader
 end

data/lib/featurevisor/emitter.rb

@@ -2,7 +2,7 @@
 
 module Featurevisor
   # Event names for the emitter
-  EVENT_NAMES = %w[datafile_set context_set sticky_set].freeze
+  EVENT_NAMES = %w[datafile_set context_set sticky_set error].freeze
 
   # Event emitter class for handling event subscriptions and triggers
   class Emitter
@@ -42,7 +42,7 @@ module Featurevisor
 
       return unless listeners
 
-      listeners.each do |listener|
+      listeners.dup.each do |listener|
         begin
           listener.call(details)
         rescue => err

data/lib/featurevisor/evaluate.rb

@@ -17,7 +17,8 @@ module Featurevisor
     VARIABLE_NOT_FOUND = "variable_not_found" # variable's schema is not defined in the feature
     VARIABLE_DEFAULT = "variable_default" # default variable value used
     VARIABLE_DISABLED = "variable_disabled" # feature is disabled, and variable's disabledValue is used
-    VARIABLE_OVERRIDE = "variable_override" # variable overridden from inside a variation
+    VARIABLE_OVERRIDE_VARIATION = "variable_override_variation" # variable overridden from inside a variation
+    VARIABLE_OVERRIDE_RULE = "variable_override_rule" # variable overridden from inside a rule
 
     # Common
     NO_MATCH = "no_match" # no rules matched
@@ -35,44 +36,39 @@ module Featurevisor
   # Evaluation module for feature flag evaluation
   module Evaluate
 
-    # Evaluate with hooks
+    # Evaluate with modules
     # @param options [Hash] Evaluation options
     # @return [Hash] Evaluation result
-    def self.evaluate_with_hooks(options)
+    def self.evaluate_with_modules(options)
       begin
-        hooks_manager = options[:hooks_manager]
-        hooks = hooks_manager.get_all
+        modules_manager = options[:modules_manager]
 
-        # Run before hooks
+        # Run before modules
         result_options = options
-        hooks.each do |hook|
-          if hook.respond_to?(:call_before)
-            result_options = hook.call_before(result_options)
-          end
+        if modules_manager
+          result_options = modules_manager.run_before_modules(result_options)
         end
 
         # Evaluate
         evaluation = evaluate(result_options)
 
         # Default: variation
-        if options[:default_variation_value] &&
+        if options.key?(:default_variation_value) &&
            evaluation[:type] == "variation" &&
            evaluation[:variation_value].nil?
           evaluation[:variation_value] = options[:default_variation_value]
         end
 
         # Default: variable
-        if options[:default_variable_value] &&
+        if options.key?(:default_variable_value) &&
            evaluation[:type] == "variable" &&
            evaluation[:variable_value].nil?
           evaluation[:variable_value] = options[:default_variable_value]
         end
 
-        # Run after hooks
-        hooks.each do |hook|
-          if hook.respond_to?(:call_after)
-            evaluation = hook.call_after(evaluation, result_options)
-          end
+        # Run after modules
+        if modules_manager
+          evaluation = modules_manager.run_after_modules(evaluation, result_options)
         end
 
         evaluation
@@ -107,9 +103,7 @@ module Featurevisor
       logger = options[:logger]
       datafile_reader = options[:datafile_reader]
       sticky = options[:sticky]
-      hooks_manager = options[:hooks_manager]
-
-      hooks = hooks_manager.get_all
+      modules_manager = options[:modules_manager]
       evaluation = nil
 
       begin
@@ -132,10 +126,10 @@ module Featurevisor
             if type == "variable"
               if feature && variable_key &&
                  feature[:variablesSchema] &&
-                 (feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym])
-                variable_schema = feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym]
+                 has_key?(feature[:variablesSchema], variable_key)
+                variable_schema = fetch_with_symbol_key(feature[:variablesSchema], variable_key)
 
-                if variable_schema[:disabledValue]
+                if variable_schema.key?(:disabledValue)
                   # disabledValue: <value>
                   evaluation = {
                     type: type,
@@ -179,8 +173,8 @@ module Featurevisor
         end
 
         # Sticky
-        if sticky && (sticky[feature_key] || sticky[feature_key.to_sym])
-          sticky_feature = sticky[feature_key] || sticky[feature_key.to_sym]
+        if sticky && has_key?(sticky, feature_key)
+          sticky_feature = fetch_with_symbol_key(sticky, feature_key)
 
           # flag
           if type == "flag" && sticky_feature.key?(:enabled)
@@ -201,7 +195,7 @@ module Featurevisor
           if type == "variation"
             variation_value = sticky_feature[:variation]
 
-            if variation_value
+            unless variation_value.nil?
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -219,8 +213,8 @@ module Featurevisor
           if type == "variable" && variable_key
             variables = sticky_feature[:variables]
 
-            if variables && (variables[variable_key] || variables[variable_key.to_sym])
-              variable_value = variables[variable_key] || variables[variable_key.to_sym]
+            if variables && has_key?(variables, variable_key)
+              variable_value = fetch_with_symbol_key(variables, variable_key)
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -261,8 +255,8 @@ module Featurevisor
         variable_schema = nil
 
         if variable_key
-          if feature[:variablesSchema] && (feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym])
-            variable_schema = feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym]
+          if feature[:variablesSchema] && has_key?(feature[:variablesSchema], variable_key)
+            variable_schema = fetch_with_symbol_key(feature[:variablesSchema], variable_key)
           end
 
           # variable schema not found
@@ -343,8 +337,8 @@ module Featurevisor
           end
 
           # variable
-          if variable_key && force[:variables] && (force[:variables][variable_key] || force[:variables][variable_key.to_sym])
-            variable_value = force[:variables][variable_key] || force[:variables][variable_key.to_sym]
+          if variable_key && force[:variables] && has_key?(force[:variables], variable_key)
+            variable_value = fetch_with_symbol_key(force[:variables], variable_key)
             evaluation = {
               type: type,
               feature_key: feature_key,
@@ -385,8 +379,8 @@ module Featurevisor
 
               required_variation_value = nil
 
-              if required_variation_evaluation[:variation_value]
-                required_variation_value = required_variation_evaluation[:variation_value]
+              if has_key?(required_variation_evaluation, :variation_value)
+                required_variation_value = fetch_with_symbol_key(required_variation_evaluation, :variation_value)
               elsif required_variation_evaluation[:variation]
                 required_variation_value = required_variation_evaluation[:variation][:value]
               end
@@ -421,24 +415,24 @@ module Featurevisor
           logger: logger
         })
 
-        # Run bucket key hooks
-        bucket_key = hooks_manager.run_bucket_key_hooks({
+        # Run bucket key modules
+        bucket_key = modules_manager.run_bucket_key_modules({
           feature_key: feature_key,
           context: context,
           bucket_by: feature[:bucketBy],
           bucket_key: bucket_key
-        })
+        }) if modules_manager
 
         # bucketValue
         bucket_value = Featurevisor::Bucketer.get_bucketed_number(bucket_key)
 
-        # Run bucket value hooks
-        bucket_value = hooks_manager.run_bucket_value_hooks({
+        # Run bucket value modules
+        bucket_value = modules_manager.run_bucket_value_modules({
           feature_key: feature_key,
           bucket_key: bucket_key,
           context: context,
           bucket_value: bucket_value
-        })
+        }) if modules_manager
 
         matched_traffic = nil
         matched_allocation = nil
@@ -601,10 +595,50 @@ module Featurevisor
         # variable
         if type == "variable" && variable_key
           # override from rule
+          if matched_traffic &&
+             matched_traffic[:variableOverrides] &&
+             has_key?(matched_traffic[:variableOverrides], variable_key)
+            overrides = fetch_with_symbol_key(matched_traffic[:variableOverrides], variable_key)
+
+            override_index = overrides.find_index do |o|
+              if o[:conditions]
+                conditions = o[:conditions].is_a?(String) && o[:conditions] != "*" ? JSON.parse(o[:conditions]) : o[:conditions]
+                datafile_reader.all_conditions_are_matched(conditions, context)
+              elsif o[:segments]
+                segments = datafile_reader.parse_segments_if_stringified(o[:segments])
+                datafile_reader.all_segments_are_matched(segments, context)
+              else
+                false
+              end
+            end
+
+            unless override_index.nil?
+              override = overrides[override_index]
+
+              evaluation = {
+                type: type,
+                feature_key: feature_key,
+                reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_RULE,
+                bucket_key: bucket_key,
+                bucket_value: bucket_value,
+                rule_key: matched_traffic[:key],
+                traffic: matched_traffic,
+                variable_key: variable_key,
+                variable_schema: variable_schema,
+                variable_value: override[:value],
+                variable_override_index: override_index
+              }
+
+              logger.debug("variable override from rule", evaluation)
+
+              return evaluation
+            end
+          end
+
           if matched_traffic &&
              matched_traffic[:variables] &&
-             (matched_traffic[:variables][variable_key] || matched_traffic[:variables][variable_key.to_sym])
-            variable_value = matched_traffic[:variables][variable_key] || matched_traffic[:variables][variable_key.to_sym]
+             has_key?(matched_traffic[:variables], variable_key)
+            variable_value = fetch_with_symbol_key(matched_traffic[:variables], variable_key)
             evaluation = {
               type: type,
               feature_key: feature_key,
@@ -637,81 +671,38 @@ module Featurevisor
           if variation_value && feature[:variations].is_a?(Array)
             variation = feature[:variations].find { |v| v[:value] == variation_value }
 
-            if variation && variation[:variableOverrides] && (variation[:variableOverrides][variable_key] || variation[:variableOverrides][variable_key.to_sym])
-              overrides = variation[:variableOverrides][variable_key] || variation[:variableOverrides][variable_key.to_sym]
-
-              logger.debug("checking variableOverrides", {
-                feature_key: feature_key,
-                variable_key: variable_key,
-                overrides: overrides,
-                context: context
-              })
+            if variation && variation[:variableOverrides] && has_key?(variation[:variableOverrides], variable_key)
+              overrides = fetch_with_symbol_key(variation[:variableOverrides], variable_key)
 
-              override = overrides.find do |o|
-                logger.debug("evaluating override", {
-                  feature_key: feature_key,
-                  variable_key: variable_key,
-                  override: o,
-                  context: context
-                })
-
-                result = if o[:conditions]
-                  matched = datafile_reader.all_conditions_are_matched(
-                    o[:conditions].is_a?(String) && o[:conditions] != "*" ?
-                      JSON.parse(o[:conditions]) : o[:conditions],
-                    context
-                  )
-                  logger.debug("conditions match result", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    conditions: o[:conditions],
-                    matched: matched
-                  })
-                  matched
+              override_index = overrides.find_index do |o|
+                if o[:conditions]
+                  conditions = o[:conditions].is_a?(String) && o[:conditions] != "*" ? JSON.parse(o[:conditions]) : o[:conditions]
+                  datafile_reader.all_conditions_are_matched(conditions, context)
                 elsif o[:segments]
                   segments = datafile_reader.parse_segments_if_stringified(o[:segments])
-                  matched = datafile_reader.all_segments_are_matched(segments, context)
-                  logger.debug("segments match result", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    segments: o[:segments],
-                    parsed_segments: segments,
-                    matched: matched
-                  })
-                  matched
+                  datafile_reader.all_segments_are_matched(segments, context)
                 else
-                  logger.debug("override has no conditions or segments", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    override: o
-                  })
                   false
                 end
-
-                logger.debug("override evaluation result", {
-                  feature_key: feature_key,
-                  variable_key: variable_key,
-                  result: result
-                })
-
-                result
               end
 
-              if override
+              unless override_index.nil?
+                override = overrides[override_index]
                 evaluation = {
                   type: type,
                   feature_key: feature_key,
-                  reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE,
+                  reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_VARIATION,
                   bucket_key: bucket_key,
                   bucket_value: bucket_value,
                   rule_key: matched_traffic&.[](:key),
                   traffic: matched_traffic,
                   variable_key: variable_key,
                   variable_schema: variable_schema,
-                  variable_value: override[:value]
+                  variable_value: override[:value],
+                  variable_override_index: override_index
                 }
 
-                logger.debug("variable override", evaluation)
+                logger.debug("variable override from variation", evaluation)
 
                 return evaluation
               end
@@ -719,8 +710,8 @@ module Featurevisor
 
             if variation &&
                variation[:variables] &&
-               (variation[:variables][variable_key] || variation[:variables][variable_key.to_sym])
-              variable_value = variation[:variables][variable_key] || variation[:variables][variable_key.to_sym]
+               has_key?(variation[:variables], variable_key)
+              variable_value = fetch_with_symbol_key(variation[:variables], variable_key)
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -814,5 +805,20 @@ module Featurevisor
         evaluation
       end
     end
+
+    def self.fetch_with_symbol_key(obj, key)
+      return obj[key] if obj.is_a?(Hash) && obj.key?(key)
+
+      symbol_key = key.to_sym
+      return obj[symbol_key] if obj.is_a?(Hash) && obj.key?(symbol_key)
+
+      nil
+    end
+
+    def self.has_key?(obj, key)
+      return false unless obj.is_a?(Hash)
+
+      obj.key?(key) || obj.key?(key.to_sym)
+    end
   end
 end

data/lib/featurevisor/events.rb

@@ -24,7 +24,7 @@ module Featurevisor
     # @param previous_reader [DatafileReader] Previous datafile reader
     # @param new_reader [DatafileReader] New datafile reader
     # @return [Hash] Event parameters
-    def self.get_params_for_datafile_set_event(previous_reader, new_reader)
+    def self.get_params_for_datafile_set_event(previous_reader, new_reader, replace = false)
       previous_revision = previous_reader.get_revision
       previous_feature_keys = previous_reader.get_feature_keys
 
@@ -67,9 +67,10 @@ module Featurevisor
 
       {
         revision: new_revision,
-        previous_revision: previous_revision,
-        revision_changed: previous_revision != new_revision,
-        features: all_affected_features
+        previousRevision: previous_revision,
+        revisionChanged: previous_revision != new_revision,
+        features: all_affected_features,
+        replaced: replace
       }
     end
   end