launchdarkly-server-sdk 6.3.0 → 8.0.0

data/lib/ldclient-rb/events.rb

@@ -1,5 +1,8 @@
+require "ldclient-rb/impl/context_filter"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/event_sender"
+require "ldclient-rb/impl/event_summarizer"
+require "ldclient-rb/impl/event_types"
 require "ldclient-rb/impl/util"
 
 require "concurrent"
@@ -18,7 +21,7 @@ require "time"
 # On a separate worker thread, EventDispatcher consumes events from the inbox. These are considered
 # "input events" because they may or may not actually be sent to LaunchDarkly; most flag evaluation
 # events are not sent, but are counted and the counters become part of a single summary event.
-# EventDispatcher updates those counters, creates "index" events for any users that have not been seen
+# EventDispatcher updates those counters, creates "index" events for any contexts that have not been seen
 # recently, and places any events that will be sent to LaunchDarkly into the "outbox" queue.
 #
 # When it is time to flush events to LaunchDarkly, the contents of the outbox are handed off to
@@ -26,16 +29,35 @@ require "time"
 #
 
 module LaunchDarkly
-  MAX_FLUSH_WORKERS = 5
-  USER_ATTRS_TO_STRINGIFY_FOR_EVENTS = [ :key, :secondary, :ip, :country, :email, :firstName, :lastName,
-    :avatar, :name ]
+  module EventProcessorMethods
+    def record_eval_event(
+      context,
+      key,
+      version = nil,
+      variation = nil,
+      value = nil,
+      reason = nil,
+      default = nil,
+      track_events = false,
+      debug_until = nil,
+      prereq_of = nil,
+      sampling_ratio = nil,
+      exclude_from_summaries = false
+    )
+    end
 
-  private_constant :MAX_FLUSH_WORKERS
-  private_constant :USER_ATTRS_TO_STRINGIFY_FOR_EVENTS
+    def record_identify_event(context)
+    end
 
-  # @private
-  class NullEventProcessor
-    def add_event(event)
+    def record_custom_event(
+      context,
+      key,
+      data = nil,
+      metric_value = nil
+    )
+    end
+
+    def record_migration_op_event(event)
     end
 
     def flush
@@ -45,12 +67,12 @@ module LaunchDarkly
     end
   end
 
+  MAX_FLUSH_WORKERS = 5
+  private_constant :MAX_FLUSH_WORKERS
+
   # @private
-  class EventMessage
-    def initialize(event)
-      @event = event
-    end
-    attr_reader :event
+  class NullEventProcessor
+    include EventProcessorMethods
   end
 
   # @private
@@ -58,7 +80,7 @@ module LaunchDarkly
   end
 
   # @private
-  class FlushUsersMessage
+  class FlushContextsMessage
   end
 
   # @private
@@ -70,7 +92,7 @@ module LaunchDarkly
     def initialize
       @reply = Concurrent::Semaphore.new(0)
     end
-    
+
     def completed
       @reply.release
     end
@@ -90,6 +112,8 @@ module LaunchDarkly
 
   # @private
   class EventProcessor
+    include EventProcessorMethods
+
     def initialize(sdk_key, config, client = nil, diagnostic_accumulator = nil, test_properties = nil)
       raise ArgumentError, "sdk_key must not be nil" if sdk_key.nil?  # see LDClient constructor comment on sdk_key
       @logger = config.logger
@@ -98,10 +122,10 @@ module LaunchDarkly
         post_to_inbox(FlushMessage.new)
       end
       @flush_task.execute
-      @users_flush_task = Concurrent::TimerTask.new(execution_interval: config.user_keys_flush_interval) do
-        post_to_inbox(FlushUsersMessage.new)
+      @contexts_flush_task = Concurrent::TimerTask.new(execution_interval: config.context_keys_flush_interval) do
+        post_to_inbox(FlushContextsMessage.new)
       end
-      @users_flush_task.execute
+      @contexts_flush_task.execute
       if !diagnostic_accumulator.nil?
         interval = test_properties && test_properties.has_key?(:diagnostic_recording_interval) ?
           test_properties[:diagnostic_recording_interval] :
@@ -116,16 +140,42 @@ module LaunchDarkly
       @stopped = Concurrent::AtomicBoolean.new(false)
       @inbox_full = Concurrent::AtomicBoolean.new(false)
 
