diff --git a/example/src/main/java/com/launchdarkly/example/MainActivity.java b/example/src/main/java/com/launchdarkly/example/MainActivity.java
index 9b604324..35d44d16 100644
--- a/example/src/main/java/com/launchdarkly/example/MainActivity.java
+++ b/example/src/main/java/com/launchdarkly/example/MainActivity.java
@@ -26,10 +26,6 @@
 
 import java.util.Date;
 import java.util.Locale;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import timber.log.Timber;
@@ -45,6 +41,9 @@ public class MainActivity extends AppCompatActivity {
 
     private static final String DEFAULT_USER_KEY = "user key";
 
+    /** How long startup blocks waiting for the first flags to arrive. */
+    private static final int INIT_WAIT_SECONDS = 10;
+
     private LDClient ldClient;
     private LDStatusListener ldStatusListener;
     private LDAllFlagsListener allFlagsListener;
@@ -102,6 +101,7 @@ public void onCreate(Bundle savedInstanceState) {
         setupFlushButton();
         setupTrackButton();
         setupIdentifyButton();
+        setupKillUnsentButton();
         setupOfflineSwitch();
         setupListeners();
         updateDedupeStatus();
@@ -142,15 +142,12 @@ public void onCreate(Bundle savedInstanceState) {
                 .set("email", "fake@example.com")
                 .build();
 
-        Future<LDClient> initFuture = LDClient.init(this.getApplication(), ldConfig, context);
-        try {
-            ldClient = initFuture.get(10, TimeUnit.SECONDS);
-            updateStatusString(ldClient.getConnectionInformation());
-            ldClient.registerStatusListener(ldStatusListener);
-            ldClient.registerAllFlagsListener(allFlagsListener);
-        } catch (InterruptedException | ExecutionException | TimeoutException e) {
-            Timber.e(e, "Exception when awaiting LaunchDarkly Client initialization");
-        }
+        // Returns the client either way: if the flags have not arrived within the wait, it is usable
+        // with whatever it has cached.
+        ldClient = LDClient.init(this.getApplication(), ldConfig, context, INIT_WAIT_SECONDS);
+        updateStatusString(ldClient.getConnectionInformation());
+        ldClient.registerStatusListener(ldStatusListener);
+        ldClient.registerAllFlagsListener(allFlagsListener);
     }
 
     private void setupListeners() {
@@ -215,6 +212,29 @@ private void setupTrackButton() {
         });
     }
 
+    /**
+     * Reproduces in-memory event loss: evaluate (exposure) and track (stand-in for an error),
+     * wait 5s so both calls are queued, then kill the process before the 30s flush.
+     * {@code finish()} or backgrounding would run the SDK's background flush, so this uses
+     * {@link android.os.Process#killProcess}.
+     */
+    private void setupKillUnsentButton() {
+        Button killUnsentButton = findViewById(R.id.kill_unsent_button);
+        killUnsentButton.setOnClickListener(v -> {
+            final String typedKey = ((EditText) findViewById(R.id.feature_flag_key)).getText().toString().trim();
+            final String flagKey = typedKey.isEmpty() ? "kill-flag" : typedKey;
+            Timber.w("eval+track+kill flag=%s", flagKey);
+            doSafeClientAction(() -> {
+                ldClient.boolVariation(flagKey, false);
+                ldClient.track("$ld:telemetry:error");
+                ldClient.flush();
+                new Handler(Looper.getMainLooper()).postDelayed(
+                        () -> android.os.Process.killProcess(android.os.Process.myPid()),
+                        5_000);
+            });
+        });
+    }
+
     private void setupIdentifyButton() {
         Button identify = findViewById(R.id.identify_button);
         identify.setOnClickListener(v -> {
diff --git a/example/src/main/res/layout/activity_main.xml b/example/src/main/res/layout/activity_main.xml
index 8657d607..06c5edb9 100644
--- a/example/src/main/res/layout/activity_main.xml
+++ b/example/src/main/res/layout/activity_main.xml
@@ -114,6 +114,17 @@
         android:layout_alignParentRight="true"
         android:minLines="4" />
 
+    <Button
+        android:id="@+id/kill_unsent_button"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_above="@id/identify_button"
+        android:layout_alignParentStart="true"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentEnd="true"
+        android:layout_alignParentRight="true"
+        android:text="Eval+track+kill" />
+
     <Space
         android:id="@+id/space"
         android:layout_width="0dp"
@@ -128,7 +139,7 @@
         android:id="@+id/userKey_editText"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_above="@+id/identify_button"
+        android:layout_above="@+id/kill_unsent_button"
         android:layout_alignEnd="@+id/result_textView"
         android:layout_alignRight="@+id/result_textView"
         android:layout_toEndOf="@+id/textView2"
diff --git a/launchdarkly-android-client-sdk/build.gradle b/launchdarkly-android-client-sdk/build.gradle
index 3b7566cb..daa235fb 100644
--- a/launchdarkly-android-client-sdk/build.gradle
+++ b/launchdarkly-android-client-sdk/build.gradle
@@ -79,7 +79,7 @@ ext.versions = [
     "jacksonDatabind": "2.10.5.1",
     "junit": "4.13",
     "launchdarklyJavaSdkCommon": "2.4.0",
-    "launchdarklyJavaSdkInternal": "1.9.0",
+    "launchdarklyJavaSdkInternal": "1.12.0",
     "launchdarklyLogging": "1.1.1",
     "okhttp": "4.12.0",
     "testHelpers": "2.1.0",
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java
index 8c9cc045..8dfdcbbe 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java
@@ -20,12 +20,9 @@
 import com.launchdarkly.sdk.android.subsystems.HookConfiguration;
 import com.launchdarkly.sdk.android.subsystems.HttpConfiguration;
 import com.launchdarkly.sdk.android.subsystems.PluginsConfiguration;
-import com.launchdarkly.sdk.internal.events.DefaultEventProcessor;
 import com.launchdarkly.sdk.internal.events.DefaultEventSender;
-import com.launchdarkly.sdk.internal.events.Event;
-import com.launchdarkly.sdk.internal.events.EventsConfiguration;
+import com.launchdarkly.sdk.internal.events.EventSender;
 
-import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -101,33 +98,30 @@ static final class EventProcessorBuilderImpl extends EventProcessorBuilder
         @Override
         public EventProcessor build(ClientContext clientContext) {
             ClientContextImpl clientContextImpl = ClientContextImpl.get(clientContext);
-            EventsConfiguration eventsConfig = new EventsConfiguration(
-                    allAttributesPrivate,
-                    capacity,
-                    null, // contextDeduplicator - not needed for client-side use
-                    diagnosticRecordingIntervalMillis,
-                    clientContextImpl.getDiagnosticStore(),
-                    new DefaultEventSender(
-                            LDUtil.makeHttpProperties(clientContext),
-                            StandardEndpoints.ANALYTICS_EVENTS_REQUEST_PATH,
-                            StandardEndpoints.DIAGNOSTIC_EVENTS_REQUEST_PATH,
-                            0L, // use default retry delay
-                            false, // disable gzip compression for Android
+            EventSender eventSender = new DefaultEventSender(
+                    LDUtil.makeHttpProperties(clientContext),
+                    StandardEndpoints.ANALYTICS_EVENTS_REQUEST_PATH,
+                    StandardEndpoints.DIAGNOSTIC_EVENTS_REQUEST_PATH,
+                    0L, // use default retry delay
+                    false, // disable gzip compression for Android
+                    clientContext.getBaseLogger());
+            return new DirectEventProcessor(
+                    new OutboundEventBuffer(
+                            capacity,
+                            allAttributesPrivate,
+                            privateAttributes,
+                            true, // perContextSummarization - enable for client SDK
                             clientContext.getBaseLogger()),
-                    1, // eventSendingThreadPoolSize
+                    eventSender,
                     clientContext.getServiceEndpoints().getEventsBaseUri(),
+                    clientContextImpl.getDiagnosticStore(),
                     flushIntervalMillis,
+                    diagnosticRecordingIntervalMillis,
                     clientContext.isInBackground(),
                     true, // initiallyOffline
-                    privateAttributes,
-                    true // perContextSummarization - enable for client SDK
-            );
-            return new DefaultEventProcessorWrapper(new DefaultEventProcessor(
-                    eventsConfig,
                     EventUtil.makeEventsTaskExecutor(),
-                    Thread.NORM_PRIORITY, // note, we may want to make this configurable as it is in java-server-sdk
                     clientContext.getBaseLogger()
-            ));
+            );
         }
 
         @Override
@@ -140,72 +134,6 @@ public LDValue describeConfiguration(ClientContext clientContext) {
                     .put("eventsFlushIntervalMillis", flushIntervalMillis)
                     .build();
         }
-
-        /**
-         * Adapter from the public component interface of EventProcessor to the internal
-         * implementation class from java-sdk-internal.
-         */
-        private final class DefaultEventProcessorWrapper implements EventProcessor {
-            private final DefaultEventProcessor eventProcessor;
-
-            DefaultEventProcessorWrapper(DefaultEventProcessor eventProcessor) {
-                this.eventProcessor = eventProcessor;
-            }
-
-            @Override
-            public void recordEvaluationEvent(
-                    LDContext context,
-                    String flagKey,
-                    int flagVersion,
-                    int variation,
-                    LDValue value,
-                    EvaluationReason reason,
-                    LDValue defaultValue,
-                    boolean requireFullEvent,
-                    Long debugEventsUntilDate
-            ) {
-                eventProcessor.sendEvent(new Event.FeatureRequest(
-                        System.currentTimeMillis(), flagKey, context, flagVersion, variation,
-                        value, defaultValue, reason, null, requireFullEvent,
-                        debugEventsUntilDate, false));
-            }
-
-            @Override
-            public void recordIdentifyEvent(LDContext context) {
-                eventProcessor.sendEvent(new Event.Identify(System.currentTimeMillis(), context));
-            }
-
-            @Override
-            public void recordCustomEvent(LDContext context, String eventKey, LDValue data, Double metricValue) {
-                eventProcessor.sendEvent(new Event.Custom(System.currentTimeMillis(), eventKey,
-                        context, data, metricValue));
-            }
-
-            @Override
-            public void setInBackground(boolean inBackground) {
-                eventProcessor.setInBackground(inBackground);
-            }
-
-            @Override
-            public void setOffline(boolean offline) {
-                eventProcessor.setOffline(offline);
-            }
-
-            @Override
-            public void flush() {
-                eventProcessor.flushAsync();
-            }
-
-            @Override
-            public void blockingFlush() {
-                eventProcessor.flushBlocking();
-            }
-
-            @Override
-            public void close() throws IOException {
-                eventProcessor.close();
-            }
-        }
     }
 
     static final class HttpConfigurationBuilderImpl extends HttpConfigurationBuilder
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java
new file mode 100644
index 00000000..d0bad056
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java
@@ -0,0 +1,386 @@
+package com.launchdarkly.sdk.android;
+
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.logging.LogValues;
+import com.launchdarkly.sdk.EvaluationReason;
+import com.launchdarkly.sdk.LDContext;
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.android.subsystems.EventProcessor;
+import com.launchdarkly.sdk.internal.events.DiagnosticEvent;
+import com.launchdarkly.sdk.internal.events.DiagnosticStore;
+import com.launchdarkly.sdk.internal.events.Event;
+import com.launchdarkly.sdk.internal.events.EventSender;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * The Android SDK's analytics event processor.
+ * <p>
+ * Recording an event summarizes it immediately and, only if it has to be delivered in full,
+ * buffers it. There is no queue between the calling thread and the summarizer, so a burst of flag
+ * evaluations cannot displace anything: evaluations of untracked flags cost a counter increment,
+ * and the configured capacity limits only the events that genuinely have to be sent one by one.
+ */
+final class DirectEventProcessor implements EventProcessor {
+    private final OutboundEventBuffer buffer;
+    private final EventSender eventSender;
+    private final URI eventsUri;
+    private final DiagnosticStore diagnosticStore;
+    private final long flushIntervalMillis;
+    private final long diagnosticRecordingIntervalMillis;
+    private final ScheduledExecutorService scheduler;
+    private final LDLogger logger;
+
+    private final AtomicBoolean inBackground;
+    private final AtomicBoolean offline;
+    private final AtomicBoolean closed = new AtomicBoolean(false);
+    // Set when the service tells us to stop, e.g. because the mobile key is invalid.
+    private final AtomicBoolean disabled = new AtomicBoolean(false);
+    private final AtomicBoolean diagnosticInitSent = new AtomicBoolean(false);
+    private final AtomicLong lastKnownPastTime = new AtomicLong(0);
+
+    private final Object stateLock = new Object();
+    private ScheduledFuture<?> flushTask;
+    private ScheduledFuture<?> diagnosticTask;
+
+    DirectEventProcessor(
+            OutboundEventBuffer buffer,
+            EventSender eventSender,
+            URI eventsUri,
+            DiagnosticStore diagnosticStore,
+            long flushIntervalMillis,
+            long diagnosticRecordingIntervalMillis,
+            boolean initiallyInBackground,
+            boolean initiallyOffline,
+            ScheduledExecutorService scheduler,
+            LDLogger logger
+    ) {
+        this.buffer = buffer;
+        this.eventSender = eventSender;
+        this.eventsUri = eventsUri;
+        this.diagnosticStore = diagnosticStore;
+        this.flushIntervalMillis = flushIntervalMillis;
+        this.diagnosticRecordingIntervalMillis = diagnosticRecordingIntervalMillis;
+        this.scheduler = scheduler;
+        this.logger = logger;
+        this.inBackground = new AtomicBoolean(initiallyInBackground);
+        this.offline = new AtomicBoolean(initiallyOffline);
+
+        synchronized (stateLock) {
+            updateScheduledTasks(initiallyInBackground, initiallyOffline);
+        }
+    }
+
+    @Override
+    public void recordEvaluationEvent(
+            LDContext context,
+            String flagKey,
+            int flagVersion,
+            int variation,
+            LDValue value,
+            EvaluationReason reason,
+            LDValue defaultValue,
+            boolean requireFullEvent,
+            Long debugEventsUntilDate
+    ) {
+        if (isStopped() || context == null) {
+            return;
+        }
+        Event.FeatureRequest event = new Event.FeatureRequest(System.currentTimeMillis(), flagKey,
+                context, flagVersion, variation, value, defaultValue, reason, null,
+                requireFullEvent, debugEventsUntilDate, false);
+        buffer.summarize(event);
+        if (requireFullEvent) {
+            buffer.addFullEvent(event);
+        }
+        if (shouldDebugEvent(debugEventsUntilDate)) {
+            buffer.addFullEvent(event.toDebugEvent());
+        }
+    }
+
+    @Override
+    public void recordIdentifyEvent(LDContext context) {
+        if (isStopped() || context == null) {
+            return;
+        }
+        buffer.addFullEvent(new Event.Identify(System.currentTimeMillis(), context));
+    }
+
+    @Override
+    public void recordCustomEvent(LDContext context, String eventKey, LDValue data, Double metricValue) {
+        if (isStopped() || context == null) {
+            return;
+        }
+        buffer.addFullEvent(new Event.Custom(System.currentTimeMillis(), eventKey, context, data,
+                metricValue));
+    }
+
+    @Override
+    public void setInBackground(boolean inBackground) {
+        if (closed.get()) {
+            return;
+        }
+        synchronized (stateLock) {
+            if (this.inBackground.getAndSet(inBackground) == inBackground) {
+                return;
+            }
+            updateScheduledTasks(inBackground, offline.get());
+        }
+    }
+
+    @Override
+    public void setOffline(boolean offline) {
+        if (closed.get()) {
+            return;
+        }
+        synchronized (stateLock) {
+            if (this.offline.getAndSet(offline) == offline) {
+                return;
+            }
+            updateScheduledTasks(inBackground.get(), offline);
+            if (!offline) {
+                // The periodic task was cancelled for the outage and starts a fresh interval above,
+                // so anything the outage buffered would otherwise wait the whole of it. Worse, each
+                // loss of connectivity re-anchors that interval, so a run of brief ones can hold
+                // events back for far longer than a single interval.
+                submit(this::deliverPayload);
+            }
+        }
+    }
+
+    @Override
+    public void flush() {
+        if (isStopped()) {
+            return;
+        }
+        submit(this::deliverPayload);
+    }
+
+    @Override
+    public void blockingFlush() {
+        if (isStopped()) {
+            return;
+        }
+        Future<?> delivery = submit(this::deliverPayload);
+        if (delivery == null) {
+            return;
+        }
+        try {
+            delivery.get();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (ExecutionException e) {
+            logUnexpectedError(e.getCause() == null ? e : e.getCause());
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (!closed.compareAndSet(false, true)) {
+            return;
+        }
+        synchronized (stateLock) {
+            flushTask = enableOrDisableTask(false, flushTask, 0, null);
+            diagnosticTask = enableOrDisableTask(false, diagnosticTask, 0, null);
+        }
+        // Deliver what is still buffered before we let go of the sender. The caller is entitled to
+        // assume the events made it out once close() returns, so this waits rather than firing and
+        // forgetting; it is the last chance these events get.
+        Future<?> delivery = submit(this::deliverPayload);
+        if (delivery != null) {
+            try {
+                delivery.get();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            } catch (ExecutionException e) {
+                logUnexpectedError(e.getCause() == null ? e : e.getCause());
+            }
+        }
+        scheduler.shutdown();
+        eventSender.close();
+    }
+
+    /**
+     * Serializes and sends everything buffered. Runs on the scheduler thread, so only one payload
+     * is ever in flight and the buffer is drained exactly once per delivery.
+     */
+    private void deliverPayload() {
+        if (disabled.get() || offline.get()) {
+            return;
+        }
+        OutboundEventBuffer.Payload payload;
+        try {
+            payload = buffer.drain();
+        } catch (IOException e) {
+            logUnexpectedError(e);
+            return;
+        }
+        if (payload == null) {
+            return;
+        }
+        if (diagnosticStore != null) {
+            diagnosticStore.recordEventsInBatch(payload.getEventCount());
+        }
+        try {
+            handleResponse(eventSender.sendAnalyticsEvents(payload.getData(),
+                    payload.getEventCount(), eventsUri));
+        } catch (Exception e) {
+            logUnexpectedError(e);
+        }
+    }
+
+    private void sendDiagnosticEvent(DiagnosticEvent diagnosticEvent, boolean isInit) {
+        if (diagnosticsSuspended()) {
+            return;
+        }
+        try {
+            byte[] data = diagnosticEvent.getJsonValue().toJsonString()
+                    .getBytes(StandardCharsets.UTF_8);
+            handleResponse(eventSender.sendDiagnosticEvent(data, eventsUri));
+            if (isInit) {
+                // Attempted, not delivered. A failed post gives back an unsuccessful Result rather
+                // than throwing, so this marks the init event done either way and the process never
+                // retries it. That matches DefaultEventProcessor, which is the behaviour to keep:
+                // diagnostics are best-effort telemetry about the SDK, and a retry that outlived
+                // its own init would describe a configuration the application has moved on from.
+                diagnosticInitSent.set(true);
+            }
+        } catch (Exception e) {
+            logUnexpectedError(e);
+        }
+    }
+
+    private void sendDiagnosticStats() {
+        // Checked before createEventAndReset, which clears the counters it hands back: bailing out
+        // after that call would discard a period's worth of statistics instead of deferring them.
+        if (diagnosticsSuspended() || diagnosticStore == null) {
+            return;
+        }
+        sendDiagnosticEvent(diagnosticStore.createEventAndReset(buffer.getAndClearDroppedCount(), 0),
+                false);
+    }
+
+    /**
+     * Unlike analytics events, diagnostics are not sent while offline or in the background.
+     * <p>
+     * {@link #updateScheduledTasks} cancels the periodic task when either becomes true, but that is
+     * not enough on its own. Cancelling does not stop a run already underway, and the init event is
+     * submitted before it reaches the executor. Either can arrive here after the state changed.
+     */
+    private boolean diagnosticsSuspended() {
+        return isStopped() || offline.get() || inBackground.get();
+    }
+
+    private void handleResponse(EventSender.Result result) {
+        if (result == null) {
+            return;
+        }
+        if (result.getTimeFromServer() != null) {
+            lastKnownPastTime.set(result.getTimeFromServer().getTime());
+        }
+        if (result.isMustShutDown()) {
+            disabled.set(true);
+        }
+    }
+
+    /**
+     * A debug event is emitted until the date the service gave us passes. We compare against the
+     * last date we know to be in the past according to the service as well as the device clock, so
+     * that a device whose clock is wrong errs on the side of stopping sooner.
+     */
+    private boolean shouldDebugEvent(Long debugEventsUntilDate) {
+        if (debugEventsUntilDate == null || debugEventsUntilDate <= 0) {
+            return false;
+        }
+        return debugEventsUntilDate > lastKnownPastTime.get()
+                && debugEventsUntilDate > System.currentTimeMillis();
+    }
+
+    private void updateScheduledTasks(boolean inBackground, boolean offline) {
+        if (closed.get()) {
+            return;
+        }
+        // Flushing is pointless while we are offline, but it stays on in the background so that
+        // events recorded before the app was backgrounded still get delivered.
+        flushTask = enableOrDisableTask(!offline, flushTask, flushIntervalMillis,
+                this::deliverPayload);
+        boolean diagnosticsEnabled = diagnosticStore != null && !offline && !inBackground;
+        diagnosticTask = enableOrDisableTask(diagnosticsEnabled, diagnosticTask,
+                diagnosticRecordingIntervalMillis, this::sendDiagnosticStats);
+        if (diagnosticsEnabled && !diagnosticInitSent.get()) {
+            DiagnosticStore store = diagnosticStore;
+            // Re-check on the executor thread: going online and coming to the foreground are two
+            // separate calls, and both want to send the init event we never got to send.
+            submit(() -> {
+                if (!diagnosticInitSent.get()) {
+                    sendDiagnosticEvent(store.getInitEvent(), true);
+                }
+            });
+        }
+    }
+
+    private ScheduledFuture<?> enableOrDisableTask(
+            boolean shouldEnable,
+            ScheduledFuture<?> currentTask,
+            long intervalMillis,
+            Runnable task
+    ) {
+        if (!shouldEnable) {
+            if (currentTask != null) {
+                currentTask.cancel(false);
+            }
+            return null;
+        }
+        if (currentTask != null) {
+            return currentTask;
+        }
+        try {
+            // Fixed delay rather than fixed rate: a cached process stops running its tasks without
+            // stopping the clock, so at a fixed rate it would come back owing every run it missed and
+            // fire them one after another.
+            return scheduler.scheduleWithFixedDelay(guarded(task), intervalMillis, intervalMillis,
+                    TimeUnit.MILLISECONDS);
+        } catch (RuntimeException e) { // the executor was shut down under us
+            return null;
+        }
+    }
+
+    private Future<?> submit(Runnable task) {
+        try {
+            return scheduler.submit(guarded(task));
+        } catch (RuntimeException e) { // the executor was shut down under us
+            return null;
+        }
+    }
+
+    /**
+     * Keeps an unexpected failure from killing a repeating task or bubbling out of the executor.
+     */
+    private Runnable guarded(Runnable task) {
+        return () -> {
+            try {
+                task.run();
+            } catch (Exception e) {
+                logUnexpectedError(e);
+            }
+        };
+    }
+
+    private boolean isStopped() {
+        return closed.get() || disabled.get();
+    }
+
+    private void logUnexpectedError(Throwable e) {
+        logger.error("Unexpected error in event processor: {}", LogValues.exceptionSummary(e));
+        logger.debug("{}", LogValues.exceptionTrace(e));
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java
new file mode 100644
index 00000000..c8039525
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java
@@ -0,0 +1,186 @@
+package com.launchdarkly.sdk.android;
+
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.sdk.AttributeRef;
+import com.launchdarkly.sdk.internal.events.AggregatedEventSummarizer;
+import com.launchdarkly.sdk.internal.events.Event;
+import com.launchdarkly.sdk.internal.events.EventOutputFormatter;
+import com.launchdarkly.sdk.internal.events.EventSummarizer;
+import com.launchdarkly.sdk.internal.events.EventSummarizerInterface;
+import com.launchdarkly.sdk.internal.events.EventsConfiguration;
+import com.launchdarkly.sdk.internal.events.PerContextEventSummarizer;
+import com.launchdarkly.sdk.internal.events.Sampler;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * The buffer behind {@link DirectEventProcessor}: evaluations are folded into summary
+ * counters as they are recorded, full-fidelity events are held in a capacity-limited list, and a
+ * flush turns whatever has accumulated into a serialized payload.
+ * <p>
+ * The summarization and the wire format come from java-sdk-internal rather than being
+ * reimplemented here, so there is one definition of what an event looks like on the wire.
+ * {@code DefaultEventProcessor} is not reused along with them because it only accepts individual
+ * events and summarizes them itself, on the far side of the bounded queue this is meant to get in
+ * front of.
+ */
+final class OutboundEventBuffer {
+    private static final int INITIAL_OUTPUT_BUFFER_SIZE = 2000;
+
+    private final EventOutputFormatter formatter;
+    private final EventSummarizerInterface summarizer;
+    private final List<Event> events = new ArrayList<>();
+    private final int capacity;
+    private final LDLogger logger;
+    private boolean capacityExceeded = false;
+    private long droppedEventCount = 0;
+
+    /**
+     * @param capacity how many full-fidelity events may be buffered between flushes
+     * @param allAttributesPrivate true to redact every context attribute except the key
+     * @param privateAttributes the individual context attributes to redact
+     * @param perContextSummarization true to emit one summary per context rather than one overall
+     * @param logger the logger to warn on when capacity is exceeded
+     */
+    OutboundEventBuffer(
+            int capacity,
+            boolean allAttributesPrivate,
+            Collection<AttributeRef> privateAttributes,
+            boolean perContextSummarization,
+            LDLogger logger
+    ) {
+        // Only the private-attribute settings affect the output; the rest of EventsConfiguration
+        // describes the delivery behavior that the processor now handles itself.
+        EventsConfiguration outputConfig = new EventsConfiguration(allAttributesPrivate, capacity,
+                null, 0, null, null, 1, null, 0, false, false, privateAttributes,
+                perContextSummarization);
+        this.formatter = new EventOutputFormatter(outputConfig);
+        this.summarizer = perContextSummarization
+                ? new PerContextEventSummarizer()
+                : new AggregatedEventSummarizer();
+        this.capacity = capacity >= 0 ? capacity : 1;
+        this.logger = logger;
+    }
+
+    /**
+     * Folds an evaluation into the summary counters, unless the evaluation asked to be left out of
+     * them.
+     * <p>
+     * A counter is an aggregate rather than a buffered event, so this never drops anything and is
+     * not affected by the configured capacity no matter how many evaluations an application does.
+     *
+     * @param event the evaluation
+     */
+    synchronized void summarize(Event.FeatureRequest event) {
+        // Checked here rather than in DirectEventProcessor, for the same reason the sampling ratio
+        // is: this is where an event arrives from outside. The processor builds its own through the
+        // constructor overload that leaves this false, so a guard there could never fire and would
+        // read as dead. java-sdk-internal's DefaultEventProcessor, which this path replaced, honored
+        // the flag, and a counter is the one thing no later stage can reconstruct.
+        if (event.isExcludeFromSummaries()) {
+            return;
+        }
+        summarizer.summarizeEvent(
+                event.getCreationDate(),
+                event.getKey(),
+                event.getVersion(),
+                event.getVariation(),
+                event.getValue(),
+                event.getDefaultVal(),
+                event.getContext()
+        );
+    }
+
+    /**
+     * Buffers an event that has to be delivered in full, subject to the configured capacity.
+     *
+     * @param event the event
+     */
+    synchronized void addFullEvent(Event event) {
+        if (!Sampler.shouldSample(event.getSamplingRatio())) {
+            return;
+        }
+        if (events.size() >= capacity) {
+            if (!capacityExceeded) {
+                capacityExceeded = true;
+                logger.warn("Exceeded event queue capacity. Increase capacity to avoid dropping events.");
+            }
+            droppedEventCount++;
+            return;
+        }
+        capacityExceeded = false;
+        events.add(event);
+    }
+
+    /**
+     * @return the number of full events dropped for capacity since this was last called
+     */
+    synchronized long getAndClearDroppedCount() {
+        long result = droppedEventCount;
+        droppedEventCount = 0;
+        return result;
+    }
+
+    /**
+     * Serializes everything accumulated so far and resets the buffer.
+     *
+     * @return the payload to send, or null if there was nothing to send
+     * @throws IOException if the events could not be serialized
+     */
+    synchronized Payload drain() throws IOException {
+        if (events.isEmpty() && summarizer.isEmpty()) {
+            return null;
+        }
+        Event[] eventsOut = events.toArray(new Event[0]);
+        List<EventSummarizer.EventSummary> summaries = summarizer.getSummariesAndReset();
+
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream(INITIAL_OUTPUT_BUFFER_SIZE);
+        Writer writer = new BufferedWriter(
+                new OutputStreamWriter(buffer, StandardCharsets.UTF_8), INITIAL_OUTPUT_BUFFER_SIZE);
+        int outputEventCount;
+        try {
+            outputEventCount = formatter.writeOutputEvents(eventsOut, summaries, writer);
+            writer.flush();
+        } catch (Exception e) {
+            summarizer.restoreTo(summaries);
+            throw e instanceof IOException ? (IOException) e : new IOException(e);
+        }
+        events.clear();
+        return new Payload(buffer.toByteArray(), outputEventCount);
+    }
+
+    /**
+     * A serialized batch of analytics events.
+     */
+    static final class Payload {
+        private final byte[] data;
+        private final int eventCount;
+
+        Payload(byte[] data, int eventCount) {
+            this.data = data;
+            this.eventCount = eventCount;
+        }
+
+        /**
+         * @return the JSON request body
+         */
+        byte[] getData() {
+            return data;
+        }
+
+        /**
+         * @return how many events the body represents, including summaries
+         */
+        int getEventCount() {
+            return eventCount;
+        }
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java
new file mode 100644
index 00000000..e463e76b
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java
@@ -0,0 +1,275 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+
+import com.launchdarkly.sdk.EvaluationReason;
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.android.subsystems.EventProcessor;
+import com.launchdarkly.testhelpers.httptest.HttpServer;
+import com.launchdarkly.testhelpers.httptest.RequestInfo;
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Behavior of the SDK's own event processor, covering the parts that are not about buffering under
+ * load (see {@link EventProcessorBufferingTest} for those).
+ */
+public class DirectEventProcessorTest extends EventProcessorTestBase {
+    private static final String FLAG_KEY = "flag-key";
+    private static final int FLAG_VERSION = 10;
+    private static final int VARIATION = 1;
+    private static final LDValue FLAG_VALUE = LDValue.of(true);
+    private static final LDValue DEFAULT_VALUE = LDValue.of(false);
+
+    private static final int DEFAULT_CAPACITY = 100;
+
+    @Test
+    public void untrackedEvaluationProducesOnlyASummary() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                recordEvaluation(eventProcessor, false, null);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(1, events.size());
+                assertEquals(1, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void trackedEvaluationProducesAFeatureEventAndASummary() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordEvaluationEvent(CONTEXT, FLAG_KEY, FLAG_VERSION, VARIATION,
+                        FLAG_VALUE, EvaluationReason.off(), DEFAULT_VALUE, true, null);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                LDValue featureEvent = requireEventOfKind(events, "feature");
+                assertEquals(LDValue.of(FLAG_KEY), featureEvent.get("key"));
+                assertEquals(LDValue.of(VARIATION), featureEvent.get("variation"));
+                assertEquals(FLAG_VALUE, featureEvent.get("value"));
+                assertEquals(LDValue.of(FLAG_VERSION), featureEvent.get("version"));
+                assertEquals(1, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void identifyAndCustomEventsAreDelivered() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordIdentifyEvent(CONTEXT);
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.of("data"), 2.5);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(2, events.size());
+                requireEventOfKind(events, "identify");
+                LDValue customEvent = requireEventOfKind(events, "custom");
+                assertEquals(LDValue.of("an-event"), customEvent.get("key"));
+                assertEquals(LDValue.of("data"), customEvent.get("data"));
+                assertEquals(LDValue.of(2.5), customEvent.get("metricValue"));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void capacityLimitsFullEventsButNotSummaries() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            int capacity = 3;
+            EventProcessor eventProcessor = makeEventProcessor(server, capacity);
+            try {
+                for (int i = 0; i < capacity + 2; i++) {
+                    eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+                }
+                // Evaluations well past capacity still have to be counted in full, because a
+                // counter does not occupy a buffer slot.
+                int evaluations = capacity * 100;
+                for (int i = 0; i < evaluations; i++) {
+                    recordEvaluation(eventProcessor, false, null);
+                }
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(capacity, countEventsOfKind(events, "custom"));
+                assertEquals(evaluations, summaryCountFor(events, FLAG_KEY));
+                logging.assertWarnLogged("Exceeded event queue capacity");
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void closeDeliversBufferedEventsWithoutAnExplicitFlush() throws Exception {
+        // This is the case the SDK previously lost: a short session that records something and
+        // then shuts down before the periodic flush comes around.
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            recordEvaluation(eventProcessor, false, null);
+            eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+
+            eventProcessor.close();
+
+            List<LDValue> events = collectDelivered(server);
+            assertEquals(1, countEventsOfKind(events, "custom"));
+            assertEquals(1, summaryCountFor(events, FLAG_KEY));
+        }
+    }
+
+    @Test
+    public void eventsRecordedWhileOfflineAreRetainedAndSentOnceOnline() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.setOffline(true);
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+                recordEvaluation(eventProcessor, false, null);
+
+                eventProcessor.blockingFlush();
+                server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+
+                eventProcessor.setOffline(false);
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(1, countEventsOfKind(events, "custom"));
+                assertEquals(1, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void comingBackOnlineDeliversWithoutWaitingForTheNextInterval() throws Exception {
+        // A connectivity blip cancels the periodic flush and then restarts it from zero, so waiting
+        // for it would hold these events back by a full interval — and by several of them if the
+        // network keeps dropping.
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.setOffline(true);
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+
+                eventProcessor.setOffline(false);
+
+                // Periodic flushing is effectively off in this fixture, so a payload arriving
+                // without an explicit flush can only have come from the transition.
+                List<LDValue> events = collectDelivered(server);
+                assertEquals(1, countEventsOfKind(events, "custom"));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void debugEventIsSentWhileDebuggingIsActive() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                long debugUntil = System.currentTimeMillis() + 3_600_000;
+                recordEvaluation(eventProcessor, false, debugUntil);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                LDValue debugEvent = requireEventOfKind(events, "debug");
+                assertEquals(LDValue.of(FLAG_KEY), debugEvent.get("key"));
+                // A debug event carries the full context rather than just its keys.
+                assertEquals(LDValue.of(CONTEXT.getKey()), debugEvent.get("context").get("key"));
+                assertEquals(1, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void debugEventIsNotSentOnceDebuggingHasExpired() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                long debugUntil = System.currentTimeMillis() - 3_600_000;
+                recordEvaluation(eventProcessor, false, debugUntil);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(0, countEventsOfKind(events, "debug"));
+                assertEquals(1, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void recordingAfterCloseIsIgnored() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            eventProcessor.recordCustomEvent(CONTEXT, "before-close", LDValue.ofNull(), null);
+            eventProcessor.close();
+            collectDelivered(server);
+
+            eventProcessor.recordCustomEvent(CONTEXT, "after-close", LDValue.ofNull(), null);
+            eventProcessor.flush();
+
+            server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    @Test
+    public void diagnosticInitEventIsSentWhenComingOnline() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            // makeEventProcessor takes the processor online, which is what triggers the init event.
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY, false);
+            try {
+                RequestInfo request = server.getRecorder().requireRequest(10, TimeUnit.SECONDS);
+
+                assertEquals("/mobile/events/diagnostic", request.getPath());
+                LDValue body = LDValue.parse(request.getBody());
+                assertEquals(LDValue.of("diagnostic-init"), body.get("kind"));
+                // Only one, even though going online and coming to the foreground both ask for it.
+                eventProcessor.setInBackground(false);
+                server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void diagnosticInitEventIsNotSentWhileOffline() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY, false);
+            try {
+                server.getRecorder().requireRequest(10, TimeUnit.SECONDS); // the init event
+                eventProcessor.setOffline(true);
+                eventProcessor.setInBackground(true);
+
+                server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    private void recordEvaluation(EventProcessor eventProcessor, boolean requireFullEvent,
+                                  Long debugEventsUntilDate) {
+        eventProcessor.recordEvaluationEvent(CONTEXT, FLAG_KEY, FLAG_VERSION, VARIATION, FLAG_VALUE,
+                null, DEFAULT_VALUE, requireFullEvent, debugEventsUntilDate);
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorBufferingTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorBufferingTest.java
new file mode 100644
index 00000000..08b004fe
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorBufferingTest.java
@@ -0,0 +1,161 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.android.subsystems.EventProcessor;
+import com.launchdarkly.testhelpers.httptest.HttpServer;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tests for what the event processor is allowed to drop when flag evaluations arrive faster than
+ * it can consume them.
+ * <p>
+ * The processor used to be a thin wrapper around java-sdk-internal's
+ * {@code DefaultEventProcessor}, which buffers in two stages: every recorded event is first
+ * offered to a bounded "inbox" queue, and only after a background dispatcher thread picks it up is
+ * it either summarized or placed in the outbox that a flush actually drains. The inbox is sized to
+ * the configured event capacity, and it carries the processor's own FLUSH and SHUTDOWN control
+ * messages as well as events. So a burst of evaluations could fill it and cause silent drops even
+ * though those evaluations were only ever going to contribute a counter to a summary event, and
+ * even though unrelated custom events were competing for the same slots.
+ * <p>
+ * These tests pin the behavior we want instead: summarization happens when the evaluation is
+ * recorded, so an evaluation never occupies a queue slot, and capacity only ever limits
+ * full-fidelity events. With summarization ahead of buffering there is no queue in this path, so
+ * the counts asserted below are exact rather than approximate.
+ */
+public class EventProcessorBufferingTest extends EventProcessorTestBase {
+    private static final String FLAG_KEY = "burst-flag";
+    private static final int FLAG_VERSION = 10;
+    private static final int VARIATION = 1;
+    private static final LDValue FLAG_VALUE = LDValue.of(true);
+    private static final LDValue DEFAULT_VALUE = LDValue.of(false);
+
+    // Deliberately far smaller than the number of evaluations each test records, so that any
+    // capacity-limited queue in the evaluation path would be guaranteed to overflow.
+    private static final int CAPACITY = 100;
+
+    private static final int BURST_THREADS = 4;
+    private static final int EVALUATIONS_PER_THREAD = 25_000;
+    private static final int TOTAL_EVALUATIONS = BURST_THREADS * EVALUATIONS_PER_THREAD;
+
+    // How many full-fidelity events the interleaving tests space through the burst. Comfortably
+    // under CAPACITY, so the buffer is never legitimately entitled to drop any of them.
+    private static final int INTERLEAVED_EVENTS = 50;
+
+    @Test
+    public void summaryCountsSurviveEvaluationBurst() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, CAPACITY);
+            try {
+                new EvaluationBurst(eventProcessor).join();
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                // Every evaluation contributes to the summary regardless of capacity, because a
+                // summary counter is not a buffered event.
+                assertEquals(TOTAL_EVALUATIONS, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void customEventsSurviveEvaluationBurst() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, CAPACITY);
+            try {
+                // Record custom events spaced evenly through the burst. These are full-fidelity
+                // events and there are far fewer of them than the configured capacity, so none of
+                // them may be lost no matter how many evaluations are happening alongside them.
+                EvaluationBurst burst = new EvaluationBurst(eventProcessor);
+                for (int i = 1; i <= INTERLEAVED_EVENTS; i++) {
+                    burst.awaitFraction(i, INTERLEAVED_EVENTS + 1);
+                    eventProcessor.recordCustomEvent(CONTEXT, "burst-custom", LDValue.ofNull(), null);
+                }
+                burst.join();
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(INTERLEAVED_EVENTS, countEventsOfKind(events, "custom"));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void fullFidelityEvaluationEventsSurviveEvaluationBurst() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, CAPACITY);
+            try {
+                // A flag with trackEvents on produces a full feature event in addition to its
+                // summary counter. Evaluations of untracked flags must not crowd these out.
+                EvaluationBurst burst = new EvaluationBurst(eventProcessor);
+                for (int i = 1; i <= INTERLEAVED_EVENTS; i++) {
+                    burst.awaitFraction(i, INTERLEAVED_EVENTS + 1);
+                    eventProcessor.recordEvaluationEvent(CONTEXT, "tracked-flag", FLAG_VERSION,
+                            VARIATION, FLAG_VALUE, null, DEFAULT_VALUE, true, null);
+                }
+                burst.join();
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertEquals(INTERLEAVED_EVENTS, countEventsOfKind(events, "feature"));
+                // The tracked evaluations are summarized too, alongside the burst.
+                assertEquals(INTERLEAVED_EVENTS, summaryCountFor(events, "tracked-flag"));
+                assertEquals(TOTAL_EVALUATIONS, summaryCountFor(events, FLAG_KEY));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    /**
+     * Records evaluations of an untracked flag from several threads at once, faster than any
+     * single consumer thread could drain them. Tests that need to interleave other events use
+     * {@link #awaitFraction} rather than sleeping, so the interleaved events land at the same
+     * points in the burst regardless of how fast the machine running the test is.
+     */
+    private final class EvaluationBurst {
+        private final List<Thread> workers = new ArrayList<>();
+        private volatile int progress;
+
+        EvaluationBurst(EventProcessor eventProcessor) {
+            for (int i = 0; i < BURST_THREADS; i++) {
+                boolean reportsProgress = i == 0;
+                Thread worker = new Thread(() -> {
+                    for (int j = 0; j < EVALUATIONS_PER_THREAD; j++) {
+                        eventProcessor.recordEvaluationEvent(CONTEXT, FLAG_KEY, FLAG_VERSION,
+                                VARIATION, FLAG_VALUE, null, DEFAULT_VALUE, false, null);
+                        if (reportsProgress) {
+                            progress = j + 1;
+                        }
+                    }
+                });
+                worker.start();
+                workers.add(worker);
+            }
+        }
+
+        /** Blocks until the burst is {@code numerator/denominator} of the way through. */
+        void awaitFraction(int numerator, int denominator) {
+            int target = (int) ((long) EVALUATIONS_PER_THREAD * numerator / denominator);
+            while (progress < target && workers.get(0).isAlive()) {
+                Thread.yield();
+            }
+        }
+
+        void join() throws InterruptedException {
+            for (Thread worker : workers) {
+                worker.join();
+            }
+        }
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorPrivacyTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorPrivacyTest.java
new file mode 100644
index 00000000..5ff0bcba
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorPrivacyTest.java
@@ -0,0 +1,269 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.launchdarkly.sdk.ContextKind;
+import com.launchdarkly.sdk.LDContext;
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.android.subsystems.EventProcessor;
+import com.launchdarkly.testhelpers.httptest.HttpServer;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Context attribute redaction, as observed in the payload the processor actually posts.
+ * <p>
+ * Redaction is not reimplemented by the SDK's event processor - it reuses java-sdk-internal's
+ * context formatter through {@link OutboundEventBuffer}. These
+ * tests exist because that reuse is the whole argument for the current design, and nothing else in
+ * this repository asserts that an attribute an application marked private stays out of the wire
+ * format. Beyond the redaction itself they pin the two rules that are easy to get wrong when
+ * events are assembled somewhere new: which events inline a context at all, and which of them
+ * additionally redact the attributes of an anonymous context.
+ */
+public class EventProcessorPrivacyTest extends EventProcessorTestBase {
+    private static final String FLAG_KEY = "flag-key";
+    private static final int DEFAULT_CAPACITY = 100;
+
+    private static final LDContext PERSON = LDContext.builder("user-key")
+            .name("Sandy")
+            .set("email", "sandy@example.com")
+            .set("address", LDValue.buildObject()
+                    .put("city", "Oakland")
+                    .put("street", "123 Main St")
+                    .build())
+            .build();
+
+    @Test
+    public void namedPrivateAttributesAreRedactedAndReported() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).privateAttributes("email"), true);
+            try {
+                eventProcessor.recordIdentifyEvent(PERSON);
+
+                LDValue context = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "identify").get("context");
+
+                assertEquals(LDValue.of("user-key"), context.get("key"));
+                assertEquals("email must not appear in the payload",
+                        LDValue.ofNull(), context.get("email"));
+                // Attributes that were not marked private are still sent.
+                assertEquals(LDValue.of("Sandy"), context.get("name"));
+                assertEquals(redacted("email"), redactedAttributes(context));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void allAttributesPrivateLeavesOnlyTheKey() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).allAttributesPrivate(true), true);
+            try {
+                eventProcessor.recordIdentifyEvent(PERSON);
+
+                LDValue context = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "identify").get("context");
+
+                // The key and kind are identifiers rather than attributes, so they survive.
+                assertEquals(LDValue.of("user-key"), context.get("key"));
+                assertEquals(LDValue.of("user"), context.get("kind"));
+                assertEquals(LDValue.ofNull(), context.get("name"));
+                assertEquals(LDValue.ofNull(), context.get("email"));
+                assertEquals(LDValue.ofNull(), context.get("address"));
+                assertEquals(redacted("address", "email", "name"), redactedAttributes(context));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void aPrivateSubAttributeRedactsOnlyThatProperty() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).privateAttributes("/address/street"), true);
+            try {
+                eventProcessor.recordIdentifyEvent(PERSON);
+
+                LDValue context = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "identify").get("context");
+
+                assertEquals(LDValue.of("Oakland"), context.get("address").get("city"));
+                assertEquals(LDValue.ofNull(), context.get("address").get("street"));
+                assertEquals(redacted("/address/street"), redactedAttributes(context));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void attributesMarkedPrivateOnTheContextItselfAreRedacted() throws Exception {
+        // An application can mark an attribute private per-context instead of globally; the
+        // processor is not configured with anything in this case.
+        LDContext context = LDContext.builder("user-key")
+                .name("Sandy")
+                .set("email", "sandy@example.com")
+                .privateAttributes("email")
+                .build();
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordIdentifyEvent(context);
+
+                LDValue delivered = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "identify").get("context");
+
+                assertEquals(LDValue.ofNull(), delivered.get("email"));
+                assertEquals(LDValue.of("Sandy"), delivered.get("name"));
+                assertEquals(redacted("email"), redactedAttributes(delivered));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void anonymousContextAttributesAreRedactedFromFeatureEventsButNotIdentifyEvents() throws Exception {
+        LDContext anonymous = LDContext.builder(ContextKind.DEFAULT, "anon-key")
+                .anonymous(true)
+                .set("email", "sandy@example.com")
+                .build();
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordIdentifyEvent(anonymous);
+                eventProcessor.recordEvaluationEvent(anonymous, FLAG_KEY, 10, 1, LDValue.of(true),
+                        null, LDValue.of(false), true, null);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                // An identify event is the application deliberately registering this context.
+                LDValue identifyContext = requireEventOfKind(events, "identify").get("context");
+                assertEquals(LDValue.of("sandy@example.com"), identifyContext.get("email"));
+
+                // A feature event redacts every attribute of an anonymous context, without the
+                // application having to mark anything private.
+                LDValue featureContext = requireEventOfKind(events, "feature").get("context");
+                assertEquals(LDValue.of("anon-key"), featureContext.get("key"));
+                assertEquals(LDValue.ofNull(), featureContext.get("email"));
+                assertEquals(redacted("email"), redactedAttributes(featureContext));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void summaryEventsRedactPrivateAttributesOfTheContextTheyInline() throws Exception {
+        // Because this SDK summarizes per context, a summary event inlines the context it counted
+        // rather than just its key, and so it is subject to redaction like any other event. This
+        // is the case most easily missed, since summaries are produced by the buffer rather than
+        // by an explicit record call.
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).privateAttributes("email"), true);
+            try {
+                eventProcessor.recordEvaluationEvent(PERSON, FLAG_KEY, 10, 1, LDValue.of(true),
+                        null, LDValue.of(false), false, null);
+
+                LDValue summary = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "summary");
+
+                LDValue context = summary.get("context");
+                assertEquals(LDValue.of("user-key"), context.get("key"));
+                assertEquals(LDValue.ofNull(), context.get("email"));
+                assertEquals(redacted("email"), redactedAttributes(context));
+                // Attributes that were not marked private are inlined here, same as anywhere else.
+                assertEquals(LDValue.of("Oakland"), context.get("address").get("city"));
+                assertFalse("summary should not contain the email value anywhere",
+                        summary.toJsonString().contains("sandy@example.com"));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void redactionAppliesToEveryKindOfAMultiContext() throws Exception {
+        LDContext multi = LDContext.createMulti(
+                LDContext.builder(ContextKind.of("user"), "user-key")
+                        .set("email", "sandy@example.com")
+                        .build(),
+                LDContext.builder(ContextKind.of("org"), "org-key")
+                        .set("email", "billing@example.com")
+                        .build());
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).privateAttributes("email"), true);
+            try {
+                eventProcessor.recordIdentifyEvent(multi);
+
+                LDValue delivered = requireEventOfKind(flushAndCollect(eventProcessor, server),
+                        "identify").get("context");
+
+                assertEquals(LDValue.of("multi"), delivered.get("kind"));
+                assertEquals(LDValue.ofNull(), delivered.get("user").get("email"));
+                assertEquals(LDValue.ofNull(), delivered.get("org").get("email"));
+                assertEquals(redacted("email"), redactedAttributes(delivered.get("user")));
+                assertEquals(redacted("email"), redactedAttributes(delivered.get("org")));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void noPayloadContainsAPrivateValueAnywhere() throws Exception {
+        // A belt-and-braces check over the whole request body rather than one field, so that a
+        // private value cannot slip through in some event kind these tests do not name.
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server,
+                    eventsBuilder(DEFAULT_CAPACITY).privateAttributes("email"), true);
+            try {
+                eventProcessor.recordIdentifyEvent(PERSON);
+                eventProcessor.recordCustomEvent(PERSON, "an-event", LDValue.ofNull(), null);
+                eventProcessor.recordEvaluationEvent(PERSON, FLAG_KEY, 10, 1, LDValue.of(true),
+                        null, LDValue.of(false), true, null);
+
+                List<LDValue> events = flushAndCollect(eventProcessor, server);
+
+                assertTrue("expected identify, custom, feature and summary events",
+                        events.size() >= 4);
+                for (LDValue event : events) {
+                    assertFalse("private value leaked into " + event.get("kind") + ": " + event,
+                            event.toJsonString().contains("sandy@example.com"));
+                }
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    private static List<String> redacted(String... names) {
+        List<String> result = new ArrayList<>();
+        for (String name : names) {
+            result.add(name);
+        }
+        return result;
+    }
+
+    /** The names the payload itself reports as redacted, sorted so the comparison is stable. */
+    private static List<String> redactedAttributes(LDValue context) {
+        List<String> names = new ArrayList<>();
+        for (LDValue name : context.get("_meta").get("redactedAttributes").values()) {
+            names.add(name.stringValue());
+        }
+        java.util.Collections.sort(names);
+        return names;
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorTestBase.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorTestBase.java
new file mode 100644
index 00000000..48597b0d
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorTestBase.java
@@ -0,0 +1,145 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.launchdarkly.sdk.LDContext;
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.android.LDConfig.Builder.AutoEnvAttributes;
+import com.launchdarkly.sdk.android.env.EnvironmentReporterBuilder;
+import com.launchdarkly.sdk.android.env.IEnvironmentReporter;
+import com.launchdarkly.sdk.android.integrations.EventProcessorBuilder;
+import com.launchdarkly.sdk.android.subsystems.ClientContext;
+import com.launchdarkly.sdk.android.subsystems.EventProcessor;
+import com.launchdarkly.testhelpers.httptest.Handlers;
+import com.launchdarkly.testhelpers.httptest.HttpServer;
+import com.launchdarkly.testhelpers.httptest.RequestInfo;
+
+import org.junit.Rule;
+import org.junit.rules.Timeout;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Fixture for tests that drive the SDK's event processor directly and read back the analytics
+ * payload it posts.
+ */
+public abstract class EventProcessorTestBase {
+    protected static final String MOBILE_KEY = "test-mobile-key";
+    protected static final LDContext CONTEXT = LDContext.create("user-key");
+
+    // Long enough that the only payload in a test is the one it asks for explicitly.
+    private static final int NO_PERIODIC_FLUSH_MILLIS = 600_000;
+
+    @Rule
+    public Timeout globalTimeout = Timeout.seconds(60);
+    @Rule
+    public LogCaptureRule logging = new LogCaptureRule();
+
+    private final IEnvironmentReporter environmentReporter = new EnvironmentReporterBuilder().build();
+
+    protected HttpServer startEventsServer() {
+        return HttpServer.start(Handlers.status(202));
+    }
+
+    protected EventProcessor makeEventProcessor(HttpServer server, int capacity) {
+        return makeEventProcessor(server, capacity, true);
+    }
+
+    protected EventProcessor makeEventProcessor(HttpServer server, int capacity,
+                                                boolean diagnosticOptOut) {
+        return makeEventProcessor(server, eventsBuilder(capacity), diagnosticOptOut);
+    }
+
+    /**
+     * @return an events builder with the capacity set and periodic flushing effectively off, for
+     *   tests that need to configure something else on top such as private attributes
+     */
+    protected EventProcessorBuilder eventsBuilder(int capacity) {
+        return Components.sendEvents()
+                .capacity(capacity)
+                .flushIntervalMillis(NO_PERIODIC_FLUSH_MILLIS);
+    }
+
+    protected EventProcessor makeEventProcessor(HttpServer server, EventProcessorBuilder events,
+                                                boolean diagnosticOptOut) {
+        LDConfig config = new LDConfig.Builder(AutoEnvAttributes.Disabled)
+                .mobileKey(MOBILE_KEY)
+                .diagnosticOptOut(diagnosticOptOut)
+                .events(events)
+                .serviceEndpoints(Components.serviceEndpoints().events(server.getUri()))
+                .build();
+        ClientContext clientContext = ClientContextImpl.fromConfig(config, MOBILE_KEY, "",
+                null, null, CONTEXT, logging.logger, null, environmentReporter, null);
+        EventProcessor eventProcessor = config.events.build(clientContext);
+        // The processor is built offline; LDClient turns it on once initialization decides the SDK
+        // is not in offline mode.
+        eventProcessor.setOffline(false);
+        return eventProcessor;
+    }
+
+    /**
+     * Flushes and returns every event the processor posted. {@code blockingFlush} does not return
+     * until delivery completes, so there is no settling delay here.
+     */
+    protected List<LDValue> flushAndCollect(EventProcessor eventProcessor, HttpServer server) {
+        eventProcessor.blockingFlush();
+        return collectDelivered(server);
+    }
+
+    /** Returns every event posted so far, without asking for a flush. */
+    protected List<LDValue> collectDelivered(HttpServer server) {
+        List<LDValue> events = new ArrayList<>();
+        collectRequest(server.getRecorder().requireRequest(10, TimeUnit.SECONDS), events);
+        while (server.getRecorder().count() > 0) {
+            collectRequest(server.getRecorder().requireRequest(10, TimeUnit.SECONDS), events);
+        }
+        return events;
+    }
+
+    private void collectRequest(RequestInfo request, List<LDValue> events) {
+        assertEquals("POST", request.getMethod());
+        assertEquals("/mobile/events/bulk", request.getPath());
+        for (LDValue event : LDValue.parse(request.getBody()).values()) {
+            events.add(event);
+        }
+    }
+
+    protected int countEventsOfKind(List<LDValue> events, String kind) {
+        int count = 0;
+        for (LDValue event : events) {
+            if (kind.equals(event.get("kind").stringValue())) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    protected LDValue requireEventOfKind(List<LDValue> events, String kind) {
+        for (LDValue event : events) {
+            if (kind.equals(event.get("kind").stringValue())) {
+                return event;
+            }
+        }
+        throw new AssertionError("no event of kind " + kind + " in " + events);
+    }
+
+    protected int summaryCountFor(List<LDValue> events, String flagKey) {
+        int total = 0;
+        boolean sawSummary = false;
+        for (LDValue event : events) {
+            if (!"summary".equals(event.get("kind").stringValue())) {
+                continue;
+            }
+            sawSummary = true;
+            // Per-context summarization means a flag can have more than one counter entry.
+            for (LDValue counter : event.get("features").get(flagKey).get("counters").values()) {
+                total += counter.get("count").intValue();
+            }
+        }
+        assertTrue("no summary event was delivered", sawSummary);
+        return total;
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/OutboundEventBufferFlagsTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/OutboundEventBufferFlagsTest.java
new file mode 100644
index 00000000..76a72833
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/OutboundEventBufferFlagsTest.java
@@ -0,0 +1,135 @@
+package com.launchdarkly.sdk.android;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import com.launchdarkly.sdk.LDValue;
+import com.launchdarkly.sdk.internal.events.Event;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Tests for the two per-event flags the buffer is expected to honour: {@code excludeFromSummaries},
+ * which keeps an evaluation out of the counters, and {@code samplingRatio}, which decides whether a
+ * full event is kept at all.
+ * <p>
+ * Neither flag can be reached through the SDK's own recording path. {@link DirectEventProcessor}
+ * builds its feature events with the constructor overload that fixes them at {@code false} and
+ * {@code 1}, so every evaluation an application performs leaves both at their defaults. That is
+ * exactly why these tests go at the buffer directly rather than through the processor: the buffer
+ * is the seam an event crosses from outside, and the only one at which the flags can vary.
+ * <p>
+ * They are worth pinning even so. java-sdk-internal's {@code DefaultEventProcessor}, which this
+ * path replaced, honoured both, and anything that later constructs feature events through the
+ * fourteen-argument constructor — adopting sampling is the obvious candidate — makes both live at
+ * once. The failure would be silent and would show up as wrong analytics rather than as an error,
+ * since an event carries its sampling ratio on the wire so the receiver can scale by it.
+ * <p>
+ * Both ratios used here are deterministic rather than probabilistic: {@code Sampler.shouldSample}
+ * short-circuits to {@code true} at 1 and to {@code false} at 0, so nothing below is flaky.
+ */
+public class OutboundEventBufferFlagsTest extends EventProcessorTestBase {
+    private static final String FLAG_KEY = "flags-test-flag";
+    private static final int FLAG_VERSION = 3;
+    private static final int VARIATION = 1;
+    private static final LDValue FLAG_VALUE = LDValue.of(true);
+    private static final LDValue DEFAULT_VALUE = LDValue.of(false);
+    private static final long CREATION_DATE = 1_700_000_000_000L;
+
+    // Far more than any test here buffers, so that capacity can never be what discarded an event.
+    private static final int CAPACITY = 100;
+
+    @Test
+    public void anEvaluationExcludedFromSummariesIsNotCounted() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.summarize(evaluation(true));
+
+        assertNull("an excluded evaluation should leave nothing to send", buffer.drain());
+    }
+
+    @Test
+    public void anEvaluationNotExcludedFromSummariesIsCounted() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.summarize(evaluation(false));
+
+        assertEquals(1, summaryCountFor(drainToEvents(buffer), FLAG_KEY));
+    }
+
+    @Test
+    public void excludingOneEvaluationLeavesTheOthersCounted() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.summarize(evaluation(false));
+        buffer.summarize(evaluation(true));
+        buffer.summarize(evaluation(false));
+
+        // The exclusion applies to the event that carried it and to nothing else, which is what
+        // distinguishes honouring the flag from dropping the whole summary.
+        assertEquals(2, summaryCountFor(drainToEvents(buffer), FLAG_KEY));
+    }
+
+    @Test
+    public void aFullEventSampledOutIsNotBuffered() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.addFullEvent(evaluation(false, 0));
+
+        assertNull("a sampled-out event should leave nothing to send", buffer.drain());
+    }
+
+    @Test
+    public void aFullEventSampledInIsBuffered() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.addFullEvent(evaluation(false, 1));
+
+        assertEquals(1, countEventsOfKind(drainToEvents(buffer), "feature"));
+    }
+
+    @Test
+    public void aSampledOutEventIsNotCountedAsADrop() throws IOException {
+        OutboundEventBuffer buffer = makeBuffer();
+
+        buffer.addFullEvent(evaluation(false, 0));
+
+        // Sampling and capacity are different reasons not to keep an event, and only the second is
+        // a loss the SDK owes anyone a count of.
+        assertEquals(0, buffer.getAndClearDroppedCount());
+    }
+
+    private OutboundEventBuffer makeBuffer() {
+        return new OutboundEventBuffer(CAPACITY, false, Collections.emptyList(), false,
+                logging.logger);
+    }
+
+    private Event.FeatureRequest evaluation(boolean excludeFromSummaries) {
+        return evaluation(excludeFromSummaries, 1);
+    }
+
+    private Event.FeatureRequest evaluation(boolean excludeFromSummaries, long samplingRatio) {
+        return new Event.FeatureRequest(CREATION_DATE, FLAG_KEY, CONTEXT, FLAG_VERSION, VARIATION,
+                FLAG_VALUE, DEFAULT_VALUE, null, null, true, null, false, samplingRatio,
+                excludeFromSummaries);
+    }
+
+    private List<LDValue> drainToEvents(OutboundEventBuffer buffer) throws IOException {
+        OutboundEventBuffer.Payload payload = buffer.drain();
+        if (payload == null) {
+            return Collections.emptyList();
+        }
+        List<LDValue> events = new ArrayList<>();
+        for (LDValue event : LDValue.parse(new String(payload.getData(), StandardCharsets.UTF_8))
+                .values()) {
+            events.add(event);
+        }
+        return events;
+    }
+}
diff --git a/shared-test-code/build.gradle b/shared-test-code/build.gradle
index c3fb0e05..50f66687 100644
--- a/shared-test-code/build.gradle
+++ b/shared-test-code/build.gradle
@@ -12,7 +12,7 @@ ext.versions = [
     "androidAnnotation": "1.2.0",
     "gson": "2.13.2",
     "junit": "4.13",
-    "launchdarklyJavaSdkInternal": "1.9.0",
+    "launchdarklyJavaSdkInternal": "1.12.0",
     "launchdarklyLogging": "1.1.1",
 ]