launchdarkly-server-sdk 6.3.2 → 6.4.0

data/lib/ldclient-rb/impl/evaluator.rb

@@ -1,9 +1,17 @@
 require "ldclient-rb/evaluation_detail"
 require "ldclient-rb/impl/evaluator_bucketing"
+require "ldclient-rb/impl/evaluator_helpers"
 require "ldclient-rb/impl/evaluator_operators"
 
 module LaunchDarkly
   module Impl
+    # Used internally to record that we evaluated a prerequisite flag.
+    PrerequisiteEvalRecord = Struct.new(
+      :prereq_flag,     # the prerequisite flag that we evaluated
+      :prereq_of_flag,  # the flag that it was a prerequisite of
+      :detail           # the EvaluationDetail representing the evaluation result
+    )
+
     # Encapsulates the feature flag evaluation logic. The Evaluator has no knowledge of the rest of the SDK environment;
     # if it needs to retrieve flags or segments that are referenced by a flag, it does so through a simple function that
     # is provided in the constructor. It also produces feature requests as appropriate for any referenced prerequisite
@@ -22,7 +30,7 @@ module LaunchDarkly
         @get_big_segments_membership = get_big_segments_membership
         @logger = logger
       end
-
+  
       # Used internally to hold an evaluation result and additional state that may be accumulated during an
       # evaluation. It's simpler and a bit more efficient to represent these as mutable properties rather than
       # trying to use a pure functional approach, and since we're not exposing this object to any application code
@@ -34,7 +42,7 @@ module LaunchDarkly
       # evaluation.
       EvalResult = Struct.new(
         :detail,  # the EvaluationDetail representing the evaluation result
-        :events,  # an array of evaluation events generated by prerequisites, or nil
+        :prereq_evals,  # an array of PrerequisiteEvalRecord instances, or nil
         :big_segments_status,
         :big_segments_membership
       )
@@ -50,17 +58,15 @@ module LaunchDarkly
       #
       # @param flag [Object] the flag
       # @param user [Object] the user properties
-      # @param event_factory [EventFactory] called to construct a feature request event when a prerequisite flag is
-      #   evaluated; the caller is responsible for constructing the feature event for the top-level evaluation
       # @return [EvalResult] the evaluation result 
-      def evaluate(flag, user, event_factory)
+      def evaluate(flag, user)
         result = EvalResult.new
         if user.nil? || user[:key].nil?
           result.detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED)
           return result
         end
         
-        detail = eval_internal(flag, user, result, event_factory)
+        detail = eval_internal(flag, user, result)
         if !result.big_segments_status.nil?
           # If big_segments_status is non-nil at the end of the evaluation, it means a query was done at
           # some point and we will want to include the status in the evaluation reason.
@@ -80,21 +86,19 @@ module LaunchDarkly
 
       private
       
-      def eval_internal(flag, user, state, event_factory)
+      def eval_internal(flag, user, state)
         if !flag[:on]
-          return get_off_value(flag, EvaluationReason::off)
+          return EvaluatorHelpers.off_result(flag)
         end
 
-        prereq_failure_reason = check_prerequisites(flag, user, state, event_factory)
-        if !prereq_failure_reason.nil?
-          return get_off_value(flag, prereq_failure_reason)
-        end
+        prereq_failure_result = check_prerequisites(flag, user, state)
+        return prereq_failure_result if !prereq_failure_result.nil?
 
         # Check user target matches
         (flag[:targets] || []).each do |target|
           (target[:values] || []).each do |value|
             if value == user[:key]
-              return get_variation(flag, target[:variation], EvaluationReason::target_match)
+              return EvaluatorHelpers.target_match_result(target, flag)
             end
           end
         end
@@ -106,19 +110,21 @@ module LaunchDarkly
           if rule_match_user(rule, user, state)
             reason = rule[:_reason]  # try to use cached reason for this rule
             reason = EvaluationReason::rule_match(i, rule[:id]) if reason.nil?
-            return get_value_for_variation_or_rollout(flag, rule, user, reason)
+            return get_value_for_variation_or_rollout(flag, rule, user, reason,
+              EvaluatorHelpers.rule_precomputed_results(rule))
           end
         end
 
         # Check the fallthrough rule
         if !flag[:fallthrough].nil?
-          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough)
+          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough,
+            EvaluatorHelpers.fallthrough_precomputed_results(flag))
         end
 
         return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
       end
 