-      event_sender = test_properties && test_properties.has_key?(:event_sender) ?
-        test_properties[:event_sender] :
-        Impl::EventSender.new(sdk_key, config, client ? client : Util.new_http_client(config.events_uri, config))
+      event_sender = (test_properties || {})[:event_sender] ||
+        Impl::EventSender.new(sdk_key, config, client || Util.new_http_client(config.events_uri, config))
+
+      @timestamp_fn = (test_properties || {})[:timestamp_fn] || proc { Impl::Util.current_time_millis }
 
       EventDispatcher.new(@inbox, sdk_key, config, diagnostic_accumulator, event_sender)
     end
 
-    def add_event(event)
-      event[:creationDate] = Impl::Util.current_time_millis
-      post_to_inbox(EventMessage.new(event))
+    def record_eval_event(
+      context,
+      key,
+      version = nil,
+      variation = nil,
+      value = nil,
+      reason = nil,
+      default = nil,
+      track_events = false,
+      debug_until = nil,
+      prereq_of = nil,
+      sampling_ratio = nil,
+      exclude_from_summaries = false
+    )
+      post_to_inbox(LaunchDarkly::Impl::EvalEvent.new(timestamp, context, key, version, variation, value, reason,
+        default, track_events, debug_until, prereq_of, sampling_ratio, exclude_from_summaries))
+    end
+
+    def record_identify_event(context)
+      post_to_inbox(LaunchDarkly::Impl::IdentifyEvent.new(timestamp, context))
+    end
+
+    def record_custom_event(context, key, data = nil, metric_value = nil)
+      post_to_inbox(LaunchDarkly::Impl::CustomEvent.new(timestamp, context, key, data, metric_value))
+    end
+
+    def record_migration_op_event(event)
+      post_to_inbox(event)
     end
 
     def flush
@@ -137,8 +187,8 @@ module LaunchDarkly
       # final shutdown, which includes a final flush, is done synchronously
       if @stopped.make_true
         @flush_task.shutdown
-        @users_flush_task.shutdown
-        @diagnostic_event_task.shutdown if !@diagnostic_event_task.nil?
+        @contexts_flush_task.shutdown
+        @diagnostic_event_task.shutdown unless @diagnostic_event_task.nil?
         # Note that here we are not calling post_to_inbox, because we *do* want to wait if the inbox
         # is full; an orderly shutdown can't happen unless these messages are received.
         @inbox << FlushMessage.new
@@ -155,9 +205,11 @@ module LaunchDarkly
       sync_msg.wait_for_completion
     end
 
-    private
+    private def timestamp
+      @timestamp_fn.call()
+    end
 
-    def post_to_inbox(message)
+    private def post_to_inbox(message)
       begin
         @inbox.push(message, non_block=true)
       rescue ThreadError
@@ -179,14 +231,15 @@ module LaunchDarkly
       @config = config
       @diagnostic_accumulator = config.diagnostic_opt_out? ? nil : diagnostic_accumulator
       @event_sender = event_sender
+      @sampler = LaunchDarkly::Impl::Sampler.new(Random.new)
 
-      @user_keys = SimpleLRUCacheSet.new(config.user_keys_capacity)
+      @context_keys = SimpleLRUCacheSet.new(config.context_keys_capacity)
       @formatter = EventOutputFormatter.new(config)
       @disabled = Concurrent::AtomicBoolean.new(false)
       @last_known_past_time = Concurrent::AtomicReference.new(0)
-      @deduplicated_users = 0
+      @deduplicated_contexts = 0
       @events_in_last_batch = 0
-      
+
       outbox = EventBuffer.new(config.capacity, config.logger)
       flush_workers = NonBlockingThreadPool.new(MAX_FLUSH_WORKERS)
 
@@ -209,12 +262,10 @@ module LaunchDarkly
         begin
           message = inbox.pop
           case message
-          when EventMessage
-            dispatch_event(message.event, outbox)
           when FlushMessage
             trigger_flush(outbox, flush_workers)
-          when FlushUsersMessage
-            @user_keys.clear
+          when FlushContextsMessage
+            @context_keys.clear
           when DiagnosticEventMessage
             send_and_reset_diagnostics(outbox, diagnostic_event_workers)
           when TestSyncMessage
@@ -224,6 +275,8 @@ module LaunchDarkly
             do_shutdown(flush_workers, diagnostic_event_workers)
             running = false
             message.completed
+          else
+            dispatch_event(message, outbox)
           end
         rescue => e
           Util.log_exception(@config.logger, "Unexpected error in event processor", e)
@@ -234,7 +287,7 @@ module LaunchDarkly
     def do_shutdown(flush_workers, diagnostic_event_workers)
       flush_workers.shutdown
       flush_workers.wait_for_termination
