BIT-7817: Skeleton crash reports for native crashes on API level 30

CHANGELOG.md

@@ -29,6 +29,8 @@
 
 **Fixed**
 
+- Native crash reports are now generated on API level 30 when tombstone data is unavailable. These skeleton reports include signal information but no stack traces.
+
 - Fixed an issue where 3rd-party dependencies like `androidx` were included in the released Javadoc artifacts. Also updated the style of `capture-timber` and `capture-apollo` javadocs to match. 
 
 ### iOS

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/reports/IssueReporter.kt

@@ -165,13 +165,14 @@ internal class IssueReporter(
         val lastReasonResult = latestAppExitInfoProvider.get()
         if (lastReasonResult is LatestAppExitReasonResult.Valid) {
             val lastReason = lastReasonResult.applicationExitInfo
-            lastReason.traceInputStream?.use {
+            lastReason.traceInputStream.use { traceInputStream ->
                 latestAppExitInfoProvider.convertExitReasonToFbsReportType(lastReason.reason)?.let { fatalIssueType ->
                     issueReporterProcessor?.processAppExitReport(
                         fatalIssueType = fatalIssueType,
                         timestamp = lastReason.timestamp,
                         description = lastReason.description,
-                        traceInputStream = it,
+                        traceInputStream = traceInputStream,
+                        signalNumber = lastReason.status,
                     )
                 }
             }

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/reports/processor/IIssueReporterProcessor.kt

@@ -24,13 +24,18 @@ interface IIssueReporterProcessor {
      * (e.g. [ReportType.AppNotResponding] or [ReportType.NativeCrash]).
      * @param timestamp The timestamp when the issue occurred.
      * @param description Optional description of the issue.
-     * @param traceInputStream Input stream containing the fatal issue trace data.
+     * @param traceInputStream Input stream containing the fatal issue trace data. May be null for
+     * native crashes on API level 30 where tombstone data is unavailable; a skeleton report will
+     * be generated in that case.
+     * @param signalNumber The signal number from [android.app.ApplicationExitInfo.getStatus] for
+     * native crashes. Used to populate signal name and description in skeleton reports.
      */
     fun processAppExitReport(
         fatalIssueType: Byte,
         timestamp: Long,
         description: String? = null,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream?,
+        signalNumber: Int = 0,
     )
 
     /**

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/reports/processor/IssueReporterProcessor.kt

@@ -100,16 +100,22 @@ internal class IssueReporterProcessor(
      * (e.g. [ReportType.AppNotResponding] or [ReportType.NativeCrash])
      * @param timestamp The timestamp when the issue occurred
      * @param description Optional description of the issue
-     * @param traceInputStream Input stream containing the fatal issue trace data
+     * @param traceInputStream Input stream containing the fatal issue trace data. May be null for
+     * native crashes on API level 30 where tombstone data is unavailable; a skeleton report will
+     * be generated in that case.
+     * @param signalNumber The signal number from [android.app.ApplicationExitInfo.getStatus] for
+     * native crashes. Used to populate signal name and description in skeleton reports.
      */
     override fun processAppExitReport(
         fatalIssueType: Byte,
         timestamp: Long,
         description: String?,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream?,
+        signalNumber: Int,
     ) {
         runCatching {
             if (fatalIssueType == ReportType.AppNotResponding) {
+                if (traceInputStream == null) return
                 streamingReportsProcessor.processAndPersistANR(
                     traceInputStream,
                     timestamp,
@@ -129,6 +135,7 @@ internal class IssueReporterProcessor(
                         deviceMetrics,
                         description,
                         traceInputStream,
+                        signalNumber,
                     )
                 builder.finish(report)
 

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/reports/processor/NativeCrashProcessor.kt

@@ -25,24 +25,36 @@ import java.io.InputStream
  * and converts to a FlatBuffer Report.
  */
 internal object NativeCrashProcessor {
-    private val signalDescriptions =
+    private data class SignalInfo(
+        val name: String,
+        val description: String,
+    )
+
+    private val signals =
         mapOf(
-            "SIGABRT" to "Abort program",
-            "SIGBUS" to "Bus error (bad memory access)",
-            "SIGFPE" to "Floating‑point exception",
-            "SIGILL" to "Illegal instruction",
-            "SIGSEGV" to "Segmentation violation (invalid memory reference)",
-            "SIGTRAP" to "Trace/breakpoint trap",
+            4 to SignalInfo("SIGILL", "Illegal instruction"),
+            5 to SignalInfo("SIGTRAP", "Trace/breakpoint trap"),
+            6 to SignalInfo("SIGABRT", "Abort program"),
+            7 to SignalInfo("SIGBUS", "Bus error (bad memory access)"),
+            8 to SignalInfo("SIGFPE", "Floating‑point exception"),
+            11 to SignalInfo("SIGSEGV", "Segmentation violation (invalid memory reference)"),
         )
 
+    private val signalsByName = signals.values.associateBy { it.name }
+
     fun process(
         builder: FlatBufferBuilder,
         sdk: Int,
         appMetrics: Int,
         deviceMetrics: Int,
         description: String?,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream?,
+        signalNumber: Int = 0,
     ): Int {
+        if (traceInputStream == null) {
+            return createSkeletonReport(builder, sdk, appMetrics, deviceMetrics, description, signalNumber)
+        }
+
         val tombstone = Tombstone.parseFrom(traceInputStream)
         val nativeErrors = mutableListOf<Int>()
         val threadOffsets = mutableListOf<Int>()
@@ -139,17 +151,64 @@ internal object NativeCrashProcessor {
         )
     }
 
+    /**
+     * Creates a minimal native crash report for cases where tombstone data is unavailable
+     * (e.g. native crashes on API level 30 where [android.app.ApplicationExitInfo.getTraceInputStream]
+     * returns null). The report includes the crash description and uses empty stack traces,
+     * empty thread details, and empty binary images. When a [signalNumber] is available
+     * (from [android.app.ApplicationExitInfo.getStatus]), the signal name and description
+     * are used for the error name and reason fields.
+     */
+    private fun createSkeletonReport(
+        builder: FlatBufferBuilder,
+        sdk: Int,
+        appMetrics: Int,
+        deviceMetrics: Int,
+        description: String?,
+        signalNumber: Int = 0,
+    ): Int {
+        val signal = signals[signalNumber]
+        val name = builder.createString(signal?.name ?: description ?: "Native crash")
+        val reason = builder.createString(signal?.description ?: "Native crash")
+        val errorOffset =
+            Error.createError(
+                builder,
+                name,
+                reason,
+                Error.createStackTraceVector(builder, intArrayOf()),
+                ErrorRelation.CausedBy,
+            )
+        val threadDetailsOffset =
+            ThreadDetails.createThreadDetails(
+                builder,
+                0.toUShort(),
+                ThreadDetails.createThreadsVector(builder, intArrayOf()),
+            )
+        return Report.createReport(
+            builder,
+            sdk,
+            ReportType.NativeCrash,
+            appMetrics,
+            deviceMetrics,
+            Report.createErrorsVector(builder, intArrayOf(errorOffset)),
+            threadDetailsOffset,
+            Report.createBinaryImagesVector(builder, intArrayOf()),
+            stateOffset = 0,
+            featureFlagsOffset = 0,
+        )
+    }
+
     private fun createErrorOffset(
         builder: FlatBufferBuilder,
         description: String?,
         tombstone: Tombstone,
         frameOffsets: IntArray,
     ): Int {
         val signalName = tombstone.signalInfo.name
-        val reason = builder.createString(signalName.ifEmpty { description })
+        val reason = builder.createString(signalName.ifEmpty { description ?: "Native crash" })
         val causeText =
             tombstone.causesList.firstOrNull()?.humanReadable ?: tombstone.abortMessage.ifEmpty {
-                signalDescriptions[signalName] ?: "Native crash"
+                signalsByName[signalName]?.description ?: "Native crash"
             }
         val cause = builder.createString(causeText)
         return Error.createError(

platform/jvm/capture/src/test/kotlin/io/bitdrift/capture/reports/processor/IssueReporterProcessorTest.kt

@@ -166,6 +166,7 @@ class IssueReporterProcessorTest {
             FAKE_TIME_STAMP,
             "Input Dispatching Timed Out",
             trace,
+            signalNumber = 0,
         )
 
         verify(streamingReportProcessor).processAndPersistANR(
@@ -190,6 +191,7 @@ class IssueReporterProcessorTest {
             FAKE_TIME_STAMP,
             "Input Dispatching Timed Out",
             buildTraceInputStringFromFile("app_exit_anr_deadlock_anr.txt"),
+            signalNumber = 0,
         )
 
         verify(internalLogger).logInternalError(
@@ -214,6 +216,7 @@ class IssueReporterProcessorTest {
             FAKE_TIME_STAMP,
             "Input Dispatching Timed Out",
             buildTraceInputStringFromFile("app_exit_anr_deadlock_anr.txt"),
+            signalNumber = 0,
         )
 
         verify(internalLogger).logInternalError(
@@ -237,6 +240,7 @@ class IssueReporterProcessorTest {
             FAKE_TIME_STAMP,
             description,
             traceInputStream,
+            signalNumber = 0,
         )
 
         verify(issueReporterStorage).persistFatalIssue(
@@ -275,6 +279,60 @@ class IssueReporterProcessorTest {
         assertThat(deviceMetrics?.cpuAbis(0)).isEqualTo("armeabi-v7a")
     }
 
+    @Test
+    fun processAppExitReport_whenNativeCrashWithNullTrace_shouldCreateSkeletonNativeReport() {
+        val description = "Segmentation fault"
+
+        processor.processAppExitReport(
+            ReportType.NativeCrash,
+            FAKE_TIME_STAMP,
+            description,
+            traceInputStream = null,
+            signalNumber = 11, // SIGSEGV
+        )
+
+        verify(issueReporterStorage).persistFatalIssue(
+            eq(FAKE_TIME_STAMP),
+            issueReportCaptor.capture(),
+            reportTypeCaptor.capture(),
+        )
+        val buffer = ByteBuffer.wrap(issueReportCaptor.firstValue)
+        val report = Report.getRootAsReport(buffer)
+        assertThat(report.errorsLength).isEqualTo(1)
+        assertThat(reportTypeCaptor.firstValue).isEqualTo(ReportType.NativeCrash)
+
+        val capturedError = report.errors(0)!!
+        assertThat(capturedError.name).isEqualTo("SIGSEGV")
+        assertThat(capturedError.reason).isEqualTo("Segmentation violation (invalid memory reference)")
+        assertThat(capturedError.stackTraceLength).isEqualTo(0)
+        assertThat(report.threadDetails?.threadsLength).isEqualTo(0)
+        assertThat(report.binaryImagesLength).isEqualTo(0)
+    }
+
+    @Test
+    fun processAppExitReport_whenNativeCrashWithNullTraceAndUnknownSignal_shouldFallBackToDescription() {
+        val description = "Segmentation fault"
+
+        processor.processAppExitReport(
+            ReportType.NativeCrash,
+            FAKE_TIME_STAMP,
+            description,
+            traceInputStream = null,
+            signalNumber = 0,
+        )
+
+        verify(issueReporterStorage).persistFatalIssue(
+            eq(FAKE_TIME_STAMP),
+            issueReportCaptor.capture(),
+            reportTypeCaptor.capture(),
+        )
+        val buffer = ByteBuffer.wrap(issueReportCaptor.firstValue)
+        val report = Report.getRootAsReport(buffer)
+        val capturedError = report.errors(0)!!
+        assertThat(capturedError.name).isEqualTo(description)
+        assertThat(capturedError.reason).isEqualTo("Native crash")
+    }
+
     @Test
     fun processAppExitReport_withInvalidReason_shouldNotInteractWithStorage() {
         val description = null
@@ -285,6 +343,7 @@ class IssueReporterProcessorTest {
             FAKE_TIME_STAMP,
             description,
             traceInputStream,
+            signalNumber = 0,
         )
 
         verify(issueReporterStorage, never())