-      def check_prerequisites(flag, user, state, event_factory)
+      def check_prerequisites(flag, user, state)
         (flag[:prerequisites] || []).each do |prerequisite|
           prereq_ok = true
           prereq_key = prerequisite[:key]
@@ -129,23 +135,22 @@ module LaunchDarkly
             prereq_ok = false
           else
             begin
-              prereq_res = eval_internal(prereq_flag, user, state, event_factory)
+              prereq_res = eval_internal(prereq_flag, user, state)
               # Note that if the prerequisite flag is off, we don't consider it a match no matter what its
               # off variation was. But we still need to evaluate it in order to generate an event.
               if !prereq_flag[:on] || prereq_res.variation_index != prerequisite[:variation]
                 prereq_ok = false
               end
-              event = event_factory.new_eval_event(prereq_flag, user, prereq_res, nil, flag)
-              state.events = [] if state.events.nil?
-              state.events.push(event)
+              prereq_eval = PrerequisiteEvalRecord.new(prereq_flag, flag, prereq_res)
+              state.prereq_evals = [] if state.prereq_evals.nil?
+              state.prereq_evals.push(prereq_eval)
             rescue => exn
               Util.log_exception(@logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"#{flag[:key]}\"", exn)
               prereq_ok = false
             end
           end
           if !prereq_ok
-            reason = prerequisite[:_reason]  # try to use cached reason
-            return reason.nil? ? EvaluationReason::prerequisite_failed(prereq_key) : reason
+            return EvaluatorHelpers.prerequisite_failed_result(prerequisite, flag)
           end
         end
         nil
@@ -248,35 +253,26 @@ module LaunchDarkly
       end
 
       private
-
-      def get_variation(flag, index, reason)
-        if index < 0 || index >= flag[:variations].length
-          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index")
-          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
-        end
-        EvaluationDetail.new(flag[:variations][index], index, reason)
-      end
-
-      def get_off_value(flag, reason)
-        if flag[:offVariation].nil?  # off variation unspecified - return default value
-          return EvaluationDetail.new(nil, nil, reason)
-        end
-        get_variation(flag, flag[:offVariation], reason)
-      end
-
-      def get_value_for_variation_or_rollout(flag, vr, user, reason)
+      
+      def get_value_for_variation_or_rollout(flag, vr, user, reason, precomputed_results)
         index, in_experiment = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
-        #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
-        if in_experiment && reason.kind == :FALLTHROUGH
-          reason = EvaluationReason::fallthrough(in_experiment)
-        elsif in_experiment && reason.kind == :RULE_MATCH
-          reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
-        end
         if index.nil?
           @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": variation/rollout object with no variation or rollout")
           return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
         end
-        return get_variation(flag, index, reason)
+        if precomputed_results
+          return precomputed_results.for_variation(index, in_experiment)
+        else
+          #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
+          if in_experiment
+            if reason.kind == :FALLTHROUGH
+              reason = EvaluationReason::fallthrough(in_experiment)
+            elsif reason.kind == :RULE_MATCH
+              reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
+            end
+          end
+          return EvaluatorHelpers.evaluation_detail_for_variation(flag, index, reason)
+        end
       end
     end
   end

data/lib/ldclient-rb/impl/evaluator_helpers.rb

@@ -0,0 +1,53 @@
+require "ldclient-rb/evaluation_detail"
+
+# This file contains any pieces of low-level evaluation logic that don't need to be inside the Evaluator
+# class, because they don't depend on any SDK state outside of their input parameters.
+
+module LaunchDarkly
+  module Impl
+    module EvaluatorHelpers
+      def self.off_result(flag, logger = nil)
+        pre = flag[:_preprocessed]
+        pre ? pre.off_result : evaluation_detail_for_off_variation(flag, EvaluationReason::off, logger)
+      end
+
+      def self.target_match_result(target, flag, logger = nil)
+        pre = target[:_preprocessed]
+        pre ? pre.match_result : evaluation_detail_for_variation(
+          flag, target[:variation], EvaluationReason::target_match, logger)
+      end
+
+      def self.prerequisite_failed_result(prereq, flag, logger = nil)
+        pre = prereq[:_preprocessed]
+        pre ? pre.failed_result : evaluation_detail_for_off_variation(
+          flag, EvaluationReason::prerequisite_failed(prereq[:key]), logger
+        )
+      end
+
+      def self.fallthrough_precomputed_results(flag)
+        pre = flag[:_preprocessed]
+        pre ? pre.fallthrough_factory : nil
+      end
+
+      def self.rule_precomputed_results(rule)
+        pre = rule[:_preprocessed]
+        pre ? pre.all_match_results : nil
+      end
+
+      def self.evaluation_detail_for_off_variation(flag, reason, logger = nil)
+        index = flag[:offVariation]
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason, logger)
+      end
+
+      def self.evaluation_detail_for_variation(flag, index, reason, logger = nil)
+        vars = flag[:variations] || []
+        if index < 0 || index >= vars.length
+          logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index") unless logger.nil?
+          EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        else
+          EvaluationDetail.new(vars[index], index, reason)
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/event_summarizer.rb

