From 0c98c92e73a07afa307ee056299e4a1605351c15 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Thu, 3 Sep 2026 20:41:28 -0700
Subject: [PATCH 1/2] feat(events): add a bounded flush (tier 2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Tier 2 of the event durability spec: recoverable failure.

flushAndWait(timeout) delivers what has been recorded and reports whether it got
there inside the budget, so an application that knows it is about to go away —
backgrounding, or an uncaught exception handler on its way out — gets an answer
instead of a fire-and-forget flush. Delivery now reports its outcome so the
bounded call can tell delivered from not.

Spec: Event Durability, "Tier 2 — recoverable failure", §10.
Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../launchdarkly/example/MainActivity.java    | 91 +++++++++++++++++--
 example/src/main/res/layout/activity_main.xml | 34 ++++++-
 .../sdk/android/AndroidEventProcessor.java    | 54 ++++++++++-
 .../launchdarkly/sdk/android/LDClient.java    | 17 ++++
 .../sdk/android/LDClientInterface.java        | 22 +++++
 .../android/subsystems/EventProcessor.java    | 18 ++++
 .../android/AndroidEventProcessorTest.java    | 73 +++++++++++++++
 7 files changed, 290 insertions(+), 19 deletions(-)

diff --git a/example/src/main/java/com/launchdarkly/example/MainActivity.java b/example/src/main/java/com/launchdarkly/example/MainActivity.java
index e7deb6caf..990d5f4a0 100644
--- a/example/src/main/java/com/launchdarkly/example/MainActivity.java
+++ b/example/src/main/java/com/launchdarkly/example/MainActivity.java
@@ -103,7 +103,12 @@ public void onCreate(Bundle savedInstanceState) {
         setupTrackButton();
         setupIdentifyButton();
         setupKillUnsentButton();
+        setupKillNowButton();
+        setupCrashNowButton();
         setupOfflineSwitch();
+        // Rescues the events for "Eval+Crash now" and cannot run for "Eval+Kill now", which is what
+        // makes the pair worth pressing.
+        FlushOnCrashHandler.install();
         setupListeners();
         updateDedupeStatus();
 
@@ -216,6 +221,31 @@ private void setupTrackButton() {
         });
     }
 
+    /**
+     * The flag the kill and crash buttons evaluate: whatever is typed in the feature key field, or a
+     * default, so the buttons work without anything being typed first.
+     */
+    private String flagKeyToKillOver() {
+        String typedKey = ((EditText) findViewById(R.id.feature_flag_key)).getText().toString().trim();
+        return typedKey.isEmpty() ? "kill-flag" : typedKey;
+    }
+
+    /**
+     * Records the pair whose survival is in question: an evaluation, which is the exposure, and a
+     * track, standing in for the error an application reports just before it dies.
+     *
+     * <p>Returns false when there is no client, in which case nothing was recorded and ending the
+     * process would demonstrate nothing.
+     */
+    private boolean recordExposureAndError(String flagKey) {
+        if (ldClient == null) {
+            return false;
+        }
+        ldClient.boolVariation(flagKey, false);
+        ldClient.track("$ld:telemetry:error");
+        return true;
+    }
+
     /**
      * 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.
@@ -225,17 +255,58 @@ private void setupTrackButton() {
     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;
+            final String flagKey = flagKeyToKillOver();
             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);
-            });
+            if (!recordExposureAndError(flagKey)) {
+                return;
+            }
+            ldClient.flush();
+            new Handler(Looper.getMainLooper()).postDelayed(
+                    () -> android.os.Process.killProcess(android.os.Process.myPid()),
+                    5_000);
+        });
+    }
+
+    /**
+     * The same sequence with nothing at all between the track and the process dying: no flush to
+     * deliver the events, no delay for a timer to fire in, and SIGKILL to itself, which cannot be
+     * caught, so no part of the SDK gets to run on the way out.
+     *
+     * <p>Whether the exposure and the track are reported therefore says exactly one thing: whether
+     * recording them had already put them somewhere that outlives the process. They should arrive on
+     * the next launch of the app, not this one.
+     */
+    private void setupKillNowButton() {
+        Button killNowButton = findViewById(R.id.kill_now_button);
+        killNowButton.setOnClickListener(v -> {
+            final String flagKey = flagKeyToKillOver();
+            Timber.w("eval+track+kill now flag=%s", flagKey);
+            if (!recordExposureAndError(flagKey)) {
+                return;
+            }
+            android.os.Process.killProcess(android.os.Process.myPid());
+        });
+    }
+
+    /**
+     * The same again, ending in an uncaught exception instead of a signal the process never sees.
+     *
+     * <p>This is the shape a customer report takes: app code fails immediately after reporting the
+     * failure. Unlike SIGKILL, an uncaught exception runs the default handler before the process
+     * goes, so this is the one variant an application can rescue on its own, which
+     * {@link FlushOnCrashHandler} does by calling {@link LDClient#flushAndWait} from there. So these
+     * events should arrive and the ones from the button next to it should not.
+     */
+    private void setupCrashNowButton() {
+        Button crashNowButton = findViewById(R.id.crash_now_button);
+        crashNowButton.setOnClickListener(v -> {
+            final String flagKey = flagKeyToKillOver();
+            Timber.w("eval+track+crash now flag=%s", flagKey);
+            if (!recordExposureAndError(flagKey)) {
+                return;
+            }
+            throw new RuntimeException(
+                    "Eval+Crash: deliberate uncaught exception immediately after track, to test event persistence");
         });
     }
 
