Implement on-demand fatals internally

firebase-crashlytics/src/androidTest/java/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinatorTest.java

@@ -438,13 +438,13 @@ public void onReportSend_successfulReportsAreDeleted() {
     final Task<CrashlyticsReportWithSessionId> failedTask =
         Tasks.forException(new Exception("fail"));
 
-    when(reportSender.sendReport(mockReport1)).thenReturn(successfulTask);
-    when(reportSender.sendReport(mockReport2)).thenReturn(failedTask);
+    when(reportSender.enqueueReport(mockReport1, false)).thenReturn(successfulTask);
+    when(reportSender.enqueueReport(mockReport2, false)).thenReturn(failedTask);
 
     reportingCoordinator.sendReports(Runnable::run);
 
-    verify(reportSender).sendReport(mockReport1);
-    verify(reportSender).sendReport(mockReport2);
+    verify(reportSender).enqueueReport(mockReport1, false);
+    verify(reportSender).enqueueReport(mockReport2, false);
   }
 
   @Test

firebase-crashlytics/src/androidTest/java/com/google/firebase/crashlytics/internal/send/DataTransportCrashlyticsReportSenderTest.java

@@ -29,6 +29,7 @@
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId;
+import com.google.firebase.crashlytics.internal.common.OnDemandCounter;
 import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
 import java.io.File;
 import java.util.concurrent.ExecutionException;
@@ -51,7 +52,9 @@ public class DataTransportCrashlyticsReportSenderTest {
   public void setUp() throws Exception {
     MockitoAnnotations.initMocks(this);
     when(mockTransform.apply(any())).thenReturn(new byte[0]);
-    reportSender = new DataTransportCrashlyticsReportSender(mockTransport, mockTransform);
+    reportSender =
+        new DataTransportCrashlyticsReportSender(
+            new ReportQueue(60, 1.2, 3_000, mockTransport, new OnDemandCounter()), mockTransform);
   }
 
   @Test
@@ -61,10 +64,13 @@ public void testSendReportsSuccessful() throws Exception {
     final CrashlyticsReportWithSessionId report1 = mockReportWithSessionId();
     final CrashlyticsReportWithSessionId report2 = mockReportWithSessionId();
 
-    final Task<CrashlyticsReportWithSessionId> send1 = reportSender.sendReport(report1);
-    final Task<CrashlyticsReportWithSessionId> send2 = reportSender.sendReport(report2);
+    final Task<CrashlyticsReportWithSessionId> send1 =
+        reportSender.enqueueReport(report1, /*isOnDemand=*/ true);
+    final Task<CrashlyticsReportWithSessionId> send2 =
+        reportSender.enqueueReport(report2, /*isOnDemand=*/ true);
 
     try {
+      Thread.sleep(2_000); // give time to process queue
       Tasks.await(send1);
       Tasks.await(send2);
     } catch (ExecutionException e) {
@@ -85,10 +91,11 @@ public void testSendReportsFailure() throws Exception {
     final CrashlyticsReportWithSessionId report1 = mockReportWithSessionId();
     final CrashlyticsReportWithSessionId report2 = mockReportWithSessionId();
 
-    final Task<CrashlyticsReportWithSessionId> send1 = reportSender.sendReport(report1);
-    final Task<CrashlyticsReportWithSessionId> send2 = reportSender.sendReport(report2);
+    final Task<CrashlyticsReportWithSessionId> send1 = reportSender.enqueueReport(report1, false);
+    final Task<CrashlyticsReportWithSessionId> send2 = reportSender.enqueueReport(report2, false);
 
     try {
+      Thread.sleep(2_000); // give time to process queue
       Tasks.await(send1);
       Tasks.await(send2);
     } catch (ExecutionException e) {
@@ -112,10 +119,11 @@ public void testSendReports_oneSuccessOneFail() throws Exception {
     final CrashlyticsReportWithSessionId report1 = mockReportWithSessionId();
     final CrashlyticsReportWithSessionId report2 = mockReportWithSessionId();
 
-    final Task<CrashlyticsReportWithSessionId> send1 = reportSender.sendReport(report1);
-    final Task<CrashlyticsReportWithSessionId> send2 = reportSender.sendReport(report2);
+    final Task<CrashlyticsReportWithSessionId> send1 = reportSender.enqueueReport(report1, false);
+    final Task<CrashlyticsReportWithSessionId> send2 = reportSender.enqueueReport(report2, false);
 
     try {
+      Thread.sleep(2_000); // give time to process queue
       Tasks.await(send1);
       Tasks.await(send2);
     } catch (ExecutionException e) {

firebase-crashlytics/src/androidTest/java/com/google/firebase/crashlytics/internal/settings/TestSettingsData.java

@@ -37,7 +37,10 @@ public TestSettingsData(
         buildSettingsData(),
         buildFeaturesData(),
         settingsVersion,
-        3600);
+        3600,
+        10,
+        1.2,
+        60);
   }
 
   private static FeaturesSettingsData buildFeaturesData() {

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/FirebaseCrashlytics.java

@@ -201,6 +201,16 @@ public void recordException(@NonNull Throwable throwable) {
     core.logException(throwable);
   }
 
+  /** Records a fatal report and sends to Crashlytics on-demand. */
+  // TODO(mrober): Move this to a FirebaseCrashlyticsInternal interface.
+  private void recordFatalException(Throwable throwable) {
+    if (throwable == null) {
+      Logger.getLogger().w("A null value was passed to recordFatalException. Ignoring.");
+      return;
+    }
+    core.logFatalException(throwable);
+  }
+
   /**
    * Logs a message that's included in the next fatal, non-fatal, or ANR report.
    *

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/CrashlyticsController.java

@@ -85,6 +85,7 @@ class CrashlyticsController {
   private final SessionReportingCoordinator reportingCoordinator;
 
   private CrashlyticsUncaughtExceptionHandler crashHandler;
+  private SettingsDataProvider settingsProvider = null;
 
   // A promise that will be resolved when unsent reports are found on the device, and
   // send/deleteUnsentReports can be called to decide how to deal with them.
@@ -140,6 +141,7 @@ void enableExceptionHandling(
       String sessionIdentifier,
       Thread.UncaughtExceptionHandler defaultHandler,
       SettingsDataProvider settingsProvider) {
+    this.settingsProvider = settingsProvider;
     // This must be called before installing the controller with
     // Thread.setDefaultUncaughtExceptionHandler to ensure that we are ready to handle
     // any crashes we catch.
@@ -160,10 +162,18 @@ public void onUncaughtException(
     Thread.setDefaultUncaughtExceptionHandler(crashHandler);
   }
 
-  synchronized void handleUncaughtException(
+  void handleUncaughtException(
       @NonNull SettingsDataProvider settingsDataProvider,
       @NonNull final Thread thread,
       @NonNull final Throwable ex) {
+    handleUncaughtException(settingsDataProvider, thread, ex, /*isOnDemand=*/ false);
+  }
+
+  synchronized void handleUncaughtException(
+      @NonNull SettingsDataProvider settingsDataProvider,
+      @NonNull final Thread thread,
+      @NonNull final Throwable ex,
+      boolean isOnDemand) {
 
     Logger.getLogger()
         .d("Handling uncaught " + "exception \"" + ex + "\" from thread " + thread.getName());
@@ -222,13 +232,15 @@ public Task<Void> then(@Nullable AppSettingsData appSettingsData)
                             // Data collection is enabled, so it's safe to send the report.
                             return Tasks.whenAll(
                                 logAnalyticsAppExceptionEvents(),
-                                reportingCoordinator.sendReports(executor));
+                                reportingCoordinator.sendReports(
+                                    executor, isOnDemand ? currentSessionId : null));
                           }
                         });
               }
             });
 
     try {
+      // TODO(mrober): Don't block the main thread ever for on-demand fatals.
       Utils.awaitEvenIfOnMainThread(handleUncaughtExceptionTask);
     } catch (Exception e) {
       Logger.getLogger().e("Error handling uncaught exception", e);
@@ -419,6 +431,14 @@ public void run() {
         });
   }
 
