Merge pull request #42 from launchdarkly/eb/ch12904/summary-events

implement summary events

Author: eli-darkly

lib/ldclient-rb.rb

@@ -8,7 +8,9 @@
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
 require "ldclient-rb/polling"
-require "ldclient-rb/event_serializer"
+require "ldclient-rb/user_filter"
+require "ldclient-rb/simple_lru_cache"
+require "ldclient-rb/event_summarizer"
 require "ldclient-rb/events"
 require "ldclient-rb/redis_store"
 require "ldclient-rb/requestor"

lib/ldclient-rb/config.rb

@@ -54,7 +54,15 @@ class Config
     # @option opts [Boolean] :send_events (true) Whether or not to send events back to LaunchDarkly.
     #   This differs from `offline` in that it affects only the sending of client-side events, not
     #   streaming or polling for events from the server.
-    #
+    # @option opts [Integer] :user_keys_capacity (1000) The number of user keys that the event processor
+    #   can remember at any one time, so that duplicate user details will not be sent in analytics events.
+    # @option opts [Float] :user_keys_flush_interval (300) The interval in seconds at which the event
+    #   processor will reset its set of known user keys.
+    # @option opts [Boolean] :inline_users_in_events (false) Whether to include full user details in every
+    #   analytics event. By default, events will only include the user key, except for one "index" event
+    #   that provides the full details for the user.
+    # @option opts [Object] :update_processor An object that will receive feature flag data from LaunchDarkly.
+    #   Defaults to either the streaming or the polling processor, can be customized for tests.
     # @return [type] [description]
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
     def initialize(opts = {})
@@ -76,6 +84,10 @@ def initialize(opts = {})
       @all_attributes_private = opts[:all_attributes_private] || false
       @private_attribute_names = opts[:private_attribute_names] || []
       @send_events = opts.has_key?(:send_events) ? opts[:send_events] : Config.default_send_events
+      @user_keys_capacity = opts[:user_keys_capacity] || Config.default_user_keys_capacity
+      @user_keys_flush_interval = opts[:user_keys_flush_interval] || Config.default_user_keys_flush_interval
+      @inline_users_in_events = opts[:inline_users_in_events] || false
+      @update_processor = opts[:update_processor]
     end
 
     #
@@ -186,6 +198,26 @@ def offline?
     #
     attr_reader :send_events
 
+    #
+    # The number of user keys that the event processor can remember at any one time, so that
+    # duplicate user details will not be sent in analytics events.
+    #
+    attr_reader :user_keys_capacity
+
+    #
+    # The interval in seconds at which the event processor will reset its set of known user keys.
+    #
+    attr_reader :user_keys_flush_interval
+
+    #
+    # Whether to include full user details in every
+    # analytics event. By default, events will only include the user key, except for one "index" event
+    # that provides the full details for the user.
+    #
+    attr_reader :inline_users_in_events
+
+    attr_reader :update_processor
+    
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.
@@ -264,5 +296,13 @@ def self.default_poll_interval
     def self.default_send_events
       true
     end
+
+    def self.default_user_keys_capacity
+      1000
+    end
+
+    def self.default_user_keys_flush_interval
+      300
+    end
   end
 end

lib/ldclient-rb/evaluation.rb

@@ -127,16 +127,19 @@ def evaluate(flag, user, store)
 
       if flag[:on]
         res = eval_internal(flag, user, store, events)
-
-        return { value: res, events: events } if !res.nil?
+        if !res.nil?
+          res[:events] = events
+          return res
+        end
       end
 
-      if !flag[:offVariation].nil? && flag[:offVariation] < flag[:variations].length
-        value = flag[:variations][flag[:offVariation]]
-        return { value: value, events: events }
+      offVariation = flag[:offVariation]
+      if !offVariation.nil? && offVariation < flag[:variations].length
+        value = flag[:variations][offVariation]
+        return { variation: offVariation, value: value, events: events }
       end
 
-      { value: nil, events: events }
+      { variation: nil, value: nil, events: events }
     end
 
     def eval_internal(flag, user, store, events)
@@ -150,9 +153,13 @@ def eval_internal(flag, user, store, events)
         else
           begin
             prereq_res = eval_internal(prereq_flag, user, store, events)