diff --git a/example/src/main/res/layout/activity_main.xml b/example/src/main/res/layout/activity_main.xml
index 06c5edb9f..412058b0f 100644
--- a/example/src/main/res/layout/activity_main.xml
+++ b/example/src/main/res/layout/activity_main.xml
@@ -114,8 +114,12 @@
         android:layout_alignParentRight="true"
         android:minLines="4" />
 
-    <Button
-        android:id="@+id/kill_unsent_button"
+    <!--
+        Three ways of ending the process after an evaluation and a track, differing only in how much
+        of the SDK gets to run on the way out. See MainActivity for what each one tells you.
+    -->
+    <LinearLayout
+        android:id="@+id/kill_row"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_above="@id/identify_button"
@@ -123,7 +127,29 @@
         android:layout_alignParentLeft="true"
         android:layout_alignParentEnd="true"
         android:layout_alignParentRight="true"
-        android:text="Eval+track+kill" />
+        android:orientation="horizontal">
+
+        <Button
+            android:id="@+id/kill_unsent_button"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="Eval+Kill 5s" />
+
+        <Button
+            android:id="@+id/kill_now_button"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="Eval+Kill now" />
+
+        <Button
+            android:id="@+id/crash_now_button"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="Eval+Crash now" />
+    </LinearLayout>
 
     <Space
         android:id="@+id/space"
@@ -139,7 +165,7 @@
         android:id="@+id/userKey_editText"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_above="@+id/kill_unsent_button"
+        android:layout_above="@+id/kill_row"
         android:layout_alignEnd="@+id/result_textView"
         android:layout_alignRight="@+id/result_textView"
         android:layout_toEndOf="@+id/textView2"
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 ee9f9a94d..3af214035 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
@@ -15,11 +15,13 @@
 import java.io.IOException;
 import java.net.URI;
 import java.nio.charset.Charset;
+import java.util.concurrent.Callable;
 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.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -177,6 +179,34 @@ public void blockingFlush() {
         }
     }
 
