@react-native-firebase/crashlytics 27.0.0 → 27.1.0

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

@@ -0,0 +1,199 @@
+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.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsCore;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+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.robolectric.RobolectricTestRunner;
+
+/**
+ * JVM coverage for {@link ReactNativeFirebaseCrashlyticsInternal} against the real Crashlytics
+ * worker classes. Robolectric supplies the Android runtime the SDK classes load against;
+ * AndroidTest-AD-1. {@code Tasks.await} must not run on the (Robolectric) main thread, so waits
+ * happen on a pool thread.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsInternalTest {
+  private final ExecutorService pool = Executors.newCachedThreadPool();
+
+  @After
+  public void tearDown() {
+    pool.shutdownNow();
+  }
+
+  /**
+   * A FirebaseCrashlytics whose core uses {@code workers}. Built by reflection because the real
+   * graph is impractical in a unit test: {@code CrashlyticsCore}'s only constructor takes ten SDK
+   * collaborators (FirebaseApp, file store, native component, ...) and {@code
+   * FirebaseCrashlytics}'s constructor is private. So a mock core gets its {@code private final}
+   * workers field set.
+   */
+  static FirebaseCrashlytics crashlyticsWith(CrashlyticsWorkers workers) throws Exception {
+    CrashlyticsCore core = mock(CrashlyticsCore.class);
+    Field field = CrashlyticsCore.class.getDeclaredField("crashlyticsWorkers");
+    field.setAccessible(true);
+    field.set(core, workers);
+    return crashlyticsWithCore(core);
+  }
+
+  static FirebaseCrashlytics crashlyticsWithCore(CrashlyticsCore core) throws Exception {
+    Constructor<FirebaseCrashlytics> constructor =
+        FirebaseCrashlytics.class.getDeclaredConstructor(CrashlyticsCore.class);
+    constructor.setAccessible(true);
+    return constructor.newInstance(core);
+  }
+
+  private <T> T awaitOnPool(Task<T> task) throws Exception {
+    return pool.submit(() -> Tasks.await(task, 5, TimeUnit.SECONDS)).get(10, TimeUnit.SECONDS);
+  }
+
+  @Test
+  public void barrier_completesAfterAnEventWriteQueuedByAnEarlierCommonTask() throws Exception {
+    CrashlyticsWorkers workers = new CrashlyticsWorkers(pool, pool);
+    CountDownLatch barrierCreated = new CountDownLatch(1);
+    AtomicBoolean eventWritten = new AtomicBoolean(false);
+
+    // Same shape as CrashlyticsCore.logException → SessionReportingCoordinator.persistEvent: a
+    // common task that queues the actual write on diskWrite.
+    workers.common.submit(
+        () -> {
+          try {
+            barrierCreated.await(5, TimeUnit.SECONDS);
+          } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+          }
+          workers.diskWrite.submit(
+              () -> {
+                try {
+                  Thread.sleep(150);
+                } catch (InterruptedException e) {
+                  throw new IllegalStateException(e);
+                }
+                eventWritten.set(true);
+              });
+        });
+
+    Task<?> barrier =
+        ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlyticsWith(workers));
+    assertFalse(barrier.isComplete());
+    barrierCreated.countDown();
+
+    awaitOnPool(barrier);
+    assertTrue(eventWritten.get());
+  }
+
+  /** Every member the barrier reflects exists on the SDK version these tests compile against. */
+  @Test
+  public void reflectedMembers_existOnTheRealSdkClasses() throws Exception {
+    assertNotNull(
+        FirebaseCrashlytics.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.CORE_FIELD));
+    assertNotNull(
+        CrashlyticsCore.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.WORKERS_FIELD));
+    assertNotNull(
+        CrashlyticsWorkers.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.COMMON_FIELD));
+    assertNotNull(
+        CrashlyticsWorkers.class.getDeclaredField(
+            ReactNativeFirebaseCrashlyticsInternal.DISK_WRITE_FIELD));
+    assertNotNull(
+        CrashlyticsWorker.class.getMethod(
+            ReactNativeFirebaseCrashlyticsInternal.SUBMIT_TASK_METHOD, Callable.class));
+    assertNotNull(
+        CrashlyticsWorker.class.getMethod(
+            ReactNativeFirebaseCrashlyticsInternal.SUBMIT_METHOD, Runnable.class));
+  }
+
+  @Test
+  public void barrier_nullCore_throws() throws Exception {
+    FirebaseCrashlytics crashlytics = crashlyticsWithCore(null);
+    NullPointerException thrown =
+        assertThrows(
+            NullPointerException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlytics));
+    assertEquals("core", thrown.getMessage());
+  }
+
+  @Test
+  public void barrier_unsetWorkersField_throws() throws Exception {
+    FirebaseCrashlytics crashlytics = crashlyticsWithCore(mock(CrashlyticsCore.class));
+    NullPointerException thrown =
+        assertThrows(
+            NullPointerException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(crashlytics));
+    assertEquals("crashlyticsWorkers", thrown.getMessage());
+  }
+
+  @SuppressWarnings("unused")
+  private static class FieldOnBase {
+    private final Object workers = "from base";
+  }
+
+  private static final class SubclassWithoutTheField extends FieldOnBase {}
+
+  @Test
+  public void read_findsAFieldDeclaredOnASuperclass() throws Exception {
+    assertEquals(
+        "from base",
+        ReactNativeFirebaseCrashlyticsInternal.read(new SubclassWithoutTheField(), "workers"));
+  }
+
+  @Test
+  public void read_missingField_throwsNoSuchField() {
+    NoSuchFieldException thrown =
+        assertThrows(
+            NoSuchFieldException.class,
+            () -> ReactNativeFirebaseCrashlyticsInternal.read(new Object(), "crashlyticsWorkers"));
+    assertEquals("crashlyticsWorkers", thrown.getMessage());
+  }
+
+  @SuppressWarnings("unused")
+  private static final class WorkersWithoutSubmitMethods {
+    private final Object common = new Object();
+    private final Object diskWrite = new Object();
+  }
+
+  @Test
+  public void barrierOn_missingWorkerMethod_throwsNoSuchMethod() {
+    assertThrows(
+        NoSuchMethodException.class,
+        () -> ReactNativeFirebaseCrashlyticsInternal.barrierOn(new WorkersWithoutSubmitMethods()));
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '27.0.0';
+export const version = '27.1.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { Crashlytics } from './types/crashlytics';
-export declare const SDK_VERSION = "27.0.0";
+export declare const SDK_VERSION = "27.1.0";
 export declare function getCrashlytics(app?: FirebaseApp): Crashlytics;
 export declare function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean>;
 export declare function deleteUnsentReports(crashlytics: Crashlytics): Promise<void>;

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "27.0.0";
+export declare const version = "27.1.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.h

@@ -56,3 +56,43 @@
              isUnhandledPromiseRejection:(BOOL)isUnhandledPromiseRejection;
 
 @end
+
+/** Upper bound (seconds) a JS fatal waits for its record to save before the process exits. */
+FOUNDATION_EXPORT const NSTimeInterval RNFBCrashlyticsFatalExitWatchdogTimeout;
+
+/**
+ * Records a JS fatal, then terminates the process once the record has had a chance to save.
+ *
+ * `-[FIRCrashlytics recordExceptionModel:]` saves asynchronously: once Crashlytics' context-init
+ * promise is fulfilled, the save block is dispatched to the main queue. Terminating on the
+ * calling queue right after recording usually loses that save. Instead the terminator is
+ * enqueued on `terminateQueue` (the main queue in production), so it runs FIFO after the save
+ * block. A watchdog on `watchdogQueue` terminates after `watchdogTimeout` if `terminateQueue`
+ * is hung. The terminator runs at most once.
+ *
+ * Known limit: a JS fatal recorded before Crashlytics finished initialising queues its save as a
+ * promise observer instead of a main-queue block, so it can still be lost.
+ * The FIFO ordering also relies on FBLPromise's default dispatch queue being the main queue; if an
+ * app changes it, the save runs off the main queue and the terminator can run first, losing the
+ * report. The watchdog only covers a hung `terminateQueue`.
+ */
+@interface RNFBCrashlyticsFatalExit : NSObject
+
+/** Production instance: terminates with `exit(0)` on the main queue, 2 s watchdog. */
++ (instancetype)shared;
+
+- (instancetype)initWithTerminator:(dispatch_block_t)terminator
+                    terminateQueue:(dispatch_queue_t)terminateQueue
+                     watchdogQueue:(dispatch_queue_t)watchdogQueue
+                   watchdogTimeout:(NSTimeInterval)watchdogTimeout NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/**
+ * Runs `record` synchronously, then schedules termination, even when `record` raises. Returns NO
+ * without running `record` when an earlier call already started terminating (a second fatal
+ * while waiting).
+ */
+- (BOOL)recordThenTerminate:(dispatch_block_t)record;
+
+@end

package/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.m

@@ -35,6 +35,8 @@
 #error "RNFBCrashlyticsDebuggerProbe Swift interface not found"
 #endif
 
+#import <stdatomic.h>
+
 #import "RNFBCrashlyticsHelper.h"
 
 @implementation RNFBCrashlyticsHelper
@@ -107,3 +109,74 @@
 }
 
 @end
