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