From 554f9652f64fe52e2c809514490dd211c0699a27 Mon Sep 17 00:00:00 2001
From: Louis Chan <91093020+louis-launchdarkly@users.noreply.github.com>
Date: Wed, 26 Jun 2024 11:01:07 -0700
Subject: [PATCH] feat: adding option to omit anonymous contexts in identify
 and index events  (#287)

From investigation, LaunchDarkly thinks we don't need these events to
support any existing LaunchDarkly features. However, customers may
depend on this behavior for data export, so instead of fully remove the
identify and index events for anonymous context, we added a new option
to the SDK to control this behavior.

---------

Co-authored-by: Matthew Keeler <mkeeler@launchdarkly.com>
---
 contract-tests/client_entity.rb |   1 +
 contract-tests/service.rb       |   1 +
 lib/ldclient-rb/config.rb       |  11 +++
 lib/ldclient-rb/context.rb      |  20 +++++
 lib/ldclient-rb/events.rb       |  23 +++--
 spec/config_spec.rb             |   8 ++
 spec/events_spec.rb             | 151 ++++++++++++++++++++++++++++++--
 7 files changed, 203 insertions(+), 12 deletions(-)

diff --git a/contract-tests/client_entity.rb b/contract-tests/client_entity.rb
index faab8c9d..9c840912 100644
--- a/contract-tests/client_entity.rb
+++ b/contract-tests/client_entity.rb
@@ -35,6 +35,7 @@ def initialize(log, config)
       opts[:all_attributes_private] = !!events[:allAttributesPrivate]
       opts[:private_attributes] = events[:globalPrivateAttributes]
       opts[:flush_interval] = (events[:flushIntervalMs] / 1_000) unless events[:flushIntervalMs].nil?
+      opts[:omit_anonymous_contexts] = !!events[:omitAnonymousContexts]
     else
       opts[:send_events] = false
     end
diff --git a/contract-tests/service.rb b/contract-tests/service.rb
index 5f252970..954715ee 100644
--- a/contract-tests/service.rb
+++ b/contract-tests/service.rb
@@ -40,6 +40,7 @@
       'inline-context',
       'anonymous-redaction',
       'evaluation-hooks',
+      'omit-anonymous-contexts',
     ],
   }.to_json
 end
diff --git a/lib/ldclient-rb/config.rb b/lib/ldclient-rb/config.rb
index 09347e20..9de83df0 100644
--- a/lib/ldclient-rb/config.rb
+++ b/lib/ldclient-rb/config.rb
@@ -43,6 +43,7 @@ class Config
     # @option opts [BigSegmentsConfig] :big_segments See {#big_segments}.
     # @option opts [Hash] :application See {#application}
     # @option opts [String] :payload_filter_key See {#payload_filter_key}
+    # @option opts [Boolean] :omit_anonymous_contexts See {#omit_anonymous_contexts}
     # @option hooks [Array<Interfaces::Hooks::Hook]
     #
     def initialize(opts = {})
@@ -77,6 +78,7 @@ def initialize(opts = {})
       @application = LaunchDarkly::Impl::Util.validate_application_info(opts[:application] || {}, @logger)
       @payload_filter_key = opts[:payload_filter_key]
       @hooks = (opts[:hooks] || []).keep_if { |hook| hook.is_a? Interfaces::Hooks::Hook }
+      @omit_anonymous_contexts = opts.has_key?(:omit_anonymous_contexts) && opts[:omit_anonymous_contexts]
       @data_source_update_sink = nil
     end
 
@@ -385,6 +387,15 @@ def diagnostic_opt_out?
     #
     attr_reader :hooks
 
+    #
+    # Sets whether anonymous contexts should be omitted from index and identify events.
+    #
+    # The default value is false. Anonymous contexts will be included in index and identify events.
+    # @return [Boolean]
+    #
+    attr_reader :omit_anonymous_contexts
+
+
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.
diff --git a/lib/ldclient-rb/context.rb b/lib/ldclient-rb/context.rb
index 1f92ea9a..c9dd4618 100644
--- a/lib/ldclient-rb/context.rb
+++ b/lib/ldclient-rb/context.rb
@@ -101,6 +101,26 @@ def valid?
       @error.nil?
     end
 
+    #
+    # For a multi-kind context:
+    #
+    # A multi-kind context is made up of two or more single-kind contexts. This method will first discard any
+    # single-kind contexts which are anonymous. It will then create a new multi-kind context from the remaining
+    # single-kind contexts. This may result in an invalid context (e.g. all single-kind contexts are anonymous).
+    #
+    # For a single-kind context:
+    #
+    # If the context is not anonymous, this method will return the current context as is and unmodified.
+    #
+    # If the context is anonymous, this method will return an invalid context.
+    #
+    def without_anonymous_contexts
+      contexts = multi_kind? ? @contexts : [self]
+      contexts = contexts.reject { |c| c.anonymous }
+
+      LDContext.create_multi(contexts)
+    end
+
     #
     # Returns a hash mapping each context's kind to its key.
     #