-      if !diagnostic_event_workers.nil?
+      unless diagnostic_event_workers.nil?
         diagnostic_event_workers.shutdown
         diagnostic_event_workers.wait_for_termination
       end
@@ -244,58 +297,52 @@ module LaunchDarkly
     def synchronize_for_testing(flush_workers, diagnostic_event_workers)
       # Used only by unit tests. Wait until all active flush workers have finished.
       flush_workers.wait_all
-      diagnostic_event_workers.wait_all if !diagnostic_event_workers.nil?
+      diagnostic_event_workers.wait_all unless diagnostic_event_workers.nil?
     end
 
     def dispatch_event(event, outbox)
       return if @disabled.value
 
       # Always record the event in the summary.
-      outbox.add_to_summary(event)
+      outbox.add_to_summary(event) unless event.exclude_from_summaries
 
       # Decide whether to add the event to the payload. Feature events may be added twice, once for
       # the event (if tracked) and once for debugging.
       will_add_full_event = false
       debug_event = nil
-      if event[:kind] == "feature"
-        will_add_full_event = event[:trackEvents]
+      if event.is_a?(LaunchDarkly::Impl::EvalEvent)
+        will_add_full_event = event.track_events
         if should_debug_event(event)
-          debug_event = event.clone
-          debug_event[:debug] = true
+          debug_event = LaunchDarkly::Impl::DebugEvent.new(event)
         end
       else
         will_add_full_event = true
       end
 
-      # For each user we haven't seen before, we add an index event - unless this is already
-      # an identify event for that user.
-      if !(will_add_full_event && @config.inline_users_in_events)
-        if event.has_key?(:user) && !notice_user(event[:user]) && event[:kind] != "identify"
-          outbox.add_event({
-            kind: "index",
-            creationDate: event[:creationDate],
-            user: event[:user]
-          })
-        end
+      # For each context we haven't seen before, we add an index event - unless this is already
+      # an identify event for that context.
+      if !event.context.nil? && !notice_context(event.context) && !event.is_a?(LaunchDarkly::Impl::IdentifyEvent) && !event.is_a?(LaunchDarkly::Impl::MigrationOpEvent)
+        outbox.add_event(LaunchDarkly::Impl::IndexEvent.new(event.timestamp, event.context))
       end
 
-      outbox.add_event(event) if will_add_full_event
-      outbox.add_event(debug_event) if !debug_event.nil?
+      outbox.add_event(event) if will_add_full_event && @sampler.sample(event.sampling_ratio.nil? ? 1 : event.sampling_ratio)
+      outbox.add_event(debug_event) if !debug_event.nil? && @sampler.sample(event.sampling_ratio.nil? ? 1 : event.sampling_ratio)
     end
 
-    # Add 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
-        known = @user_keys.add(user[:key].to_s)
-        @deduplicated_users += 1 if known
-        known
-      end
+    #
+    # Add to the set of contexts we've noticed, and return true if the context
+    # was already known to us.
+    # @param context [LaunchDarkly::LDContext]
+    # @return [Boolean]
+    #
+    def notice_context(context)
+      known = @context_keys.add(context.fully_qualified_key)
+      @deduplicated_contexts += 1 if known
+      known
     end
 
     def should_debug_event(event)
-      debug_until = event[:debugEventsUntilDate]
+      debug_until = event.debug_until
       if !debug_until.nil?
         last_past = @last_known_past_time.value
         debug_until > last_past && debug_until > Impl::Util.current_time_millis
@@ -309,7 +356,7 @@ module LaunchDarkly
         return
       end
 
-      payload = outbox.get_payload  
+      payload = outbox.get_payload
       if !payload.events.empty? || !payload.summary.counters.empty?
         count = payload.events.length + (payload.summary.counters.empty? ? 0 : 1)
         @events_in_last_batch = count
@@ -319,7 +366,7 @@ module LaunchDarkly
             events_out = @formatter.make_output_events(payload.events, payload.summary)
             result = @event_sender.send_event_data(events_out.to_json, "#{events_out.length} events", false)
             @disabled.value = true if result.must_shutdown
-            if !result.time_from_server.nil?
+            unless result.time_from_server.nil?
               @last_known_past_time.value = (result.time_from_server.to_f * 1000).to_i
             end
           rescue => e
@@ -335,8 +382,8 @@ module LaunchDarkly
     def send_and_reset_diagnostics(outbox, diagnostic_event_workers)
       return if @diagnostic_accumulator.nil?
       dropped_count = outbox.get_and_clear_dropped_count
