From 244e04b20e33c70289578394ba97f38f290dee6b Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Thu, 3 Sep 2026 16:59:53 -0700
Subject: [PATCH 01/10] feat(events): summarize and buffer events on the
 recording thread (tier 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Tier 1 of the event durability spec: the buffer.

AndroidEventBuffer folds an evaluation into summary counters as it is recorded
and holds in full only the events that have to be sent one by one, so a burst of
evaluations of untracked flags cannot displace anything. AndroidEventProcessor
takes over from java-sdk-internal's DefaultEventProcessor in ComponentsImpl,
removing the bounded queue that used to sit between the calling thread and the
summarizer.

Spec: Event Durability, "Tier 1 — the buffer".
Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../launchdarkly/example/MainActivity.java    |  24 ++
 example/src/main/res/layout/activity_main.xml |  13 +-
 launchdarkly-android-client-sdk/build.gradle  |  12 +
 .../sdk/android/AndroidEventProcessor.java    | 359 ++++++++++++++++++
 .../sdk/android/ComponentsImpl.java           | 109 +-----
 .../internal/events/AndroidEventBuffer.java   | 189 +++++++++
 .../android/AndroidEventProcessorTest.java    | 252 ++++++++++++
 .../android/EventProcessorBufferingTest.java  | 161 ++++++++
 .../android/EventProcessorPrivacyTest.java    | 269 +++++++++++++
 .../sdk/android/EventProcessorTestBase.java   | 145 +++++++
 10 files changed, 1442 insertions(+), 91 deletions(-)
 create mode 100644 launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
 create mode 100644 launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/internal/events/AndroidEventBuffer.java
 create mode 100644 launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java
 create mode 100644 launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorBufferingTest.java
 create mode 100644 launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorPrivacyTest.java
 create mode 100644 launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/EventProcessorTestBase.java

diff --git a/example/src/main/java/com/launchdarkly/example/MainActivity.java b/example/src/main/java/com/launchdarkly/example/MainActivity.java
index 9b604324..e7deb6ca 100644
--- a/example/src/main/java/com/launchdarkly/example/MainActivity.java
+++ b/example/src/main/java/com/launchdarkly/example/MainActivity.java
@@ -102,6 +102,7 @@ public void onCreate(Bundle savedInstanceState) {
         setupFlushButton();
         setupTrackButton();
         setupIdentifyButton();
+        setupKillUnsentButton();
         setupOfflineSwitch();
         setupListeners();
         updateDedupeStatus();
@@ -215,6 +216,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..c9197d62 100644
--- a/launchdarkly-android-client-sdk/build.gradle
+++ b/launchdarkly-android-client-sdk/build.gradle
@@ -131,16 +131,28 @@ def androidJavadoc = tasks.register("javadoc", Javadoc) {
     dependsOn("generateDebugBuildConfig", "generateReleaseBuildConfig")
 
     include("**/*.java")
+    // AndroidEventBuffer is public only so that com.launchdarkly.sdk.android can use it, and it
+    // sits in java-sdk-internal's package solely to reach that library's package-private event
+    // serialization. Documenting it would advertise a package this SDK does not own. Excluding it
+    // from the sources means javadoc resolves it from the compiled classes added below instead.
+    exclude("**/com/launchdarkly/sdk/internal/**")
 
     if (options instanceof StandardJavadocDocletOptions) {
         options.source = "8"
     }
 
+    dependsOn(android.libraryVariants.collect { it.javaCompileProvider })
+
     doFirst {
         // Include classpaths for dependencies
         classpath += files(android.libraryVariants.collect { variant ->
             variant.javaCompileProvider.get().classpath.files
         })
+        // ...and the SDK's own compiled classes, so that the excluded internal sources above can
+        // still be resolved by the classes that reference them.
+        classpath += files(android.libraryVariants.collect { variant ->
+            variant.javaCompileProvider.get().destinationDirectory
+        })
         // Add Android boot classpath for references to Android OS classes.
         def bootClasspath = files(android.bootClasspath)
         classpath += bootClasspath
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
new file mode 100644
index 00000000..ee9f9a94
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
@@ -0,0 +1,359 @@
+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.AndroidEventBuffer;
+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.Charset;
+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 AndroidEventProcessor implements EventProcessor {
+    private final AndroidEventBuffer 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;
+
+    AndroidEventProcessor(
+            AndroidEventBuffer 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);
+        }
+    }
+
+    @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;
+        }
+        AndroidEventBuffer.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 (disabled.get()) {
+            return;
+        }
+        try {
+            byte[] data = diagnosticEvent.getJsonValue().toJsonString()
+                    .getBytes(Charset.forName("UTF-8"));
+            handleResponse(eventSender.sendDiagnosticEvent(data, eventsUri));
+            if (isInit) {
+                diagnosticInitSent.set(true);
+            }
+        } catch (Exception e) {
+            logUnexpectedError(e);
+        }
+    }
+
+    private void sendDiagnosticStats() {
+        if (disabled.get() || diagnosticStore == null) {
+            return;
+        }
+        sendDiagnosticEvent(diagnosticStore.createEventAndReset(buffer.getAndClearDroppedCount(), 0),
+                false);
+    }
+
+    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 {
+            return scheduler.scheduleAtFixedRate(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/ComponentsImpl.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/ComponentsImpl.java
index 8c9cc045..62ea8156 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,10 @@
 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.AndroidEventBuffer;
 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 +99,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 AndroidEventProcessor(
+                    new AndroidEventBuffer(
+                            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 +135,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/internal/events/AndroidEventBuffer.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/internal/events/AndroidEventBuffer.java
new file mode 100644
index 00000000..43d7fe6e
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/internal/events/AndroidEventBuffer.java
@@ -0,0 +1,189 @@
+package com.launchdarkly.sdk.internal.events;
+
+import com.launchdarkly.logging.LDLogger;
+import com.launchdarkly.sdk.AttributeRef;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * The buffer behind the Android SDK's event processor: 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>
+ * This class is deliberately in java-sdk-internal's package rather than the Android SDK's own.
+ * The summarizers, the output formatter, and the context formatter that redacts private
+ * attributes are all package-private there, and there is no public way to hand java-sdk-internal
+ * a summary that has already been aggregated - {@code DefaultEventProcessor} only accepts
+ * individual events and summarizes them itself, on the far side of the bounded queue we are
+ * trying to get in front of. Sharing the package lets the Android SDK reuse that serialization
+ * instead of growing a second copy of the wire format that could drift.
+ * <p>
+ * Everything exposed here is a public type, so the rest of the Android SDK stays in its own
+ * package and only this one file depends on the split. If java-sdk-internal ever offers this
+ * capability publicly, this class should be deleted in favor of it.
+ * <p>
+ * It is public only so that {@code com.launchdarkly.sdk.android} can use it across the package
+ * boundary; it is not SDK API and is kept out of the published Javadoc.
+ *
+ * @hidden
+ */
+public final class AndroidEventBuffer {
+    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
+     */
+    public AndroidEventBuffer(
+            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 Android event 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.
+     * <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
+     */
+    public synchronized void summarize(Event.FeatureRequest event) {
+        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
+     */
+    public 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 true if there is nothing buffered and no summary counters
+     */
+    public synchronized boolean isEmpty() {
+        return events.isEmpty() && summarizer.isEmpty();
+    }
+
+    /**
+     * @return the number of full events dropped for capacity since this was last called
+     */
+    public 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
+     */
+    public 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, Charset.forName("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.
+     *
+     * @hidden
+     */
+    public 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
+         */
+        public byte[] getData() {
+            return data;
+        }
+
+        /**
+         * @return how many events the body represents, including summaries
+         */
+        public int getEventCount() {
+            return eventCount;
+        }
+    }
+}
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java
new file mode 100644
index 00000000..761af50c
--- /dev/null
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java
@@ -0,0 +1,252 @@
+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 AndroidEventProcessorTest 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 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..c7439685
--- /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 com.launchdarkly.sdk.internal.events.AndroidEventBuffer}. 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;
+    }
+}

From 73dc7d3fe31792d502c8a628b9be62a48042a95f Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 15 Sep 2026 09:16:50 -0700
Subject: [PATCH 02/10] build: build java-sdk-internal from a local checkout
 (temporary)

The next commit drops the split-package hack in favor of declarations that
launchdarkly/java-core#214 makes public. That is not in a release yet, so this
points the build at a working copy until one carries it.

Skipped when the directory is absent, so a clean checkout still resolves the
published artifact rather than failing. Revert together with a version bump once
the release is out.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../AndroidEventBuffer.java                   |  0
 settings.gradle                               | 25 +++++++++++++++++++
 2 files changed, 25 insertions(+)
 rename launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/{internal/events => android}/AndroidEventBuffer.java (100%)

diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/internal/events/AndroidEventBuffer.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
similarity index 100%
rename from launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/internal/events/AndroidEventBuffer.java
rename to launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
diff --git a/settings.gradle b/settings.gradle
index 36c077f5..2ac14b5a 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,3 +1,28 @@
+// TEMPORARY: builds java-sdk-internal from a working copy instead of the published artifact.
+//
+// The event durability work needs event serialization classes that are package-private in
+// java-sdk-internal, and the PR making them public is not released yet. Until a release carries
+// it, this points the build at a local checkout so the two can be developed together.
+//
+// Revert this block and bump `launchdarklyJavaSdkInternal` in
+// launchdarkly-android-client-sdk/build.gradle once the release is out.
+//
+// Set `ldJavaSdkInternalDir` in ~/.gradle/gradle.properties or on the command line to override the
+// default location; skipped entirely if the directory is not there, so a clean checkout still builds
+// against the published artifact.
+def javaSdkInternalDir = providers.gradleProperty("ldJavaSdkInternalDir")
+        .map { new File(it) }
+        .getOrElse(new File(rootDir, "../java-core/lib/shared/internal"))
+if (javaSdkInternalDir.directory) {
+    includeBuild(javaSdkInternalDir) {
+        dependencySubstitution {
+            substitute module("com.launchdarkly:launchdarkly-java-sdk-internal") using project(":")
+        }
+    }
+} else {
+    logger.lifecycle("Local java-sdk-internal not found at ${javaSdkInternalDir}; using the published artifact")
+}
+
 include(":launchdarkly-android-client-sdk")
 include(":shared-test-code")
 include(":example")

From e5cb94765431cab884bb189a9ae424ac32a01c11 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 15 Sep 2026 09:16:50 -0700
Subject: [PATCH 03/10] refactor(events): move AndroidEventBuffer out of
 java-sdk-internal's package

AndroidEventBuffer was declared in com.launchdarkly.sdk.internal.events so it
could reach the summarizers and the output formatter, which were package-private
there. That made a package split across two artifacts, forced the class to be
public for the rest of the SDK to use it, and needed a javadoc exclusion plus a
classpath workaround to keep it out of the published docs.

launchdarkly/java-core#214 makes those declarations public, so the class moves to
com.launchdarkly.sdk.android where it belongs. It is package-private now, along
with its members and Payload, because everything using it is in that package, so
it is out of the published docs by virtue of its visibility rather than by being
excluded from javadoc. The build.gradle javadoc block goes back to what it was
before tier 1.

No behavior change: same summarization, same wire format, same tests.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 launchdarkly-android-client-sdk/build.gradle  | 12 -----
 .../sdk/android/AndroidEventBuffer.java       | 53 +++++++++----------
 .../sdk/android/AndroidEventProcessor.java    |  1 -
 .../sdk/android/ComponentsImpl.java           |  1 -
 .../android/EventProcessorPrivacyTest.java    |  2 +-
 5 files changed, 25 insertions(+), 44 deletions(-)

diff --git a/launchdarkly-android-client-sdk/build.gradle b/launchdarkly-android-client-sdk/build.gradle
index c9197d62..3b7566cb 100644
--- a/launchdarkly-android-client-sdk/build.gradle
+++ b/launchdarkly-android-client-sdk/build.gradle
@@ -131,28 +131,16 @@ def androidJavadoc = tasks.register("javadoc", Javadoc) {
     dependsOn("generateDebugBuildConfig", "generateReleaseBuildConfig")
 
     include("**/*.java")
-    // AndroidEventBuffer is public only so that com.launchdarkly.sdk.android can use it, and it
-    // sits in java-sdk-internal's package solely to reach that library's package-private event
-    // serialization. Documenting it would advertise a package this SDK does not own. Excluding it
-    // from the sources means javadoc resolves it from the compiled classes added below instead.
-    exclude("**/com/launchdarkly/sdk/internal/**")
 
     if (options instanceof StandardJavadocDocletOptions) {
         options.source = "8"
     }
 
-    dependsOn(android.libraryVariants.collect { it.javaCompileProvider })
-
     doFirst {
         // Include classpaths for dependencies
         classpath += files(android.libraryVariants.collect { variant ->
             variant.javaCompileProvider.get().classpath.files
         })
-        // ...and the SDK's own compiled classes, so that the excluded internal sources above can
-        // still be resolved by the classes that reference them.
-        classpath += files(android.libraryVariants.collect { variant ->
-            variant.javaCompileProvider.get().destinationDirectory
-        })
         // Add Android boot classpath for references to Android OS classes.
         def bootClasspath = files(android.bootClasspath)
         classpath += bootClasspath
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
index 43d7fe6e..9b35017d 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
@@ -1,7 +1,15 @@
-package com.launchdarkly.sdk.internal.events;
+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;
@@ -18,24 +26,13 @@
  * 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>
- * This class is deliberately in java-sdk-internal's package rather than the Android SDK's own.
- * The summarizers, the output formatter, and the context formatter that redacts private
- * attributes are all package-private there, and there is no public way to hand java-sdk-internal
- * a summary that has already been aggregated - {@code DefaultEventProcessor} only accepts
- * individual events and summarizes them itself, on the far side of the bounded queue we are
- * trying to get in front of. Sharing the package lets the Android SDK reuse that serialization
- * instead of growing a second copy of the wire format that could drift.
- * <p>
- * Everything exposed here is a public type, so the rest of the Android SDK stays in its own
- * package and only this one file depends on the split. If java-sdk-internal ever offers this
- * capability publicly, this class should be deleted in favor of it.
- * <p>
- * It is public only so that {@code com.launchdarkly.sdk.android} can use it across the package
- * boundary; it is not SDK API and is kept out of the published Javadoc.
- *
- * @hidden
+ * 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.
  */
-public final class AndroidEventBuffer {
+final class AndroidEventBuffer {
     private static final int INITIAL_OUTPUT_BUFFER_SIZE = 2000;
 
     private final EventOutputFormatter formatter;
@@ -53,7 +50,7 @@ public final class AndroidEventBuffer {
      * @param perContextSummarization true to emit one summary per context rather than one overall
      * @param logger the logger to warn on when capacity is exceeded
      */
-    public AndroidEventBuffer(
+    AndroidEventBuffer(
             int capacity,
             boolean allAttributesPrivate,
             Collection<AttributeRef> privateAttributes,
@@ -81,7 +78,7 @@ public AndroidEventBuffer(
      *
      * @param event the evaluation
      */
-    public synchronized void summarize(Event.FeatureRequest event) {
+    synchronized void summarize(Event.FeatureRequest event) {
         summarizer.summarizeEvent(
                 event.getCreationDate(),
                 event.getKey(),
@@ -98,7 +95,7 @@ public synchronized void summarize(Event.FeatureRequest event) {
      *
      * @param event the event
      */
-    public synchronized void addFullEvent(Event event) {
+    synchronized void addFullEvent(Event event) {
         if (!Sampler.shouldSample(event.getSamplingRatio())) {
             return;
         }
@@ -117,14 +114,14 @@ public synchronized void addFullEvent(Event event) {
     /**
      * @return true if there is nothing buffered and no summary counters
      */
-    public synchronized boolean isEmpty() {
+    synchronized boolean isEmpty() {
         return events.isEmpty() && summarizer.isEmpty();
     }
 
     /**
      * @return the number of full events dropped for capacity since this was last called
      */
-    public synchronized long getAndClearDroppedCount() {
+    synchronized long getAndClearDroppedCount() {
         long result = droppedEventCount;
         droppedEventCount = 0;
         return result;
@@ -136,7 +133,7 @@ public synchronized long getAndClearDroppedCount() {
      * @return the payload to send, or null if there was nothing to send
      * @throws IOException if the events could not be serialized
      */
-    public synchronized Payload drain() throws IOException {
+    synchronized Payload drain() throws IOException {
         if (events.isEmpty() && summarizer.isEmpty()) {
             return null;
         }
@@ -160,10 +157,8 @@ public synchronized Payload drain() throws IOException {
 
     /**
      * A serialized batch of analytics events.
-     *
-     * @hidden
      */
-    public static final class Payload {
+    static final class Payload {
         private final byte[] data;
         private final int eventCount;
 
@@ -175,14 +170,14 @@ public static final class Payload {
         /**
          * @return the JSON request body
          */
-        public byte[] getData() {
+        byte[] getData() {
             return data;
         }
 
         /**
          * @return how many events the body represents, including summaries
          */
-        public int getEventCount() {
+        int getEventCount() {
             return eventCount;
         }
     }
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
index ee9f9a94..fcf52e04 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
@@ -6,7 +6,6 @@
 import com.launchdarkly.sdk.LDContext;
 import com.launchdarkly.sdk.LDValue;
 import com.launchdarkly.sdk.android.subsystems.EventProcessor;
-import com.launchdarkly.sdk.internal.events.AndroidEventBuffer;
 import com.launchdarkly.sdk.internal.events.DiagnosticEvent;
 import com.launchdarkly.sdk.internal.events.DiagnosticStore;
 import com.launchdarkly.sdk.internal.events.Event;
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 62ea8156..d124d46d 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,7 +20,6 @@
 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.AndroidEventBuffer;
 import com.launchdarkly.sdk.internal.events.DefaultEventSender;
 import com.launchdarkly.sdk.internal.events.EventSender;
 
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
index c7439685..0743438b 100644
--- 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
@@ -19,7 +19,7 @@
  * 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 com.launchdarkly.sdk.internal.events.AndroidEventBuffer}. These
+ * context formatter through {@link AndroidEventBuffer}. 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

From bf9466b461e15986dc786fb02f1fad70608aebbd Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 15 Sep 2026 09:54:14 -0700
Subject: [PATCH 04/10] build: use java-sdk-internal 1.12.0

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 launchdarkly-android-client-sdk/build.gradle |  2 +-
 settings.gradle                              | 25 --------------------
 shared-test-code/build.gradle                |  2 +-
 3 files changed, 2 insertions(+), 27 deletions(-)

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/settings.gradle b/settings.gradle
index 2ac14b5a..36c077f5 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,28 +1,3 @@
-// TEMPORARY: builds java-sdk-internal from a working copy instead of the published artifact.
-//
-// The event durability work needs event serialization classes that are package-private in
-// java-sdk-internal, and the PR making them public is not released yet. Until a release carries
-// it, this points the build at a local checkout so the two can be developed together.
-//
-// Revert this block and bump `launchdarklyJavaSdkInternal` in
-// launchdarkly-android-client-sdk/build.gradle once the release is out.
-//
-// Set `ldJavaSdkInternalDir` in ~/.gradle/gradle.properties or on the command line to override the
-// default location; skipped entirely if the directory is not there, so a clean checkout still builds
-// against the published artifact.
-def javaSdkInternalDir = providers.gradleProperty("ldJavaSdkInternalDir")
-        .map { new File(it) }
-        .getOrElse(new File(rootDir, "../java-core/lib/shared/internal"))
-if (javaSdkInternalDir.directory) {
-    includeBuild(javaSdkInternalDir) {
-        dependencySubstitution {
-            substitute module("com.launchdarkly:launchdarkly-java-sdk-internal") using project(":")
-        }
-    }
-} else {
-    logger.lifecycle("Local java-sdk-internal not found at ${javaSdkInternalDir}; using the published artifact")
-}
-
 include(":launchdarkly-android-client-sdk")
 include(":shared-test-code")
 include(":example")
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",
 ]
 

From 9201bfaeeb6b0fc4a9bf476f9ad27af4d14ca6e6 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 15 Sep 2026 12:51:33 -0700
Subject: [PATCH 05/10] fix(events): do not send diagnostics while offline or
 backgrounded

Diagnostics are meant to be off in both states, and updateScheduledTasks cancels
the periodic task accordingly, but two paths could still reach the sender after
the state had changed. Cancelling does not stop a run that has already begun, and
the init event is submitted to the executor while still online, so going offline
or backgrounding between submission and execution left it to send anyway.

Both paths now re-check on the way out, via a predicate that mirrors the
scheduling condition so the two cannot drift. The check in sendDiagnosticStats
sits ahead of createEventAndReset, which clears the counters it returns, so a
suspended period defers its statistics rather than discarding them.

Analytics delivery is unchanged: deliverPayload already skips while offline, and
it deliberately keeps running in the background so events recorded before the app
was backgrounded still get out.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../sdk/android/AndroidEventProcessor.java       | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
index fcf52e04..952e3560 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
@@ -232,7 +232,7 @@ private void deliverPayload() {
     }
 
     private void sendDiagnosticEvent(DiagnosticEvent diagnosticEvent, boolean isInit) {
-        if (disabled.get()) {
+        if (diagnosticsSuspended()) {
             return;
         }
         try {
@@ -248,13 +248,25 @@ private void sendDiagnosticEvent(DiagnosticEvent diagnosticEvent, boolean isInit
     }
 
     private void sendDiagnosticStats() {
-        if (disabled.get() || diagnosticStore == null) {
+        // 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.
+     * {@link #updateScheduledTasks} cancels the periodic task when either becomes true, but
+     * cancelling does not stop a run that has already begun, and the init event is submitted before
+     * it reaches the executor, so both paths can still arrive here after the state has changed.
+     */
+    private boolean diagnosticsSuspended() {
+        return isStopped() || offline.get() || inBackground.get();
+    }
+
     private void handleResponse(EventSender.Result result) {
         if (result == null) {
             return;

From 66a92da282cb24b49cf1445d93813043be1e7301 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 15 Sep 2026 12:52:39 -0700
Subject: [PATCH 06/10] refactor(events): rename AndroidEventProcessor and
 AndroidEventBuffer

The Android prefix in this package is reserved for adapters over Android OS APIs
- AndroidPlatformState, AndroidTaskExecutor, AndroidEnvironmentReporter. Neither
of these touches an Android API, so the prefix put them in the wrong category
while also repeating what the repository and package already say.

  AndroidEventProcessor -> DirectEventProcessor
  AndroidEventBuffer    -> OutboundEventBuffer

DirectEventProcessor names what sets it apart from java-sdk-internal's
DefaultEventProcessor: nothing sits between the caller and the summarizer.
OutboundEventBuffer says which direction the events are going, which matters
once tier 3 adds a store to read them back from.

DefaultEventProcessor was avoided as a name because java-sdk-internal already
exports that simple name and this package imports from it.

Rename only, including the test class. No behavior change.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../com/launchdarkly/sdk/android/ComponentsImpl.java   |  4 ++--
 ...idEventProcessor.java => DirectEventProcessor.java} | 10 +++++-----
 ...ndroidEventBuffer.java => OutboundEventBuffer.java} |  8 ++++----
 ...rocessorTest.java => DirectEventProcessorTest.java} |  2 +-
 .../sdk/android/EventProcessorPrivacyTest.java         |  2 +-
 5 files changed, 13 insertions(+), 13 deletions(-)
 rename launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/{AndroidEventProcessor.java => DirectEventProcessor.java} (98%)
 rename launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/{AndroidEventBuffer.java => OutboundEventBuffer.java} (96%)
 rename launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/{AndroidEventProcessorTest.java => DirectEventProcessorTest.java} (99%)

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 d124d46d..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
@@ -105,8 +105,8 @@ public EventProcessor build(ClientContext clientContext) {
                     0L, // use default retry delay
                     false, // disable gzip compression for Android
                     clientContext.getBaseLogger());
-            return new AndroidEventProcessor(
-                    new AndroidEventBuffer(
+            return new DirectEventProcessor(
+                    new OutboundEventBuffer(
                             capacity,
                             allAttributesPrivate,
                             privateAttributes,
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java
similarity index 98%
rename from launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
rename to launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java
index 952e3560..73c9685c 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventProcessor.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/DirectEventProcessor.java
@@ -30,8 +30,8 @@
  * 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 AndroidEventProcessor implements EventProcessor {
-    private final AndroidEventBuffer buffer;
+final class DirectEventProcessor implements EventProcessor {
+    private final OutboundEventBuffer buffer;
     private final EventSender eventSender;
     private final URI eventsUri;
     private final DiagnosticStore diagnosticStore;
@@ -52,8 +52,8 @@ final class AndroidEventProcessor implements EventProcessor {
     private ScheduledFuture<?> flushTask;
     private ScheduledFuture<?> diagnosticTask;
 
-    AndroidEventProcessor(
-            AndroidEventBuffer buffer,
+    DirectEventProcessor(
+            OutboundEventBuffer buffer,
             EventSender eventSender,
             URI eventsUri,
             DiagnosticStore diagnosticStore,
@@ -210,7 +210,7 @@ private void deliverPayload() {
         if (disabled.get() || offline.get()) {
             return;
         }
-        AndroidEventBuffer.Payload payload;
+        OutboundEventBuffer.Payload payload;
         try {
             payload = buffer.drain();
         } catch (IOException e) {
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java
similarity index 96%
rename from launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
rename to launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java
index 9b35017d..02e474d8 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/AndroidEventBuffer.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/OutboundEventBuffer.java
@@ -22,7 +22,7 @@
 import java.util.List;
 
 /**
- * The buffer behind the Android SDK's event processor: evaluations are folded into summary
+ * 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>
@@ -32,7 +32,7 @@
  * events and summarizes them itself, on the far side of the bounded queue this is meant to get in
  * front of.
  */
-final class AndroidEventBuffer {
+final class OutboundEventBuffer {
     private static final int INITIAL_OUTPUT_BUFFER_SIZE = 2000;
 
     private final EventOutputFormatter formatter;
@@ -50,7 +50,7 @@ final class AndroidEventBuffer {
      * @param perContextSummarization true to emit one summary per context rather than one overall
      * @param logger the logger to warn on when capacity is exceeded
      */
-    AndroidEventBuffer(
+    OutboundEventBuffer(
             int capacity,
             boolean allAttributesPrivate,
             Collection<AttributeRef> privateAttributes,
@@ -58,7 +58,7 @@ final class AndroidEventBuffer {
             LDLogger logger
     ) {
         // Only the private-attribute settings affect the output; the rest of EventsConfiguration
-        // describes the delivery behavior that the Android event processor now handles itself.
+        // 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);
diff --git a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java
similarity index 99%
rename from launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java
rename to launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java
index 761af50c..11d2b962 100644
--- a/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/AndroidEventProcessorTest.java
+++ b/launchdarkly-android-client-sdk/src/test/java/com/launchdarkly/sdk/android/DirectEventProcessorTest.java
@@ -17,7 +17,7 @@
  * 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 AndroidEventProcessorTest extends EventProcessorTestBase {
+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;
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
index 0743438b..5ff0bcba 100644
--- 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
@@ -19,7 +19,7 @@
  * 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 AndroidEventBuffer}. These
+ * 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

From 0fb38cb434cf6d9539ef1dd28c29d68fa4223197 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Thu, 17 Sep 2026 16:18:55 -0700
Subject: [PATCH 07/10] chore(events): clear lint warnings on the event
 processor and buffer

- drop OutboundEventBuffer.isEmpty, which nothing calls
- StandardCharsets.UTF_8 in place of Charset.forName("UTF-8")
- scheduleWithFixedDelay, so a cached process does not come back owing every missed run
- split an over-long Javadoc sentence

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../sdk/android/DirectEventProcessor.java        | 16 ++++++++++------
 .../sdk/android/OutboundEventBuffer.java         | 11 ++---------
 2 files changed, 12 insertions(+), 15 deletions(-)

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
index 73c9685c..7987894f 100644
--- 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
@@ -13,7 +13,7 @@
 
 import java.io.IOException;
 import java.net.URI;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
@@ -237,7 +237,7 @@ private void sendDiagnosticEvent(DiagnosticEvent diagnosticEvent, boolean isInit
         }
         try {
             byte[] data = diagnosticEvent.getJsonValue().toJsonString()
-                    .getBytes(Charset.forName("UTF-8"));
+                    .getBytes(StandardCharsets.UTF_8);
             handleResponse(eventSender.sendDiagnosticEvent(data, eventsUri));
             if (isInit) {
                 diagnosticInitSent.set(true);
@@ -259,9 +259,10 @@ private void sendDiagnosticStats() {
 
     /**
      * Unlike analytics events, diagnostics are not sent while offline or in the background.
-     * {@link #updateScheduledTasks} cancels the periodic task when either becomes true, but
-     * cancelling does not stop a run that has already begun, and the init event is submitted before
-     * it reaches the executor, so both paths can still arrive here after the state has changed.
+     * <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();
@@ -331,7 +332,10 @@ private ScheduledFuture<?> enableOrDisableTask(
             return currentTask;
         }
         try {
-            return scheduler.scheduleAtFixedRate(guarded(task), intervalMillis, intervalMillis,
+            // 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;
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
index 02e474d8..c6d68ee5 100644
--- 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
@@ -16,7 +16,7 @@
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -111,13 +111,6 @@ synchronized void addFullEvent(Event event) {
         events.add(event);
     }
 
-    /**
-     * @return true if there is nothing buffered and no summary counters
-     */
-    synchronized boolean isEmpty() {
-        return events.isEmpty() && summarizer.isEmpty();
-    }
-
     /**
      * @return the number of full events dropped for capacity since this was last called
      */
@@ -142,7 +135,7 @@ synchronized Payload drain() throws IOException {
 
         ByteArrayOutputStream buffer = new ByteArrayOutputStream(INITIAL_OUTPUT_BUFFER_SIZE);
         Writer writer = new BufferedWriter(
-                new OutputStreamWriter(buffer, Charset.forName("UTF-8")), INITIAL_OUTPUT_BUFFER_SIZE);
+                new OutputStreamWriter(buffer, StandardCharsets.UTF_8), INITIAL_OUTPUT_BUFFER_SIZE);
         int outputEventCount;
         try {
             outputEventCount = formatter.writeOutputEvents(eventsOut, summaries, writer);

From 80f3083d18f4d5108d1024e2231f634096f3fad6 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Thu, 17 Sep 2026 17:13:15 -0700
Subject: [PATCH 08/10] fix warning

(cherry picked from commit 123cb81d6d39bd47b8f47706ba48b47a083fbe98)
---
 .../launchdarkly/example/MainActivity.java    | 22 ++++++++-----------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/example/src/main/java/com/launchdarkly/example/MainActivity.java b/example/src/main/java/com/launchdarkly/example/MainActivity.java
index e7deb6ca..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;
@@ -143,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() {

From 14349d529482eec0b022f665d590589c5e1e267f Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Fri, 18 Sep 2026 15:55:05 -0700
Subject: [PATCH 09/10] docs(events): record that a failed diagnostic init is
 not retried

Bugbot flagged that diagnosticInitSent is set without consulting the
Result. That is deliberate: DefaultEventProcessor does the same, and a
failed post returns an unsuccessful Result rather than throwing, so the
flag flips either way. Note it at the assignment so the next reader does
not read it as an oversight.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../com/launchdarkly/sdk/android/DirectEventProcessor.java   | 5 +++++
 1 file changed, 5 insertions(+)

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
index 7987894f..e261acb1 100644
--- 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
@@ -240,6 +240,11 @@ private void sendDiagnosticEvent(DiagnosticEvent diagnosticEvent, boolean isInit
                     .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) {

From 6d77bdef9cb543dbec75c350621c13e5d5c502c1 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Fri, 18 Sep 2026 16:01:25 -0700
Subject: [PATCH 10/10] fix(events): deliver buffered events when connectivity
 returns

Going offline cancels the periodic flush, so coming back online started a
fresh interval and left whatever the outage buffered waiting for it. Each
drop re-anchored that interval, so repeated brief losses could defer
delivery well past a single one.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../sdk/android/DirectEventProcessor.java     |  7 ++++++
 .../sdk/android/DirectEventProcessorTest.java | 23 +++++++++++++++++++
 2 files changed, 30 insertions(+)

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
index e261acb1..d0bad056 100644
--- 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
@@ -147,6 +147,13 @@ public void setOffline(boolean 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);
+            }
         }
     }
 
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
index 11d2b962..e463e76b 100644
--- 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
@@ -154,6 +154,29 @@ public void eventsRecordedWhileOfflineAreRetainedAndSentOnceOnline() throws Exce
         }
     }
 
+    @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()) {