@react-native-firebase/crashlytics 27.0.0 → 27.1.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.1.0](https://github.com/invertase/react-native-firebase/compare/v27.0.0...v27.1.0) (2026-10-23)
+
+### Bug Fixes
+
+- **crashlytics, ios:** time out SPM upload-symbols so a stalled upload cannot hang the build ([1cdb7de](https://github.com/invertase/react-native-firebase/commit/1cdb7de24ef5ca12a24cf599cce11d3d8797cbb2))
+- **crashlytics:** reach Android Crashlytics internals by reflection only ([c3f15e3](https://github.com/invertase/react-native-firebase/commit/c3f15e37b1f53e0a81469183e896003ea6e80141))
+- **crashlytics:** save JS fatal report before exiting when chaining is disabled ([cfd00b6](https://github.com/invertase/react-native-firebase/commit/cfd00b65754186aad0f765f61a5db3f19e84b716))
+
 ## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
 
 ### ⚠ BREAKING CHANGES

package/android/build.gradle

@@ -68,6 +68,7 @@ android {
 
   defaultConfig {
     multiDexEnabled = true
+    consumerProguardFiles 'proguard-rules.pro'
   }
 
   buildFeatures {

package/android/proguard-rules.pro

@@ -0,0 +1,20 @@
+# Consumer R8/ProGuard rules for @react-native-firebase/crashlytics.
+#
+# io.invertase.firebase.crashlytics.ReactNativeFirebaseCrashlyticsInternal reaches these Crashlytics
+# SDK internals by reflection to wait for a JS fatal's event write before the process exits. Keep
+# this list in sync with the names there. A missing rule (or an SDK without these members) only
+# makes the barrier fail, which falls back to a bounded wait; it never crashes.
+-keepclassmembers class com.google.firebase.crashlytics.FirebaseCrashlytics {
+  com.google.firebase.crashlytics.internal.common.CrashlyticsCore core;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.common.CrashlyticsCore {
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers crashlyticsWorkers;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers {
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker common;
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker diskWrite;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker {
+  com.google.android.gms.tasks.Task submit(java.lang.Runnable);
+  com.google.android.gms.tasks.Task submitTask(java.util.concurrent.Callable);
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/NativeRNFBTurboCrashlytics.java

@@ -35,6 +35,9 @@ import java.util.Objects;
 
 public class NativeRNFBTurboCrashlytics extends NativeRNFBTurboCrashlyticsSpec {
   private static final String TAG = "Crashlytics";
+  // Process-wide so a second JS fatal during the bounded wait neither records nor exits again.
+  private static final ReactNativeFirebaseCrashlyticsFatalExit FATAL_EXIT =
+      ReactNativeFirebaseCrashlyticsFatalExit.create();
 
   public NativeRNFBTurboCrashlytics(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -83,10 +86,14 @@ public class NativeRNFBTurboCrashlytics extends NativeRNFBTurboCrashlyticsSpec {
   @Override
   public void crashWithStackPromise(ReadableMap jsErrorMap, Promise promise) {
     if (ReactNativeFirebaseCrashlyticsInitProvider.isCrashlyticsCollectionEnabled()) {
-      Exception e = recordJavaScriptError(jsErrorMap);
-      e.printStackTrace(System.err);
-      Log.e(TAG, "Crash logged. Terminating app.");
-      System.exit(0);
+      // Coverage exception: this branch ends the process, so neither JVM tests nor e2e can
+      // observe it. Keep it a thin delegate; barrier, timeout, fallback and the second-fatal guard
+      // live in ReactNativeFirebaseCrashlyticsFatalExit (unit-tested). The promise is
+      // intentionally never resolved: that keeps the JS global handler suspended (no chaining to
+      // the previous handler, no fall-through) until termination.
+      Log.e(TAG, "Logging crash and terminating app.");
+      FATAL_EXIT.recordThenTerminate(() -> recordJavaScriptError(jsErrorMap).printStackTrace());
+      return;
     } else {
       Log.i(TAG, "crashlytics collection is not enabled, not crashing.");
     }

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExit.java

@@ -0,0 +1,117 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Records a JS fatal, then terminates the process once the record has been written.
+ *
+ * <p>{@code FirebaseCrashlytics.recordException} writes asynchronously on SDK worker threads, so
+ * exiting right after it usually loses the event. This waits on a barrier that completes after the
+ * queued event write, bounded by {@link #TIMEOUT_MS}. On any barrier failure (SDK internals
+ * changed, timeout, interruption) it waits out the rest of the bound, then terminates anyway.
+ *
+ * <p>Must run on a background thread (the TurboModule's native-modules thread), never main.
+ */
+final class ReactNativeFirebaseCrashlyticsFatalExit {
+  static final long TIMEOUT_MS = 2000;
+
+  interface Barrier {
+    void await(long timeoutMs) throws Exception;
+  }
+
+  interface Sleeper {
+    void sleep(long millis) throws InterruptedException;
+  }
+
+  interface Clock {
+    long nowMillis();
+  }
+
+  final Barrier barrier;
+  final Sleeper sleeper;
+  final Clock clock;
+  final Runnable terminator;
+  final long timeoutMs;
+  private final AtomicBoolean exiting = new AtomicBoolean(false);
+
+  ReactNativeFirebaseCrashlyticsFatalExit(
+      Barrier barrier, Sleeper sleeper, Clock clock, Runnable terminator, long timeoutMs) {
+    this.barrier = barrier;
+    this.sleeper = sleeper;
+    this.clock = clock;
+    this.terminator = terminator;
+    this.timeoutMs = timeoutMs;
+  }
+
+  static ReactNativeFirebaseCrashlyticsFatalExit create() {
+    return new ReactNativeFirebaseCrashlyticsFatalExit(
+        timeoutMs ->
+            Tasks.await(
+                ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(
+                    FirebaseCrashlytics.getInstance()),
+                timeoutMs,
+                TimeUnit.MILLISECONDS),
+        Thread::sleep,
+        () -> TimeUnit.NANOSECONDS.toMillis(System.nanoTime()),
+        // Coverage exception: ends the process, so no test can run it.
+        () -> System.exit(0),
+        TIMEOUT_MS);
+  }
+
+  /**
+   * Runs {@code record}, waits (bounded) for it to be written, then terminates, even when {@code
+   * record} throws. Returns false without running {@code record} when an earlier call already
+   * started terminating.
+   */
+  boolean recordThenTerminate(Runnable record) {
+    if (!exiting.compareAndSet(false, true)) {
+      return false;
+    }
+    try {
+      record.run();
+    } catch (Throwable recordFailed) {
+      // The guard is already set, so terminate anyway rather than leave the app running with
+      // every later fatal ignored.
+      recordFailed.printStackTrace();
+    }
+    long deadline = clock.nowMillis() + timeoutMs;
+    try {
+      barrier.await(timeoutMs);
+    } catch (Throwable barrierUnavailable) {
+      waitUntil(deadline);
+    }
+    terminator.run();
+    return true;
+  }
+
+  private void waitUntil(long deadline) {
+    long remaining;
+    while ((remaining = deadline - clock.nowMillis()) > 0) {
+      try {
+        sleeper.sleep(remaining);
+      } catch (InterruptedException ignored) {
+        // Keep waiting out the bound; the process terminates right after.
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsInternal.java

@@ -0,0 +1,80 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+
+/**
+ * Reaches Firebase Crashlytics SDK internals that have no public API.
+ *
+ * <p>{@code recordException} queues its event on the {@code common} worker, which then queues the
+ * event write on the {@code diskWrite} worker. Both workers are serial, so a {@code common} task
+ * that itself queues a no-op on {@code diskWrite} completes only after every event write already
+ * queued by earlier {@code recordException} calls.
+ *
+ * <p>Apps can override the Firebase BoM, so every internal member is reached by reflection: an SDK
+ * without them still builds, and any mismatch throws at runtime. Callers must treat every failure
+ * as "barrier unavailable". The reflected members are kept by the package's consumer R8/ProGuard
+ * rules ({@code proguard-rules.pro}); keep both lists in sync.
+ */
+final class ReactNativeFirebaseCrashlyticsInternal {
+  static final String CORE_FIELD = "core";
+  static final String WORKERS_FIELD = "crashlyticsWorkers";
+  static final String COMMON_FIELD = "common";
+  static final String DISK_WRITE_FIELD = "diskWrite";
+  static final String SUBMIT_TASK_METHOD = "submitTask";
+  static final String SUBMIT_METHOD = "submit";
+
+  private ReactNativeFirebaseCrashlyticsInternal() {}
+
+  /** Returns a task that completes after all event writes already queued by the SDK. */
+  static Task<?> pendingEventWritesBarrier(FirebaseCrashlytics crashlytics)
+      throws ReflectiveOperationException {
+    return barrierOn(read(read(crashlytics, CORE_FIELD), WORKERS_FIELD));
+  }
+
+  /** {@code workers.common.submitTask(() -> workers.diskWrite.submit(() -> {}))}, reflectively. */
+  static Task<?> barrierOn(Object workers) throws ReflectiveOperationException {
+    Object common = read(workers, COMMON_FIELD);
+    Object diskWrite = read(workers, DISK_WRITE_FIELD);
+    Method submit = diskWrite.getClass().getMethod(SUBMIT_METHOD, Runnable.class);
+    Method submitTask = common.getClass().getMethod(SUBMIT_TASK_METHOD, Callable.class);
+    Runnable noop = () -> {};
+    Callable<Object> queueNoopOnDiskWrite = () -> submit.invoke(diskWrite, noop);
+    return (Task<?>) submitTask.invoke(common, queueNoopOnDiskWrite);
+  }
+
+  /** Reads field {@code name} declared on {@code owner}'s class or a superclass; never null. */
+  static Object read(Object owner, String name) throws ReflectiveOperationException {
+    for (Class<?> type = owner.getClass(); type != null; type = type.getSuperclass()) {
+      try {
+        Field field = type.getDeclaredField(name);
+        field.setAccessible(true);
+        return Objects.requireNonNull(field.get(owner), name);
+      } catch (NoSuchFieldException notDeclaredHere) {
+        // Keep looking up the hierarchy (e.g. a subclass of the SDK type).
+      }
+    }
+    throw new NoSuchFieldException(name);
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExitBarrierTest.java

@@ -0,0 +1,122 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsCore;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Covers the production barrier wired by {@link ReactNativeFirebaseCrashlyticsFatalExit#create()}
+ * against real Crashlytics workers. Robolectric for the SDK classes; AndroidTest-AD-1. The barrier
+ * runs on a pool thread (as on the native-modules thread in production), and {@code mockStatic} is
+ * thread-bound, so it is opened on that thread.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsFatalExitBarrierTest {
+  private final ExecutorService pool = Executors.newCachedThreadPool();
+
+  @After
+  public void tearDown() {
+    pool.shutdownNow();
+  }
+
+  @Test
+  public void productionBarrier_waitsForTheQueuedEventWrite() throws Exception {
+    CrashlyticsWorkers workers = new CrashlyticsWorkers(pool, pool);
+    FirebaseCrashlytics crashlytics =
+        ReactNativeFirebaseCrashlyticsInternalTest.crashlyticsWith(workers);
+    AtomicBoolean eventWritten = new AtomicBoolean(false);
+    workers.diskWrite.submit(
+        () -> {
+          try {
+            Thread.sleep(150);
+          } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+          }
+          eventWritten.set(true);
+        });
+
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        ReactNativeFirebaseCrashlyticsFatalExit.create();
+    pool.submit(
+            () -> {
+              try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+                  mockStatic(FirebaseCrashlytics.class)) {
+                firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+                fatalExit.barrier.await(fatalExit.timeoutMs);
+              }
+              return null;
+            })
+        .get(10, TimeUnit.SECONDS);
+
+    assertTrue(eventWritten.get());
+  }
+
+  /**
+   * When the barrier is unavailable (here: an unset {@code crashlyticsWorkers}), the production
+   * barrier fails and the fatal exit waits out the bound, then terminates.
+   */
+  @Test
+  public void productionBarrier_barrierUnavailable_fallsBackToTheBoundedWait() throws Exception {
+    FirebaseCrashlytics crashlytics =
+        ReactNativeFirebaseCrashlyticsInternalTest.crashlyticsWithCore(mock(CrashlyticsCore.class));
+    List<String> events = new ArrayList<>();
+    long[] now = {0};
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        new ReactNativeFirebaseCrashlyticsFatalExit(
+            ReactNativeFirebaseCrashlyticsFatalExit.create().barrier,
+            millis -> {
+              events.add("sleep:" + millis);
+              now[0] += millis;
+            },
+            () -> now[0],
+            () -> events.add("exit"),
+            ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS);
+
+    pool.submit(
+            () -> {
+              try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+                  mockStatic(FirebaseCrashlytics.class)) {
+                firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+                assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+              }
+              return null;
+            })
+        .get(10, TimeUnit.SECONDS);
+
+    assertEquals(Arrays.asList("record", "sleep:2000", "exit"), events);
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExitTest.java

@@ -0,0 +1,189 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import org.junit.Test;
+
+/**
+ * Plain JUnit (AndroidTest-AD-1) for the JS-fatal record → barrier → terminate ordering. A fake
+ * clock/sleeper/terminator stand in for time and {@code System.exit}, so no test ends the JVM.
+ */
+public class ReactNativeFirebaseCrashlyticsFatalExitTest {
+  private static final long TIMEOUT = 2000;
+
+  private final List<String> events = Collections.synchronizedList(new ArrayList<>());
+  private final List<Long> sleeps = new ArrayList<>();
+  private long now = 10_000;
+
+  private ReactNativeFirebaseCrashlyticsFatalExit fatalExit(
+      ReactNativeFirebaseCrashlyticsFatalExit.Barrier barrier,
+      ReactNativeFirebaseCrashlyticsFatalExit.Sleeper sleeper) {
+    return new ReactNativeFirebaseCrashlyticsFatalExit(
+        barrier, sleeper, () -> now, () -> events.add("exit"), TIMEOUT);
+  }
+
+  private ReactNativeFirebaseCrashlyticsFatalExit.Sleeper advancingSleeper() {
+    return millis -> {
+      sleeps.add(millis);
+      now += millis;
+    };
+  }
+
+  @Test
+  public void barrierSuccess_terminatesAfterRecordAndBarrierWithoutWaiting() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              assertEquals(TIMEOUT, timeoutMs);
+              events.add("barrier");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+    assertTrue(sleeps.isEmpty());
+  }
+
+  @Test
+  public void recordThrows_stillWaitsOnBarrierAndTerminates() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(timeoutMs -> events.add("barrier"), advancingSleeper());
+
+    assertTrue(
+        fatalExit.recordThenTerminate(
+            () -> {
+              events.add("record");
+              throw new IllegalStateException("record failed");
+            }));
+
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+    assertFalse(fatalExit.recordThenTerminate(() -> events.add("second")));
+    assertEquals(Arrays.asList("record", "barrier", "exit"), events);
+  }
+
+  @Test
+  public void barrierTimeout_terminatesOnceTheBoundHasElapsed() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              now += timeoutMs;
+              throw new TimeoutException("barrier timed out");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList("record", "exit"), events);
+    assertTrue("bound already used up by the barrier", sleeps.isEmpty());
+  }
+
+  @Test
+  public void reflectionFailure_waitsOutTheRemainingBoundThenTerminates() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              now += 300;
+              throw new NoSuchFieldException("crashlyticsWorkers");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Collections.singletonList(TIMEOUT - 300), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void linkageError_fallsBackToTheBoundedWait() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              throw new NoSuchFieldError("core");
+            },
+            advancingSleeper());
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Collections.singletonList(TIMEOUT), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void interruptedFallbackWait_keepsWaitingUntilTheBound() {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        fatalExit(
+            timeoutMs -> {
+              throw new InterruptedException("barrier interrupted");
+            },
+            millis -> {
+              sleeps.add(millis);
+              if (sleeps.size() == 1) {
+                now += 500;
+                throw new InterruptedException("sleep interrupted");
+              }
+              now += millis;
+            });
+
+    assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+
+    assertEquals(Arrays.asList(TIMEOUT, TIMEOUT - 500), sleeps);
+    assertEquals(Arrays.asList("record", "exit"), events);
+  }
+
+  @Test
+  public void secondFatalWhileTerminating_neitherRecordsNorTerminatesAgain() {
+    ReactNativeFirebaseCrashlyticsFatalExit[] holder =
+        new ReactNativeFirebaseCrashlyticsFatalExit[1];
+    List<Boolean> nestedResults = new ArrayList<>();
+    holder[0] =
+        fatalExit(
+            timeoutMs -> {
+              // A second JS fatal arrives while the first one is waiting on the barrier.
+              nestedResults.add(holder[0].recordThenTerminate(() -> events.add("record-2")));
+            },
+            advancingSleeper());
+
+    assertTrue(holder[0].recordThenTerminate(() -> events.add("record-1")));
+    assertFalse(holder[0].recordThenTerminate(() -> events.add("record-3")));
+
+    assertEquals(Collections.singletonList(false), nestedResults);
+    assertEquals(Arrays.asList("record-1", "exit"), events);
+  }
+
+  @Test
+  public void create_wiresTheProductionTimeoutClockAndSleeper() throws Exception {
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        ReactNativeFirebaseCrashlyticsFatalExit.create();
+
+    assertEquals(2000, ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS);
+    assertEquals(ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS, fatalExit.timeoutMs);
+    long before = fatalExit.clock.nowMillis();
+    fatalExit.sleeper.sleep(5);
+    assertTrue(fatalExit.clock.nowMillis() >= before + 5);
+  }
+}