+
+const NSTimeInterval RNFBCrashlyticsFatalExitWatchdogTimeout = 2.0;
+
+@implementation RNFBCrashlyticsFatalExit {
+  dispatch_block_t _terminator;
+  dispatch_queue_t _terminateQueue;
+  dispatch_queue_t _watchdogQueue;
+  NSTimeInterval _watchdogTimeout;
+  atomic_bool _exiting;
+  atomic_bool _terminated;
+}
+
++ (instancetype)shared {
+  static RNFBCrashlyticsFatalExit *shared;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    shared = [[RNFBCrashlyticsFatalExit alloc]
+        initWithTerminator:^{
+          // Coverage exception: ends the process, so no test can run it.
+          exit(0);
+        }
+            terminateQueue:dispatch_get_main_queue()
+             watchdogQueue:dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
+           watchdogTimeout:RNFBCrashlyticsFatalExitWatchdogTimeout];
+  });
+  return shared;
+}
+
+- (instancetype)initWithTerminator:(dispatch_block_t)terminator
+                    terminateQueue:(dispatch_queue_t)terminateQueue
+                     watchdogQueue:(dispatch_queue_t)watchdogQueue
+                   watchdogTimeout:(NSTimeInterval)watchdogTimeout {
+  if (self = [super init]) {
+    _terminator = [terminator copy];
+    _terminateQueue = terminateQueue;
+    _watchdogQueue = watchdogQueue;
+    _watchdogTimeout = watchdogTimeout;
+    atomic_init(&_exiting, false);
+    atomic_init(&_terminated, false);
+  }
+  return self;
+}
+
+- (BOOL)recordThenTerminate:(dispatch_block_t)record {
+  if (atomic_exchange(&_exiting, true)) {
+    return NO;
+  }
+  @try {
+    record();
+  } @catch (NSException *exception) {
+    // The guard is already set, so terminate anyway rather than leave the app running with every
+    // later fatal ignored.
+    NSLog(@"RNFBCrashlytics: recording JS fatal failed: %@", exception);
+  }
+  dispatch_block_t terminateOnce = ^{
+    [self terminateOnce];
+  };
+  // FIFO behind the Crashlytics save block that recordExceptionModel: enqueued on main.
+  dispatch_async(_terminateQueue, terminateOnce);
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_watchdogTimeout * NSEC_PER_SEC)),
+                 _watchdogQueue, terminateOnce);
+  return YES;
+}
+
+- (void)terminateOnce {
+  if (!atomic_exchange(&_terminated, true)) {
+    _terminator();
+  }
+}
+
+@end