@@ -0,0 +1,63 @@
+require "ldclient-rb/impl/event_types"
+
+module LaunchDarkly
+  module Impl
+    EventSummary = Struct.new(:start_date, :end_date, :counters)
+
+    EventSummaryFlagInfo = Struct.new(:default, :versions)
+
+    EventSummaryFlagVariationCounter = Struct.new(:value, :count)
+
+    # Manages the state of summarizable information for the EventProcessor, including the
+    # event counters and user deduplication. Note that the methods of this class are
+    # deliberately not thread-safe; the EventProcessor is responsible for enforcing
+    # synchronization across both the summarizer and the event queue.
+    class EventSummarizer
+      class Counter
+      end
+
+      def initialize
+        clear
+      end
+
+      # Adds this event to our counters, if it is a type of event we need to count.
+      def summarize_event(event)
+        return if !event.is_a?(LaunchDarkly::Impl::EvalEvent)
+
+        counters_for_flag = @counters[event.key]
+        if counters_for_flag.nil?
+          counters_for_flag = EventSummaryFlagInfo.new(event.default, Hash.new)
+          @counters[event.key] = counters_for_flag
+        end
+        counters_for_flag_version = counters_for_flag.versions[event.version]
+        if counters_for_flag_version.nil?
+          counters_for_flag_version = Hash.new
+          counters_for_flag.versions[event.version] = counters_for_flag_version
+        end
+        variation_counter = counters_for_flag_version[event.variation]
+        if variation_counter.nil?
+          counters_for_flag_version[event.variation] = EventSummaryFlagVariationCounter.new(event.value, 1)
+        else
+          variation_counter.count = variation_counter.count + 1
+        end
+        time = event.timestamp
+        if !time.nil?
+          @start_date = time if @start_date == 0 || time < @start_date
+          @end_date = time if time > @end_date
+        end
+      end
+
+      # Returns a snapshot of the current summarized event data, and resets this state.
+      def snapshot
+        ret = EventSummary.new(@start_date, @end_date, @counters)
+        ret
+      end
+
+      def clear
+        @start_date = 0
+        @end_date = 0
+        @counters = {}
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/event_types.rb

@@ -0,0 +1,90 @@
+module LaunchDarkly
+  module Impl
+    class Event
+      def initialize(timestamp, user)
+        @timestamp = timestamp
+        @user = user
+      end
+
+      attr_reader :timestamp
+      attr_reader :kind
+      attr_reader :user
+    end
+
+    class EvalEvent < Event
+      def initialize(timestamp, user, key, version = nil, variation = nil, value = nil, reason = nil, default = nil,
+        track_events = false, debug_until = nil, prereq_of = nil)
+        super(timestamp, user)
+        @key = key
+        @version = version
+        @variation = variation
+        @value = value
+        @reason = reason
+        @default = default
+        # avoid setting rarely-used attributes if they have no value - this saves a little space per instance
+        @track_events = track_events if track_events
+        @debug_until = debug_until if debug_until
+        @prereq_of = prereq_of if prereq_of
+      end
+
+      attr_reader :key
+      attr_reader :version
+      attr_reader :variation
+      attr_reader :value
+      attr_reader :reason
+      attr_reader :default
+      attr_reader :track_events
+      attr_reader :debug_until
+      attr_reader :prereq_of
+    end
+
+    class IdentifyEvent < Event
+      def initialize(timestamp, user)
+        super(timestamp, user)
+      end
+    end
+
+    class CustomEvent < Event
+      def initialize(timestamp, user, key, data = nil, metric_value = nil)
+        super(timestamp, user)
+        @key = key
+        @data = data if !data.nil?
+        @metric_value = metric_value if !metric_value.nil?
+      end
+
+      attr_reader :key
+      attr_reader :data
+      attr_reader :metric_value
+    end
+
+    class AliasEvent < Event
+      def initialize(timestamp, key, context_kind, previous_key, previous_context_kind)
+        super(timestamp, nil)
+        @key = key
+        @context_kind = context_kind
+        @previous_key = previous_key
+        @previous_context_kind = previous_context_kind
+      end
+
+      attr_reader :key
+      attr_reader :context_kind
+      attr_reader :previous_key
+      attr_reader :previous_context_kind
+    end
+
+    class IndexEvent < Event
+      def initialize(timestamp, user)
+        super(timestamp, user)
+      end
+    end
+
+    class DebugEvent < Event
+      def initialize(eval_event)
+        super(eval_event.timestamp, eval_event.user)
+        @eval_event = eval_event
+      end
+
+      attr_reader :eval_event
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/preprocessed_data.rb