diff --git a/lib/ldclient-rb/events.rb b/lib/ldclient-rb/events.rb
index 4800163b..370ad28e 100644
--- a/lib/ldclient-rb/events.rb
+++ b/lib/ldclient-rb/events.rb
@@ -144,6 +144,7 @@ def initialize(sdk_key, config, client = nil, diagnostic_accumulator = nil, test
         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 }
+      @omit_anonymous_contexts = config.omit_anonymous_contexts
 
       EventDispatcher.new(@inbox, sdk_key, config, diagnostic_accumulator, event_sender)
     end
@@ -167,7 +168,8 @@ def record_eval_event(
     end
 
     def record_identify_event(context)
-      post_to_inbox(LaunchDarkly::Impl::IdentifyEvent.new(timestamp, context))
+      target_context = !@omit_anonymous_contexts ? context : context.without_anonymous_contexts
+      post_to_inbox(LaunchDarkly::Impl::IdentifyEvent.new(timestamp, target_context)) if target_context.valid?
     end
 
     def record_custom_event(context, key, data = nil, metric_value = nil)
@@ -319,16 +321,27 @@ def dispatch_event(event, outbox)
         will_add_full_event = true
       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))
+      get_indexable_context(event) do |ctx|
+        outbox.add_event(LaunchDarkly::Impl::IndexEvent.new(event.timestamp, ctx))
       end
 
       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
 
+    private def get_indexable_context(event, &block)
+      return if event.context.nil?
+
+      context = !@config.omit_anonymous_contexts ? event.context : event.context.without_anonymous_contexts
+      return unless context.valid?
+
+      return if notice_context(context)
+      return if event.is_a?(LaunchDarkly::Impl::IdentifyEvent)
+      return if event.is_a?(LaunchDarkly::Impl::MigrationOpEvent)
+
+      yield context unless block.nil?
+    end
+
     #
     # Add to the set of contexts we've noticed, and return true if the context
     # was already known to us.
diff --git a/spec/config_spec.rb b/spec/config_spec.rb
index fcbd7df3..63af36ee 100644
--- a/spec/config_spec.rb
+++ b/spec/config_spec.rb
@@ -99,5 +99,13 @@ module LaunchDarkly
         end
       end
     end
+    describe ".omit_anonymous_contexts" do
+      it "defaults to false" do
+        expect(subject.new.omit_anonymous_contexts).to eq false
+      end
+      it "can be set to true" do
+        expect(subject.new(omit_anonymous_contexts: true).omit_anonymous_contexts).to eq true
+      end
+    end
   end
 end
diff --git a/spec/events_spec.rb b/spec/events_spec.rb
index f10100fd..dd10f07c 100644
--- a/spec/events_spec.rb
+++ b/spec/events_spec.rb
@@ -12,14 +12,151 @@ module LaunchDarkly
     let(:starting_timestamp) { 1000 }
     let(:default_config_opts) { { diagnostic_opt_out: true, logger: $null_log } }
     let(:default_config) { Config.new(default_config_opts) }
+    let(:omit_anonymous_contexts_config) { Config.new(default_config_opts.merge(omit_anonymous_contexts: true))}
     let(:context) { LDContext.create({ kind: "user", key: "userkey", name: "Red" }) }
+    let(:anon_context) { LDContext.create({ kind: "org", key: "orgkey", name: "Organization", anonymous: true }) }
 
-    it "queues identify event" do
-      with_processor_and_sender(default_config, starting_timestamp) do |ep, sender|
-        ep.record_identify_event(context)
+    describe "identify events" do
+      it "can be queued" do
+        with_processor_and_sender(default_config, starting_timestamp) do |ep, sender|
+          ep.record_identify_event(context)
 