package/ios/RNFBCrashlytics/RNFBCrashlyticsModule.mm

@@ -97,10 +97,15 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
       RCTLog(
           @"Crashlytics - WARNING: Debugger detected. Crashlytics will not receive crash reports.");
     }
-    [self recordJavaScriptError:jsErrorDict];
-
-    ELog(@"Crashlytics - Crash logged. Terminating app.");
-    exit(0);
+    // Coverage exception: this branch ends the process, so neither XCTest nor e2e can observe it.
+    // Keep it a thin delegate; ordering, watchdog and the second-fatal guard live in
+    // RNFBCrashlyticsFatalExit (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.
+    ELog(@"Crashlytics - Logging crash and terminating app.");
+    [[RNFBCrashlyticsFatalExit shared]
+        recordThenTerminate:[self javaScriptErrorRecorder:jsErrorDict]];
+    return;
   } else {
     RCTLog(@"Crashlytics - INFO: crashlytics collection is not enabled, not crashing.");
   }
@@ -193,6 +198,13 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
 }
 
 - (void)recordJavaScriptError:(JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict {
+  [self javaScriptErrorRecorder:jsErrorDict]();
+}
+
+// Converts the codegen struct to Foundation values up front, so the returned block captures no
+// C++ references and can be handed to RNFBCrashlyticsFatalExit.
+- (dispatch_block_t)javaScriptErrorRecorder:
+    (JS::NativeRNFBTurboCrashlytics::JavaScriptErrorObject &)jsErrorDict {
   NSString *message = jsErrorDict.message();
   auto stackFrames = jsErrorDict.frames();
   NSMutableArray *frames = [[NSMutableArray alloc] init];
@@ -206,9 +218,11 @@ RCT_EXPORT_MODULE(NativeRNFBTurboCrashlytics)
     }];
   }
 
