BIT-7817: implement skeleton crash reports for null traceInputStream on API level 30

Agent-Logs-Url: https://github.com/bitdriftlabs/capture-sdk/sessions/1eea7ae0-62e8-43c2-92b3-c17d8583429c

Co-authored-by: murki <216735+murki@users.noreply.github.com>

Author: Copilot

CHANGELOG.md

@@ -29,6 +29,8 @@
 
 **Fixed**
 
+- Fixed an issue where native crashes on API level 30 were silently discarded due to a missing tombstone trace. Skeleton crash reports with basic metadata but no stack traces are now generated in this case.
+
 - 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,15 +165,21 @@ internal class IssueReporter(
         val lastReasonResult = latestAppExitInfoProvider.get()
         if (lastReasonResult is LatestAppExitReasonResult.Valid) {
             val lastReason = lastReasonResult.applicationExitInfo
-            lastReason.traceInputStream?.use {
-                latestAppExitInfoProvider.convertExitReasonToFbsReportType(lastReason.reason)?.let { fatalIssueType ->
+            latestAppExitInfoProvider.convertExitReasonToFbsReportType(lastReason.reason)?.let { fatalIssueType ->
+                val traceInputStream = lastReason.traceInputStream
+                traceInputStream?.use {
                     issueReporterProcessor?.processAppExitReport(
                         fatalIssueType = fatalIssueType,
                         timestamp = lastReason.timestamp,
                         description = lastReason.description,
                         traceInputStream = it,
                     )
-                }
+                } ?: issueReporterProcessor?.processAppExitReport(
+                    fatalIssueType = fatalIssueType,
+                    timestamp = lastReason.timestamp,
+                    description = lastReason.description,
+                    traceInputStream = null,
+                )
             }
         }
     }

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

@@ -24,13 +24,15 @@ 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.
      */
     fun processAppExitReport(
         fatalIssueType: Byte,
         timestamp: Long,
         description: String? = null,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream? = null,
     )
 
     /**

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

@@ -100,13 +100,15 @@ 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.
      */
     override fun processAppExitReport(
         fatalIssueType: Byte,
         timestamp: Long,
         description: String?,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream?,
     ) {
         runCatching {
             if (fatalIssueType == ReportType.AppNotResponding) {

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

@@ -41,8 +41,12 @@ internal object NativeCrashProcessor {
         appMetrics: Int,
         deviceMetrics: Int,
         description: String?,
-        traceInputStream: InputStream,
+        traceInputStream: InputStream?,
     ): Int {
+        if (traceInputStream == null) {
+            return createSkeletonReport(builder, sdk, appMetrics, deviceMetrics, description)
+        }
+
         val tombstone = Tombstone.parseFrom(traceInputStream)
         val nativeErrors = mutableListOf<Int>()
         val threadOffsets = mutableListOf<Int>()
@@ -139,6 +143,43 @@ internal object NativeCrashProcessor {
         )
     }
 
+    private fun createSkeletonReport(
+        builder: FlatBufferBuilder,
+        sdk: Int,
+        appMetrics: Int,
+        deviceMetrics: Int,
+        description: String?,
+    ): Int {
+        val name = builder.createString(description ?: "Native crash")
+        val reason = builder.createString("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?,

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

@@ -275,6 +275,35 @@ 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,
+        )
+
+        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(description)
+        assertThat(capturedError.reason).isEqualTo("Native crash")
+        assertThat(capturedError.stackTraceLength).isEqualTo(0)
+        assertThat(report.threadDetails?.threadsLength).isEqualTo(0)
+        assertThat(report.binaryImagesLength).isEqualTo(0)
+    }
+
     @Test
     fun processAppExitReport_withInvalidReason_shouldNotInteractWithStorage() {
         val description = null