+    @Override
+    public boolean blockingFlush(long timeout, TimeUnit unit) {
+        if (isStopped()) {
+            return false;
+        }
+        // Typed rather than inlined, so that it is unambiguously submitted as work with a result.
+        Callable<Boolean> delivery = this::deliverPayloadReportingOutcome;
+        Future<Boolean> pending;
+        try {
+            pending = scheduler.submit(delivery);
+        } catch (RuntimeException e) { // the executor was shut down under us
+            return false;
+        }
+        try {
+            return Boolean.TRUE.equals(pending.get(timeout, unit));
+        } catch (TimeoutException e) {
+            // Left running rather than cancelled: the buffer has already been drained into the
+            // payload, so interrupting the delivery now would only make the loss certain.
+            return false;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return false;
+        } catch (ExecutionException e) {
+            logUnexpectedError(e.getCause() == null ? e : e.getCause());
+            return false;
+        }
+    }
+
     @Override
     public void close() throws IOException {
         if (!closed.compareAndSet(false, true)) {
@@ -208,27 +238,41 @@ public void close() throws IOException {
      * is ever in flight and the buffer is drained exactly once per delivery.
      */
     private void deliverPayload() {
+        deliverPayloadReportingOutcome();
+    }
+
+    /**
+     * Delivers as {@link #deliverPayload()} does, and says whether it worked, for a caller that is
+     * waiting to find out.
+     *
+     * @return true if the events reached the service, or if there were none to send; false if they
+     *   could not be sent or the service did not accept them
+     */
+    private boolean deliverPayloadReportingOutcome() {
         if (disabled.get() || offline.get()) {
-            return;
+            return false;
         }
         AndroidEventBuffer.Payload payload;
         try {
             payload = buffer.drain();
         } catch (IOException e) {
             logUnexpectedError(e);
-            return;
+            return false;
         }
         if (payload == null) {
-            return;
+            return true;
         }
         if (diagnosticStore != null) {
             diagnosticStore.recordEventsInBatch(payload.getEventCount());
         }
         try {
-            handleResponse(eventSender.sendAnalyticsEvents(payload.getData(),
-                    payload.getEventCount(), eventsUri));
+            EventSender.Result result = eventSender.sendAnalyticsEvents(payload.getData(),
+                    payload.getEventCount(), eventsUri);
+            handleResponse(result);
+            return result != null && result.isSuccess();
         } catch (Exception e) {
             logUnexpectedError(e);
+            return false;
         }
     }
 
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
index f224668a1..f05968f25 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
@@ -779,6 +779,23 @@ private void flushInternal() {
         eventProcessor.flush();
     }
 
+    @Override
+    public boolean flushAndWait(long timeout, TimeUnit unit) {
+        long deadline = System.nanoTime() + unit.toNanos(timeout);
+        boolean delivered = true;
+        for (LDClient client : getInstancesIfTheyIncludeThisClient().values()) {
+            // Each environment gets what is left of the one budget rather than a fresh copy of it,
+            // so that the timeout the caller asked for is the time this call can take.
+            long remaining = Math.max(0, deadline - System.nanoTime());
+            delivered &= client.flushAndWaitInternal(remaining, TimeUnit.NANOSECONDS);
+        }
+        return delivered;
+    }
+
+    private boolean flushAndWaitInternal(long timeout, TimeUnit unit) {
+        return eventProcessor.blockingFlush(timeout, unit);
+    }
+
     @VisibleForTesting
     void blockingFlush() {
         eventProcessor.blockingFlush();
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClientInterface.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClientInterface.java
index dd62ec5c9..81bc53730 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClientInterface.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClientInterface.java
@@ -11,6 +11,7 @@
 import java.io.Closeable;
 import java.util.Map;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 /**
  * The interface for the LaunchDarkly SDK client.
@@ -146,6 +147,27 @@ public interface LDClientInterface extends Closeable {
      */
     void flush();
 
+    /**
+     * Sends all pending events to LaunchDarkly and waits for them to be delivered.
+     * <p>
+     * Unlike {@link #flush()}, which returns before the events reach the network, this reports
+     * whether they arrived, which is what makes it usable at a point where the application is about
+     * to lose the ability to send them: an uncaught exception handler, a move to the background, or
+     * any other last chance. Events buffered in memory do not survive the process, so a caller that
+     * knows the process is ending can use this to give them one.
+     * <p>
+     * The timeout bounds the whole call, including when the SDK is configured for more than one
+     * environment. Choose it with the caller in mind: a dying process is not a good place to wait on
+     * a network request that may never answer.
+     *
+     * @param timeout how long to wait for delivery
+     * @param unit the time unit of {@code timeout}
+     * @return true if the events were delivered, or there were none to deliver; false if the timeout
+     *   expired first, or the SDK is offline, closed, or otherwise unable to deliver them
+     * @since 5.17.0
+     */
+    boolean flushAndWait(long timeout, TimeUnit unit);
+
     /**
      * Returns a map of all feature flags for the current evaluation context. No events are sent to LaunchDarkly.
      *
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/subsystems/EventProcessor.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/subsystems/EventProcessor.java
index d1c98af02..7621f4c60 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/subsystems/EventProcessor.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/subsystems/EventProcessor.java
@@ -6,6 +6,7 @@
 import com.launchdarkly.sdk.LDValue;
 
 import java.io.Closeable;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Interface for an object that can send or store analytics events.
@@ -98,4 +99,21 @@ void recordCustomEvent(
      * Specifies that any buffered events should be sent immediately, blocking until done.
      */
     void blockingFlush();
+
+    /**
+     * Specifies that any buffered events should be sent immediately, blocking until they have been
+     * delivered or until the timeout expires, whichever comes first.
+     *
+     * @param timeout how long to wait for delivery
+     * @param unit the time unit of {@code timeout}
+     * @return true if the events were delivered, or there were none to deliver; false if the
+     *   timeout expired first or the events could not be delivered
+     * @since 5.17.0
+     */
+    default boolean blockingFlush(long timeout, TimeUnit unit) {
+        // An implementation written before this method existed has no way to honor a timeout, so it
+        // gets its unbounded flush and reports success, having no way to tell otherwise.
+        blockingFlush();
+        return true;
+    }
 }
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
index 761af50cb..825e166a8 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/AndroidEventProcessorTest.java
@@ -1,16 +1,20 @@
 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.EvaluationReason;
 import com.launchdarkly.sdk.LDValue;
 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.Test;
 
 import java.util.List;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -244,6 +248,75 @@ public void diagnosticInitEventIsNotSentWhileOffline() throws Exception {
         }
     }
 
+    @Test
+    public void flushWithTimeoutReportsDeliveredEvents() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+
+                assertTrue(eventProcessor.blockingFlush(10, TimeUnit.SECONDS));
+
+                assertEquals(1, countEventsOfKind(collectDelivered(server), "custom"));
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void flushWithTimeoutReportsSuccessWhenThereIsNothingToSend() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                // Nothing was recorded, so the caller's events are not waiting anywhere.
+                assertTrue(eventProcessor.blockingFlush(10, TimeUnit.SECONDS));
+
+                server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void flushWithTimeoutReportsFailureWhileOffline() throws Exception {
+        try (HttpServer server = startEventsServer()) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.setOffline(true);
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+
+                // The events are still buffered rather than delivered, and no amount of waiting
+                // changes that, so the caller is told so instead of being told they are safe.
+                assertFalse(eventProcessor.blockingFlush(10, TimeUnit.SECONDS));
+
+                server.getRecorder().requireNoRequests(100, TimeUnit.MILLISECONDS);
+            } finally {
+                eventProcessor.close();
+            }
+        }
+    }
+
+    @Test
+    public void flushWithTimeoutReportsFailureWhenTheTimeoutExpiresFirst() throws Exception {
+        Semaphore letResponseFinish = new Semaphore(0);
+        try (HttpServer server = HttpServer.start(Handlers.all(Handlers.waitFor(letResponseFinish),
+                Handlers.status(202)))) {
+            EventProcessor eventProcessor = makeEventProcessor(server, DEFAULT_CAPACITY);
+            try {
+                eventProcessor.recordCustomEvent(CONTEXT, "an-event", LDValue.ofNull(), null);
+
+                assertFalse(eventProcessor.blockingFlush(100, TimeUnit.MILLISECONDS));
+            } finally {
+                // Released before closing, so that the delivery still in flight can finish rather
+                // than hold up the shutdown that close() waits on.
+                letResponseFinish.release(Integer.MAX_VALUE);
+                eventProcessor.close();
+            }
+        }
+    }
+
     private void recordEvaluation(EventProcessor eventProcessor, boolean requireFullEvent,
                                   Long debugEventsUntilDate) {
         eventProcessor.recordEvaluationEvent(CONTEXT, FLAG_KEY, FLAG_VERSION, VARIATION, FLAG_VALUE,

From e1136941857aaff6c0ccec0d83e187b31de91377 Mon Sep 17 00:00:00 2001
From: Andrey Belonogov <abelonogov@launchdarkly.com>
Date: Tue, 22 Sep 2026 21:21:13 -0700
Subject: [PATCH 2/2] Report a failed flushAndWait from a closed client

flushAndWait started from delivered = true and only updated it for the
environments this client still belongs to. After close() that set is
empty, so the call reported success for events it could not deliver.
It now returns false when the client has been closed or replaced.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../sdk/android/LDClientEventTest.java        | 31 +++++++++++++++++++
 .../launchdarkly/sdk/android/LDClient.java    |  8 ++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/sdk/android/LDClientEventTest.java b/launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/sdk/android/LDClientEventTest.java
index 544c416bd..3590f9c33 100644
--- a/launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/sdk/android/LDClientEventTest.java
+++ b/launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/sdk/android/LDClientEventTest.java
@@ -26,6 +26,7 @@
 import org.junit.Test;
 
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 
 import okhttp3.HttpUrl;
 import okhttp3.mockwebserver.MockResponse;
@@ -95,6 +96,36 @@ public void testTrackData() throws IOException, InterruptedException {
         }
     }
 
+    @Test
+    public void flushAndWaitReportsDelivery() throws IOException, InterruptedException {
+        try (MockWebServer mockEventsServer = new MockWebServer()) {
+            mockEventsServer.start();
+            mockEventsServer.enqueue(new MockResponse());
+
+            LDConfig ldConfig = baseConfigBuilder(mockEventsServer).build();
+            try (LDClient client = LDClient.init(application, ldConfig, ldContext, 0)) {
+                client.track("test-event");
+
+                assertTrue(client.flushAndWait(5, TimeUnit.SECONDS));
+                LDValue[] events = getEventsFromLastRequest(mockEventsServer, 2);
+                assertCustomEvent(events[1], ldContext, "test-event");
+            }
+        }
+    }
+
+    @Test
+    public void flushAndWaitReportsFailureOnceClosed() throws IOException {
+        try (MockWebServer mockEventsServer = new MockWebServer()) {
+            mockEventsServer.start();
+
+            LDConfig ldConfig = baseConfigBuilder(mockEventsServer).build();
+            LDClient client = LDClient.init(application, ldConfig, ldContext, 0);
+            client.close();
+
+            assertFalse(client.flushAndWait(5, TimeUnit.SECONDS));
+        }
+    }
+
     @Test
     public void testTrackDataValueNull() throws IOException, InterruptedException {
         try (MockWebServer mockEventsServer = new MockWebServer()) {
diff --git a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
index f05968f25..8eb539a04 100644
--- a/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
+++ b/launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/sdk/android/LDClient.java
@@ -782,8 +782,14 @@ private void flushInternal() {
     @Override
     public boolean flushAndWait(long timeout, TimeUnit unit) {
         long deadline = System.nanoTime() + unit.toNanos(timeout);
+        Map<String, LDClient> clients = getInstancesIfTheyIncludeThisClient();
+        if (clients.isEmpty()) {
+            // This client has been closed, or replaced by a later init; either way it can deliver
+            // nothing, and saying otherwise would tell the caller its events were safe.
+            return false;
+        }
         boolean delivered = true;
-        for (LDClient client : getInstancesIfTheyIncludeThisClient().values()) {
+        for (LDClient client : clients.values()) {
             // Each environment gets what is left of the one budget rather than a fresh copy of it,
             // so that the timeout the caller asked for is the time this call can take.
             long remaining = Math.max(0, deadline - System.nanoTime());