-  [RNFBCrashlyticsHelper recordJavaScriptErrorWithMessage:message
-                                                   frames:frames
-                              isUnhandledPromiseRejection:isUnhandledPromiseRejection];
+  return ^{
+    [RNFBCrashlyticsHelper recordJavaScriptErrorWithMessage:message
+                                                     frames:frames
+                                isUnhandledPromiseRejection:isUnhandledPromiseRejection];
+  };
 }
 
 @end

package/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/FIRCrashlyticsHostStub.m

@@ -2,6 +2,7 @@
  * Host-only stub for macOS XCTest. Not shipped in the production pod.
  */
 #import <Firebase/Firebase.h>
+#import <stdatomic.h>
 
 @implementation FIRStackFrame {
   NSString *_symbol;
@@ -63,11 +64,19 @@ static NSString *sUserIDValue;
 static NSUInteger sDeleteUnsentReportsCallCount;
 static NSUInteger sSendUnsentReportsCallCount;
 static FIRExceptionModel *sLastRecordedExceptionModel;
+static NSMutableArray<FIRExceptionModel *> *sSavedExceptionModels;
+static void (^sOnExceptionModelSaved)(FIRExceptionModel *);
+static BOOL sContextInitPending;
+static NSMutableArray<dispatch_block_t> *sPendingSaves;
+// Bumped by resetTestState so saves enqueued by an earlier test are dropped.
+static atomic_uint_fast64_t sSaveGeneration;
 
 + (void)initialize {
   if (self == [FIRCrashlytics class]) {
     sLoggedMessages = [NSMutableArray new];
     sCustomValues = [NSMutableDictionary new];
+    sSavedExceptionModels = [NSMutableArray new];
+    sPendingSaves = [NSMutableArray new];
   }
 }
 
@@ -150,6 +159,36 @@ static FIRExceptionModel *sLastRecordedExceptionModel;
   sLastRecordedExceptionModel = lastRecordedExceptionModel;
 }
 