+  void logFatalException(Thread thread, Throwable ex) {
+    if (settingsProvider == null) {
+      Logger.getLogger().w("settingsProvider not set");
+      return;
+    }
+    handleUncaughtException(settingsProvider, thread, ex, /*isOnDemand=*/ true);
+  }
+
   void setUserId(String identifier) {
     userMetadata.setUserId(identifier);
   }

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/CrashlyticsCore.java

@@ -61,13 +61,19 @@ public class CrashlyticsCore {
 
   static final int DEFAULT_MAIN_HANDLER_TIMEOUT_SEC = 4;
 
+  private static final String ON_DEMAND_RECORDED_KEY =
+      "com.crashlytics.on-demand.recorded-exceptions";
+  private static final String ON_DEMAND_DROPPED_KEY =
+      "com.crashlytics.on-demand.dropped-exceptions";
+
   // If this marker sticks around, the app is crashing before we finished initializing
   private static final String INITIALIZATION_MARKER_FILE_NAME = "initialization_marker";
   static final String CRASH_MARKER_FILE_NAME = "crash_marker";
 
   private final Context context;
   private final FirebaseApp app;
   private final DataCollectionArbiter dataCollectionArbiter;
+  private final OnDemandCounter onDemandCounter;
 
   private final long startTime;
 
@@ -110,6 +116,7 @@ public CrashlyticsCore(
     this.backgroundWorker = new CrashlyticsBackgroundWorker(crashHandlerExecutor);
 
     startTime = System.currentTimeMillis();
+    onDemandCounter = new OnDemandCounter();
   }
 
   // endregion
@@ -150,7 +157,8 @@ public boolean onPreExecute(AppData appData, SettingsDataProvider settingsProvid
               logFileManager,
               userMetadata,
               stackTraceTrimmingStrategy,
-              settingsProvider);
+              settingsProvider,
+              onDemandCounter);
 
       controller =
           new CrashlyticsController(
@@ -348,6 +356,10 @@ public void setCustomKeys(Map<String, String> keysAndValues) {
     controller.setCustomKeys(keysAndValues);
   }
 
+  // endregion
+
+  // region Internal API
+
   /**
    * Set a value to be associated with a given key for your crash data. The key/value pairs will be
    * reported with any crash that occurs in this session. A maximum of 64 key/value pairs can be
@@ -364,6 +376,19 @@ public void setInternalKey(String key, String value) {
     controller.setInternalKey(key, value);
   }
 
+  /** Logs a fatal Throwable on the Crashlytics servers on-demand. */
+  public void logFatalException(Throwable throwable) {
+    Logger.getLogger()
+        .d("Recorded on-demand fatal events: " + onDemandCounter.getRecordedOnDemandExceptions());
+    Logger.getLogger()
+        .d("Dropped on-demand fatal events: " + onDemandCounter.getDroppedOnDemandExceptions());
+    controller.setInternalKey(
+        ON_DEMAND_RECORDED_KEY, Integer.toString(onDemandCounter.getRecordedOnDemandExceptions()));
+    controller.setInternalKey(
+        ON_DEMAND_DROPPED_KEY, Integer.toString(onDemandCounter.getDroppedOnDemandExceptions()));
+    controller.logFatalException(Thread.currentThread(), throwable);
+  }
+
   // endregion
 
   // region Package-protected getters

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/OnDemandCounter.java

@@ -0,0 +1,46 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file 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.
+
+package com.google.firebase.crashlytics.internal.common;
+
+/** Simple, thread-safe, class to keep count of recorded and dropped on-demand events. */
+public final class OnDemandCounter {
+  private int recordedOnDemandExceptions;
+  private int droppedOnDemandExceptions;
+
+  public OnDemandCounter() {
+    recordedOnDemandExceptions = 0;
+    droppedOnDemandExceptions = 0;
+  }
+
+  public synchronized int getRecordedOnDemandExceptions() {
+    return recordedOnDemandExceptions;
+  }
+
+  public synchronized void incrementRecordedOnDemandExceptions() {
+    recordedOnDemandExceptions++;
+  }
+
+  public synchronized int getDroppedOnDemandExceptions() {
+    return droppedOnDemandExceptions;
+  }
+
+  public synchronized void incrementDroppedOnDemandExceptions() {
+    droppedOnDemandExceptions++;
+  }
+
+  public synchronized void resetDroppedOnDemandExceptions() {
+    droppedOnDemandExceptions = 0;
+  }
+}

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator.java

@@ -67,13 +67,14 @@ public static SessionReportingCoordinator create(
       LogFileManager logFileManager,
       UserMetadata userMetadata,
       StackTraceTrimmingStrategy stackTraceTrimmingStrategy,
-      SettingsDataProvider settingsProvider) {
+      SettingsDataProvider settingsProvider,
+      OnDemandCounter onDemandCounter) {
     final CrashlyticsReportDataCapture dataCapture =
         new CrashlyticsReportDataCapture(context, idManager, appData, stackTraceTrimmingStrategy);
     final CrashlyticsReportPersistence reportPersistence =
         new CrashlyticsReportPersistence(fileStore, settingsProvider);
     final DataTransportCrashlyticsReportSender reportSender =
-        DataTransportCrashlyticsReportSender.create(context);
+        DataTransportCrashlyticsReportSender.create(context, settingsProvider, onDemandCounter);
     return new SessionReportingCoordinator(
         dataCapture, reportPersistence, reportSender, logFileManager, userMetadata);
   }
@@ -202,14 +203,21 @@ public void removeAllReports() {
    *     sent.
    */
   public Task<Void> sendReports(@NonNull Executor reportSendCompleteExecutor) {
+    return sendReports(reportSendCompleteExecutor, /*sessionId=*/ null);
+  }
+
+  public Task<Void> sendReports(
+      @NonNull Executor reportSendCompleteExecutor, @Nullable String sessionId) {
     final List<CrashlyticsReportWithSessionId> reportsToSend =
         reportPersistence.loadFinalizedReports();
     final List<Task<Boolean>> sendTasks = new ArrayList<>();
     for (CrashlyticsReportWithSessionId reportToSend : reportsToSend) {
-      sendTasks.add(
-          reportsSender
-              .sendReport(reportToSend)
-              .continueWith(reportSendCompleteExecutor, this::onReportSendComplete));
+      if (sessionId == null || sessionId.equals(reportToSend.getSessionId())) {
+        sendTasks.add(
+            reportsSender
+                .enqueueReport(reportToSend, sessionId != null)
+                .continueWith(reportSendCompleteExecutor, this::onReportSendComplete));
+      }
     }
     return Tasks.whenAll(sendTasks);
   }