@@ -0,0 +1,177 @@
+require "ldclient-rb/impl/evaluator_helpers"
+
+module LaunchDarkly
+  module Impl
+    module DataModelPreprocessing
+      #
+      # Container for a precomputed result that includes a specific variation index and value, an
+      # evaluation reason, and optionally an alternate evaluation reason that corresponds to the
+      # "in experiment" state.
+      #
+      class EvalResultsForSingleVariation
+        def initialize(value, variation_index, regular_reason, in_experiment_reason = nil)
+          @regular_result = EvaluationDetail.new(value, variation_index, regular_reason)
+          @in_experiment_result = in_experiment_reason ?
+            EvaluationDetail.new(value, variation_index, in_experiment_reason) :
+            @regular_result
+        end
+
+        # @param in_experiment [Boolean] indicates whether we want the result to include
+        #   "inExperiment: true" in the reason or not
+        # @return [EvaluationDetail]
+        def get_result(in_experiment = false)
+          in_experiment ? @in_experiment_result : @regular_result
+        end
+      end
+
+      #
+      # Container for a set of precomputed results, one for each possible flag variation.
+      #
+      class EvalResultFactoryMultiVariations
+        def initialize(variation_factories)
+          @factories = variation_factories
+        end
+
+        # @param index [Integer] the variation index
+        # @param in_experiment [Boolean] indicates whether we want the result to include
+        #   "inExperiment: true" in the reason or not
+        def for_variation(index, in_experiment)
+          if index < 0 || index >= @factories.length
+            EvaluationDetail.new(nil, nil, EvaluationReason.error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          else
+            @factories[index].get_result(in_experiment)
+          end
+        end 
+      end
+
+      # Base class for all of the preprocessed data classes we embed in our data model. Using this class
+      # ensures that none of its properties will be included in JSON representations. It also overrides
+      # == to say that it is always equal with another instance of the same class; equality tests on
+      # this class are only ever done in test code, and we want the contents of these classes to be
+      # ignored in test code unless we are looking at specific attributes.
+      class PreprocessedDataBase
+        def as_json(*)
+          nil
+        end
+        
+        def to_json(*a)
+          "null"
+        end
+
+        def ==(other)
+          other.class == self.class
+        end
+      end
+
+      class FlagPreprocessed < PreprocessedDataBase
+        def initialize(off_result, fallthrough_factory)
+          @off_result = off_result
+          @fallthrough_factory = fallthrough_factory
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :off_result
+        # @return [EvalResultFactoryMultiVariations]
+        attr_reader :fallthrough_factory
+      end
+
+      class PrerequisitePreprocessed < PreprocessedDataBase
+        def initialize(failed_result)
+          @failed_result = failed_result
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :failed_result
+      end
+
+      class TargetPreprocessed < PreprocessedDataBase
+        def initialize(match_result)
+          @match_result = match_result
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :match_result
+      end
+
+      class FlagRulePreprocessed < PreprocessedDataBase
+        def initialize(all_match_results)
+          @all_match_results = all_match_results
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :all_match_results
+      end
+
+      class Preprocessor
+        def initialize(logger = nil)
+          @logger = logger
+        end
+
+        def preprocess_item!(kind, item)
+          if kind.eql? FEATURES
+            preprocess_flag!(item)
+          elsif kind.eql? SEGMENTS
+            preprocess_segment!(item)
+          end
+        end
+
+        def preprocess_all_items!(kind, items_map)
+          return items_map if !items_map
+          items_map.each do |key, item|
+            preprocess_item!(kind, item)
+          end
+        end
+
+        def preprocess_flag!(flag)
+          flag[:_preprocessed] = FlagPreprocessed.new(
+            EvaluatorHelpers.off_result(flag),
+            precompute_multi_variation_results(flag, EvaluationReason::fallthrough(false), EvaluationReason::fallthrough(true))
+          )
+          (flag[:prerequisites] || []).each do |prereq|
+            preprocess_prerequisite!(prereq, flag)
+          end
+          (flag[:targets] || []).each do |target|
+            preprocess_target!(target, flag)
+          end
+          rules = flag[:rules]
+          (rules || []).each_index do |index|
+            preprocess_flag_rule!(rules[index], index, flag)
+          end
+        end
+  
+        def preprocess_segment!(segment)
+          # nothing to do for segments currently
+        end
+  
+        private def preprocess_prerequisite!(prereq, flag)
+          prereq[:_preprocessed] = PrerequisitePreprocessed.new(
+            EvaluatorHelpers.prerequisite_failed_result(prereq, flag, @logger)
+          )
+        end
+  
+        private def preprocess_target!(target, flag)
+          target[:_preprocessed] = TargetPreprocessed.new(
+            EvaluatorHelpers.target_match_result(target, flag, @logger)
+          )
+        end
+  
+        private def preprocess_flag_rule!(rule, index, flag)
+          match_reason = EvaluationReason::rule_match(index, rule[:id])
+          match_reason_in_experiment = EvaluationReason::rule_match(index, rule[:id], true)
+          rule[:_preprocessed] = FlagRulePreprocessed.new(
+            precompute_multi_variation_results(flag, match_reason, match_reason_in_experiment)
+          )
+        end
+  
+        private def precompute_multi_variation_results(flag, regular_reason, in_experiment_reason)
+          factories = []
+          vars = flag[:variations] || []
+          vars.each_index do |index|
+            factories << EvalResultsForSingleVariation.new(vars[index], index, regular_reason, in_experiment_reason)
+          end
+          EvalResultFactoryMultiVariations.new(factories)
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/serialization.rb

@@ -1,13 +1,14 @@
+require "ldclient-rb/impl/model/preprocessed_data"
 
 module LaunchDarkly
   module Impl
     module Model
       # Abstraction of deserializing a feature flag or segment that was read from a data store or
       # received from LaunchDarkly.
-      def self.deserialize(kind, json)
+      def self.deserialize(kind, json, logger = nil)
         return nil if json.nil?
         item = JSON.parse(json, symbolize_names: true)
-        postprocess_item_after_deserializing!(kind, item)
+        DataModelPreprocessing::Preprocessor.new(logger).preprocess_item!(kind, item)
         item
       end
 
@@ -18,45 +19,14 @@ module LaunchDarkly
       end
 
       # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
-      def self.make_all_store_data(received_data)
+      def self.make_all_store_data(received_data, logger = nil)
+        preprocessor = DataModelPreprocessing::Preprocessor.new(logger)
         flags = received_data[:flags]
-        postprocess_items_after_deserializing!(FEATURES, flags)
+        preprocessor.preprocess_all_items!(FEATURES, flags)
         segments = received_data[:segments]
-        postprocess_items_after_deserializing!(SEGMENTS, segments)
+        preprocessor.preprocess_all_items!(SEGMENTS, segments)
         { FEATURES => flags, SEGMENTS => segments }
       end
-
-      # Called after we have deserialized a model item from JSON (because we received it from LaunchDarkly,
-      # or read it from a persistent data store). This allows us to precompute some derived attributes that
-      # will never change during the lifetime of that item.
-      def self.postprocess_item_after_deserializing!(kind, item)
-        return if !item
-        # Currently we are special-casing this for FEATURES; eventually it will be handled by delegating
-        # to the "kind" object or the item class.
-        if kind.eql? FEATURES
-          # For feature flags, we precompute all possible parameterized EvaluationReason instances.
-          prereqs = item[:prerequisites]
-          if !prereqs.nil?
-            prereqs.each do |prereq|
-              prereq[:_reason] = EvaluationReason::prerequisite_failed(prereq[:key])
-            end
-          end
-          rules = item[:rules]
-          if !rules.nil?
-            rules.each_index do |i|
-              rule = rules[i]
-              rule[:_reason] = EvaluationReason::rule_match(i, rule[:id])
-            end
-          end
-        end
-      end
-
-      def self.postprocess_items_after_deserializing!(kind, items_map)
-        return items_map if !items_map
-        items_map.each do |key, item|
-          postprocess_item_after_deserializing!(kind, item)
-        end
-      end
     end
   end
 end