++ (NSArray<FIRExceptionModel *> *)savedExceptionModels {
+  return [sSavedExceptionModels copy];
+}
+
++ (void (^)(FIRExceptionModel *))onExceptionModelSaved {
+  return sOnExceptionModelSaved;
+}
+
++ (void)setOnExceptionModelSaved:(void (^)(FIRExceptionModel *))onExceptionModelSaved {
+  sOnExceptionModelSaved = [onExceptionModelSaved copy];
+}
+
++ (void)holdContextInit {
+  @synchronized(sPendingSaves) {
+    sContextInitPending = YES;
+  }
+}
+
++ (void)fulfillContextInit {
+  NSArray<dispatch_block_t> *saves;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    saves = [sPendingSaves copy];
+    [sPendingSaves removeAllObjects];
+  }
+  for (dispatch_block_t save in saves) {
+    dispatch_async(dispatch_get_main_queue(), save);
+  }
+}
+
 + (void)resetTestState {
   sDidCrashDuringPreviousExecutionValue = NO;
   sCheckForUnsentReportsValue = NO;
@@ -159,6 +198,13 @@ static FIRExceptionModel *sLastRecordedExceptionModel;
   sDeleteUnsentReportsCallCount = 0;
   sSendUnsentReportsCallCount = 0;
   sLastRecordedExceptionModel = nil;
+  [sSavedExceptionModels removeAllObjects];
+  sOnExceptionModelSaved = nil;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    [sPendingSaves removeAllObjects];
+  }
+  atomic_fetch_add(&sSaveGeneration, 1);
 }
 
 - (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion {
@@ -202,6 +248,26 @@ static FIRExceptionModel *sLastRecordedExceptionModel;
 
 - (void)recordExceptionModel:(FIRExceptionModel *)exceptionModel {
   sLastRecordedExceptionModel = exceptionModel;
+  // Mirrors FirebaseCrashlytics: once context init is fulfilled, the save block is dispatched to
+  // the main queue and writes synchronously when it runs. While init is pending, FBLPromise holds
+  // the block as an observer and dispatches it to the main queue only when the promise fulfills.
+  uint_fast64_t generation = atomic_load(&sSaveGeneration);
+  dispatch_block_t save = ^{
+    if (generation != atomic_load(&sSaveGeneration)) {
+      return;
+    }
+    [sSavedExceptionModels addObject:exceptionModel];
+    if (sOnExceptionModelSaved != nil) {
+      sOnExceptionModelSaved(exceptionModel);
+    }
+  };
+  @synchronized(sPendingSaves) {
+    if (sContextInitPending) {
+      [sPendingSaves addObject:save];
+      return;
+    }
+  }
+  dispatch_async(dispatch_get_main_queue(), save);
 }
 
 @end

package/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/Firebase.h

@@ -41,6 +41,15 @@
 @property(class, nonatomic, assign) NSUInteger deleteUnsentReportsCallCount;
 @property(class, nonatomic, assign) NSUInteger sendUnsentReportsCallCount;
 @property(class, nonatomic, copy, nullable) FIRExceptionModel *lastRecordedExceptionModel;
+/** Models whose main-queue save block has run (see recordExceptionModel:). */
+@property(class, nonatomic, readonly, copy) NSArray<FIRExceptionModel *> *savedExceptionModels;
+/** Called on the main queue right after a save block runs. */
+@property(class, nonatomic, copy, nullable) void (^onExceptionModelSaved)(FIRExceptionModel *model);
+/** Holds later saves like observers of a pending context-init promise, until fulfillContextInit. */
++ (void)holdContextInit;
+
+/** Dispatches the held saves to the main queue and stops holding new ones. */
++ (void)fulfillContextInit;
 
 + (void)resetTestState;