-      event = @diagnostic_accumulator.create_periodic_event_and_reset(dropped_count, @deduplicated_users, @events_in_last_batch)
-      @deduplicated_users = 0
+      event = @diagnostic_accumulator.create_periodic_event_and_reset(dropped_count, @deduplicated_contexts, @events_in_last_batch)
+      @deduplicated_contexts = 0
       @events_in_last_batch = 0
       send_diagnostic_event(event, diagnostic_event_workers)
     end
@@ -365,17 +412,16 @@ module LaunchDarkly
       @capacity_exceeded = false
       @dropped_events = 0
       @events = []
-      @summarizer = EventSummarizer.new
+      @summarizer = LaunchDarkly::Impl::EventSummarizer.new
     end
 
     def add_event(event)
       if @events.length < @capacity
-        @logger.debug { "[LDClient] Enqueueing event: #{event.to_json}" }
         @events.push(event)
         @capacity_exceeded = false
       else
         @dropped_events += 1
-        if !@capacity_exceeded
+        unless @capacity_exceeded
           @capacity_exceeded = true
           @logger.warn { "[LDClient] Exceeded event queue capacity. Increase capacity to avoid dropping events." }
         end
@@ -387,7 +433,7 @@ module LaunchDarkly
     end
 
     def get_payload
-      return FlushPayload.new(@events, @summarizer.snapshot)
+      FlushPayload.new(@events, @summarizer.snapshot)
     end
 
     def get_and_clear_dropped_count
@@ -404,113 +450,177 @@ module LaunchDarkly
 
   # @private
   class EventOutputFormatter
+    FEATURE_KIND = 'feature'
+    IDENTIFY_KIND = 'identify'
+    CUSTOM_KIND = 'custom'
+    INDEX_KIND = 'index'
+    DEBUG_KIND = 'debug'
+    MIGRATION_OP_KIND = 'migration_op'
+    SUMMARY_KIND = 'summary'
+
     def initialize(config)
-      @inline_users = config.inline_users_in_events
-      @user_filter = UserFilter.new(config)
+      @context_filter = LaunchDarkly::Impl::ContextFilter.new(config.all_attributes_private, config.private_attributes)
     end
 
     # Transforms events into the format used for event sending.
     def make_output_events(events, summary)
       events_out = events.map { |e| make_output_event(e) }
-      if !summary.counters.empty?
+      unless summary.counters.empty?
         events_out.push(make_summary_event(summary))
       end
       events_out
     end
 
-    private
+    private def make_output_event(event)
+      case event
 
-    def process_user(event)
-      filtered = @user_filter.transform_user_props(event[:user])
-      Util.stringify_attrs(filtered, USER_ATTRS_TO_STRINGIFY_FOR_EVENTS)
-    end
+      when LaunchDarkly::Impl::EvalEvent
+        out = {
+          kind: FEATURE_KIND,
+          creationDate: event.timestamp,
+          key: event.key,
+          value: event.value,
+        }
+        out[:default] = event.default unless event.default.nil?
+        out[:variation] = event.variation unless event.variation.nil?
+        out[:version] = event.version unless event.version.nil?
+        out[:prereqOf] = event.prereq_of unless event.prereq_of.nil?
+        out[:contextKeys] = event.context.keys
+        out[:reason] = event.reason unless event.reason.nil?
+        out
 
-    def make_output_event(event)
-      case event[:kind]
-      when "feature"
-        is_debug = event[:debug]
+      when LaunchDarkly::Impl::MigrationOpEvent
         out = {
-          kind: is_debug ? "debug" : "feature",
-          creationDate: event[:creationDate],
-          key: event[:key],
-          value: event[:value]
+          kind: MIGRATION_OP_KIND,
+          creationDate: event.timestamp,
+          contextKeys: event.context.keys,
+          operation: event.operation.to_s,
+          evaluation: {
+            key: event.key,
+            value: event.evaluation.value,
+          },
         }