-            variation = get_variation(prereq_flag, prerequisite[:variation])
-            events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
-            if prereq_res.nil? || prereq_res != variation
+            event = {
+              kind: "feature", key: prereq_flag[:key], variation: prereq_res[:variation],
+              value: prereq_res[:value], version: prereq_flag[:version], prereqOf: flag[:key],
+              trackEvents: prereq_flag[:trackEvents], debugEventsUntilDate: prereq_flag[:debugEventsUntilDate]
+            }
+            events.push(event)
+            if prereq_res.nil? || prereq_res[:variation] != prerequisite[:variation]
               failed_prereq = true
             end
           rescue => exn
@@ -175,7 +182,9 @@ def eval_rules(flag, user, store)
       # Check user target matches
       (flag[:targets] || []).each do |target|
         (target[:values] || []).each do |value|
-          return get_variation(flag, target[:variation]) if value == user[:key]
+          if value == user[:key]
+            return { variation: target[:variation], value: get_variation(flag, target[:variation]) }
+          end
         end
       end
 
@@ -245,15 +254,17 @@ def clause_match_user_no_segments(clause, user)
 
     def variation_for_user(rule, user, flag)
       if !rule[:variation].nil? # fixed variation
-        return get_variation(flag, rule[:variation])
+        return { variation: rule[:variation], value: get_variation(flag, rule[:variation]) }
       elsif !rule[:rollout].nil? # percentage rollout
         rollout = rule[:rollout]
         bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
         bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt])
         sum = 0;
         rollout[:variations].each do |variate|
           sum += variate[:weight].to_f / 100000.0
-          return get_variation(flag, variate[:variation]) if bucket < sum
+          if bucket < sum
+            return { variation: variate[:variation], value: get_variation(flag, variate[:variation]) }
+          end
         end
         nil
       else # the rule isn't well-formed

lib/ldclient-rb/event_summarizer.rb

@@ -0,0 +1,105 @@
+
+module LaunchDarkly
+  EventSummarySnapshot = Struct.new(:start_date, :end_date, :counters)
+
+  # 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
+    def initialize(config)
+      @config = config
+      @users = SimpleLRUCacheSet.new(@config.user_keys_capacity)
+      reset_state
+    end
+
+    # Adds to the set of users we've noticed, and return true if the user was already known to us.
+    def notice_user(user)
+      if user.nil? || !user.has_key?(:key)
+        true
+      else
+        @users.add(user[:key])
+      end
+    end
+
+    # Resets the set of users we've seen.
+    def reset_users
+      @users.reset
+    end
+
+    # Adds this event to our counters, if it is a type of event we need to count.
+    def summarize_event(event)
+      if event[:kind] == "feature"
+        counter_key = {
+          key: event[:key],
+          version: event[:version],
+          variation: event[:variation]
+        }
+        c = @counters[counter_key]
+        if c.nil?
+          @counters[counter_key] = {
+            value: event[:value],
+            default: event[:default],
+            count: 1
+          }
+        else
+          c[:count] = c[:count] + 1
+        end
+        time = event[:creationDate]
+        if !time.nil?
+          @start_date = time if @start_date == 0 || time < @start_date
+          @end_date = time if time > @end_date
+        end
+      end
+    end
+
+    # Returns a snapshot of the current summarized event data, and resets this state.
+    def snapshot
+      ret = {
+        start_date: @start_date,
+        end_date: @end_date,
+        counters: @counters
+      }
+      reset_state
+      ret
+    end
+
+    # Transforms the summary data into the format used for event sending.
+    def output(snapshot)
+      flags = {}
+      snapshot[:counters].each { |ckey, cval|
+        flag = flags[ckey[:key]]
+        if flag.nil?
+          flag = {
+            default: cval[:default],
+            counters: []
+          }
+          flags[ckey[:key]] = flag
+        end
+        c = {
+          value: cval[:value],
+          count: cval[:count]
+        }
+        if ckey[:version].nil?
+          c[:unknown] = true
+        else
+          c[:version] = ckey[:version]
+        end
+        flag[:counters].push(c)
+      }
+      {
+        startDate: snapshot[:start_date],
+        endDate: snapshot[:end_date],
+        features: flags
+      }
+    end
+
+    private
+
+    def reset_state
+      @start_date = 0
+      @end_date = 0
+      @counters = {}
+    end
+  end
+end