-        output = flush_and_get_events(ep, sender)
-        expect(output).to contain_exactly(eq(identify_event(default_config, context)))
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(eq(identify_event(default_config, context)))
+        end
+      end
+
+      it "does queue if anonymous" do
+        with_processor_and_sender(default_config, starting_timestamp) do |ep, sender|
+          ep.record_identify_event(anon_context)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(eq(identify_event(default_config, anon_context)))
+        end
+      end
+
+      it "does not queue if anonymous and omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          ep.record_identify_event(anon_context)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to be_nil
+        end
+      end
+
+      it "strips anonymous contexts from multi kind contexts if omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          user = LDContext.create({ kind: "user", key: "userkey", name: "Example User", anonymous: true })
+          org = LDContext.create({ kind: "org", key: "orgkey", name: "Big Organization" })
+          device = LDContext.create({ kind: "device", key: "devicekey", name: "IoT Device", anonymous: true })
+
+          ep.record_identify_event(LDContext.create_multi([user, org, device]))
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(eq(identify_event(omit_anonymous_contexts_config, org)))
+        end
+      end
+
+      it "does not queue if all are anonymous and omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          user = LDContext.create({ kind: "user", key: "userkey", name: "Example User", anonymous: true })
+          org = LDContext.create({ kind: "org", key: "orgkey", name: "Big Organization", anonymous: true })
+          device = LDContext.create({ kind: "device", key: "devicekey", name: "IoT Device", anonymous: true })
+
+          ep.record_identify_event(LDContext.create_multi([user, org, device]))
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to be_nil
+        end
+      end
+    end
+
+    describe "index events" do
+      it "does not ignore single-kind anonymous context" do
+        with_processor_and_sender(default_config, starting_timestamp) do |ep, sender|
+          flag = { key: "flagkey", version: 11 }
+          ep.record_eval_event(anon_context, 'flagkey', 11, 1, 'value', nil, nil, true)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(
+            eq(index_event(default_config, anon_context)),
+            eq(feature_event(default_config, flag, anon_context, 1, 'value')),
+            include(:kind => "summary")
+          )
+
+          summary = output.detect { |e| e[:kind] == "summary" }
+          expect(summary[:features][:flagkey][:contextKinds]).to contain_exactly("org")
+        end
+      end
+
+      it "ignore single-kind anonymous context if omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          flag = { key: "flagkey", version: 11 }
+          ep.record_eval_event(anon_context, 'flagkey', 11, 1, 'value', nil, nil, true)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(
+            eq(feature_event(omit_anonymous_contexts_config, flag, anon_context, 1, 'value')),
+            include(:kind => "summary")
+          )
+
+          summary = output.detect { |e| e[:kind] == "summary" }
+          expect(summary[:features][:flagkey][:contextKinds]).to contain_exactly("org")
+        end
+      end
+
+      it "ignore anonymous contexts from multi-kind if omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          flag = { key: "flagkey", version: 11 }
+          multi = LDContext.create_multi([context, anon_context])
+          ep.record_eval_event(multi, 'flagkey', 11, 1, 'value', nil, nil, true)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(
+            eq(index_event(omit_anonymous_contexts_config, context)),
+            eq(feature_event(omit_anonymous_contexts_config, flag, multi, 1, 'value')),
+            include(:kind => "summary")
+          )
+
+          summary = output.detect { |e| e[:kind] == "summary" }
+          expect(summary[:features][:flagkey][:contextKinds]).to contain_exactly("user", "org")
+        end
+      end
+
+      it "handles mult-kind context being completely anonymous if omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          flag = { key: "flagkey", version: 11 }
+          anon_user = LDContext.create({ kind: "user", key: "userkey", name: "User name", anonymous: true })
+          multi = LDContext.create_multi([anon_user, anon_context])
+          ep.record_eval_event(multi, 'flagkey', 11, 1, 'value', nil, nil, true)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(
+            eq(feature_event(omit_anonymous_contexts_config, flag, multi, 1, 'value')),
+            include(:kind => "summary")
+          )
+
+          summary = output.detect { |e| e[:kind] == "summary" }
+          expect(summary[:features][:flagkey][:contextKinds]).to contain_exactly("user", "org")
+        end
+      end
+
+      it "anonymous context does not prevent subsequent index events if omit_anonymous_contexts" do
+        with_processor_and_sender(omit_anonymous_contexts_config, starting_timestamp) do |ep, sender|
+          flag = { key: "flagkey", version: 11 }
+          ep.record_eval_event(anon_context, 'flagkey', 11, 1, 'value', nil, nil, false)
+          non_anon_context = LDContext.create({ kind: "org", key: "orgkey", name: "Organization", anonymous: false })
+          ep.record_eval_event(non_anon_context, 'flagkey', 11, 1, 'value', nil, nil, false)
+
+          output = flush_and_get_events(ep, sender)
+          expect(output).to contain_exactly(
+            eq(index_event(omit_anonymous_contexts_config, non_anon_context, starting_timestamp + 1)),
+            include(:kind => "summary")
+          )
+
+          summary = output.detect { |e| e[:kind] == "summary" }
+          expect(summary[:features][:flagkey][:contextKinds]).to contain_exactly("org")
+        end
       end
     end
 
@@ -274,7 +411,7 @@ module LaunchDarkly
 
     it "treats nil value for custom the same as an empty hash" do
       with_processor_and_sender(default_config, starting_timestamp) do |ep, sender|
-        user_with_nil_custom = LDContext.create({ key: "userkey", custom: nil })
+        user_with_nil_custom = LDContext.create({ key: "userkey", kind: "user", custom: nil })
         ep.record_identify_event(user_with_nil_custom)
 
         output = flush_and_get_events(ep, sender)
@@ -721,7 +858,7 @@ def custom_event(context, key, data, metric_value)
     def flush_and_get_events(ep, sender)
       ep.flush
       ep.wait_until_inactive
-      sender.analytics_payloads.pop
+      sender.analytics_payloads.pop unless sender.analytics_payloads.empty?
     end
   end
 end