-        out[:default] = event[:default] if event.has_key?(:default)
-        out[:variation] = event[:variation] if event.has_key?(:variation)
-        out[:version] = event[:version] if event.has_key?(:version)
-        out[:prereqOf] = event[:prereqOf] if event.has_key?(:prereqOf)
-        out[:contextKind] = event[:contextKind] if event.has_key?(:contextKind)
-        if @inline_users || is_debug
-          out[:user] = process_user(event)
-        else
-          out[:userKey] = event[:user][:key]
+
+        out[:evaluation][:version] = event.version unless event.version.nil?
+        out[:evaluation][:default] = event.default unless event.default.nil?
+        out[:evaluation][:variation] = event.evaluation.variation_index unless event.evaluation.variation_index.nil?
+        out[:evaluation][:reason] = event.evaluation.reason unless event.evaluation.reason.nil?
+        out[:samplingRatio] = event.sampling_ratio unless event.sampling_ratio.nil? || event.sampling_ratio == 1
+
+        measurements = []
+
+        unless event.invoked.empty?
+          measurements << {
+            "key": "invoked",
+            "values": event.invoked.map { |origin| [origin, true] }.to_h,
+          }
+        end
+
+        unless event.consistency_check.nil?
+          measurement = {
+            "key": "consistent",
+            "value": event.consistency_check,
+          }
+
+          unless event.consistency_check_ratio.nil? || event.consistency_check_ratio == 1
+            measurement[:samplingRatio] = event.consistency_check_ratio
+          end
+
+          measurements << measurement
+        end
+
+
+        unless event.latencies.empty?
+          measurements << {
+            "key": "latency_ms",
+            "values": event.latencies,
+          }
         end
-        out[:reason] = event[:reason] if !event[:reason].nil?
+
+        unless event.errors.empty?
+          measurements << {
+            "key": "error",
+            "values": event.errors.map { |origin| [origin, true] }.to_h,
+          }
+        end
+        out[:measurements] = measurements unless measurements.empty?
+
         out
-      when "identify"
+
+      when LaunchDarkly::Impl::IdentifyEvent
         {
-          kind: "identify",
-          creationDate: event[:creationDate],
-          key: event[:user][:key].to_s,
-          user: process_user(event)
+          kind: IDENTIFY_KIND,
+          creationDate: event.timestamp,
+          key: event.context.fully_qualified_key,
+          context: @context_filter.filter(event.context),
         }
-      when "custom"
+
+      when LaunchDarkly::Impl::CustomEvent
         out = {
-          kind: "custom",
-          creationDate: event[:creationDate],
-          key: event[:key]
+          kind: CUSTOM_KIND,
+          creationDate: event.timestamp,
+          key: event.key,
         }
-        out[:data] = event[:data] if event.has_key?(:data)
-        if @inline_users
-          out[:user] = process_user(event)
-        else
-          out[:userKey] = event[:user][:key]
-        end
-        out[:metricValue] = event[:metricValue] if event.has_key?(:metricValue)
-        out[:contextKind] = event[:contextKind] if event.has_key?(:contextKind)
+        out[:data] = event.data unless event.data.nil?
+        out[:contextKeys] = event.context.keys
+        out[:metricValue] = event.metric_value unless event.metric_value.nil?
         out
-      when "index"
+
+      when LaunchDarkly::Impl::IndexEvent
         {
-          kind: "index",
-          creationDate: event[:creationDate],
-          user: process_user(event)
+          kind: INDEX_KIND,
+          creationDate: event.timestamp,
+          context: @context_filter.filter(event.context),
         }
+
+      when LaunchDarkly::Impl::DebugEvent
+        original = event.eval_event
+        out = {
+          kind: DEBUG_KIND,
+          creationDate: original.timestamp,
+          key: original.key,
+          context: @context_filter.filter(original.context),
+          value: original.value,
+        }
+        out[:default] = original.default unless original.default.nil?
+        out[:variation] = original.variation unless original.variation.nil?
+        out[:version] = original.version unless original.version.nil?
+        out[:prereqOf] = original.prereq_of unless original.prereq_of.nil?
+        out[:reason] = original.reason unless original.reason.nil?
+        out
+
       else
-        event
+        nil
       end
     end
 
     # Transforms the summary data into the format used for event sending.
-    def make_summary_event(summary)
+    private def make_summary_event(summary)
       flags = {}
-      summary[: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[:variation].nil?
-          c[:variation] = ckey[:variation]
-        end
-        if ckey[:version].nil?
-          c[:unknown] = true
-        else
-          c[:version] = ckey[:version]
+      summary.counters.each do |flagKey, flagInfo|
+        counters = []
+        flagInfo.versions.each do |version, variations|
+          variations.each do |variation, counter|
+            c = {
+              value: counter.value,
+              count: counter.count,
+            }
+            c[:variation] = variation unless variation.nil?
+            if version.nil?
+              c[:unknown] = true
+            else
+              c[:version] = version
+            end
+            counters.push(c)
+          end
         end
-        flag[:counters].push(c)
-      }
+        flags[flagKey] = { default: flagInfo.default, counters: counters, contextKinds: flagInfo.context_kinds.to_a }
+      end
       {
-        kind: "summary",
+        kind: SUMMARY_KIND,
         startDate: summary[:start_date],
         endDate: summary[:end_date],
-        features: flags
+        features: flags,
       }
     end
   end