@grafana/faro-react-native 1.2.1 → 1.3.0

package/android/src/main/java/com/grafana/faro/reactnative/FaroUncaughtExceptionHandler.kt

@@ -0,0 +1,62 @@
+package com.grafana.faro.reactnative
+
+import android.content.Context
+import android.util.Log
+
+/**
+ * Captures Java/Kotlin stack traces for fatal crashes before the process exits.
+ *
+ * ApplicationExitInfo.traceInputStream is often null on emulators and some devices
+ * (observed on Android 16 / API 36). Without this handler the SDK cannot report
+ * native frames for retrace.
+ */
+internal class FaroUncaughtExceptionHandler(
+    private val context: Context,
+    private val originalHandler: Thread.UncaughtExceptionHandler?,
+) : Thread.UncaughtExceptionHandler {
+
+    override fun uncaughtException(thread: Thread, throwable: Throwable) {
+        try {
+            val trace = Log.getStackTraceString(throwable).trim()
+            if (trace.isNotEmpty()) {
+                FaroCrashTraceCache.savePendingCrashTrace(context, trace, System.currentTimeMillis())
+            }
+        } catch (_: Throwable) {
+            // Never interfere with the original crash path.
+        } finally {
+            originalHandler?.uncaughtException(thread, throwable)
+                ?: run {
+                    @Suppress("DEPRECATION")
+                    android.os.Process.killProcess(android.os.Process.myPid())
+                    System.exit(10)
+                }
+        }
+    }
+
+    companion object {
+        @Volatile
+        private var installed = false
+
+        @JvmStatic
+        fun install(context: Context) {
+            if (installed) {
+                return
+            }
+            synchronized(this) {
+                if (installed) {
+                    return
+                }
+                val appContext = context.applicationContext
+                val current = Thread.getDefaultUncaughtExceptionHandler()
+                if (current is FaroUncaughtExceptionHandler) {
+                    installed = true
+                    return
+                }
+                Thread.setDefaultUncaughtExceptionHandler(
+                    FaroUncaughtExceptionHandler(appContext, current)
+                )
+                installed = true
+            }
+        }
+    }
+}

package/android/src/main/java/com/grafana/faro/reactnative/TombstoneBacktraceFormatter.kt

@@ -0,0 +1,117 @@
+package com.grafana.faro.reactnative
+
+/**
+ * Converts Android tombstone data into the text backtrace format expected by the Faro
+ * collector's NDK retrace pipeline.
+ */
+internal object TombstoneBacktraceFormatter {
+
+    private val nativeFrameLine = Regex("""^\s*#\d+\s+pc\s+(?:0x)?[0-9a-fA-F]+\s+\S+""")
+
+    fun looksLikeNativeBacktrace(text: String): Boolean {
+        if (text.isBlank()) {
+            return false
+        }
+        return text.lineSequence().any { nativeFrameLine.containsMatchIn(it) }
+    }
+
+    fun looksLikeTextTombstone(text: String): Boolean {
+        if (text.isBlank()) {
+            return false
+        }
+        if (looksLikeNativeBacktrace(text)) {
+            return true
+        }
+        return text.contains("*** *** ***") || text.contains("backtrace:")
+    }
+
+    fun format(tombstone: ParsedTombstoneData): FormattedTombstone {
+        val signalLabel = formatSignal(tombstone.signalName, tombstone.signalNumber)
+        val crashThread = tombstone.threads[tombstone.tid]
+            ?: tombstone.threads.values.firstOrNull { it.backtrace.isNotEmpty() }
+        val frames = crashThread?.backtrace.orEmpty()
+
+        val lines = mutableListOf<String>()
+        lines.add("*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***")
+        lines.add("ABI: '${tombstone.arch}'")
+        if (tombstone.pid > 0) {
+            lines.add("pid: ${tombstone.pid}, tid: ${tombstone.tid}, name: ${crashThread?.name.orEmpty()}")
+        }
+        if (signalLabel.isNotEmpty()) {
+            lines.add("signal $signalLabel")
+        }
+        if (tombstone.abortMessage.isNotBlank()) {
+            lines.add("Abort message: '${tombstone.abortMessage.trim()}'")
+        }
+        lines.add("backtrace:")
+
+        frames.forEachIndexed { index, frame ->
+            lines.add(formatFrameLine(index, frame, tombstone.memoryMappings))
+        }
+
+        return FormattedTombstone(
+            text = lines.joinToString("\n").trim(),
+            signal = signalLabel,
+        )
+    }
+
+    data class FormattedTombstone(
+        val text: String,
+        val signal: String,
+    )
+
+    private fun formatSignal(name: String, number: Int): String {
+        if (name.isBlank() && number == 0) {
+            return ""
+        }
+        val signalName = name.trim().ifEmpty { "UNKNOWN" }
+        return if (number != 0) {
+            "$signalName ($number)"
+        } else {
+            signalName
+        }
+    }
+
+    private fun formatFrameLine(
+        index: Int,
+        frame: ParsedBacktraceFrame,
+        mappings: List<ParsedMemoryMapping>,
+    ): String {
+        val pc = frame.pc
+        val pcHex = pc.toString(16).padStart(16, '0')
+        val library = resolveLibrary(frame, mappings)
+        val suffix = buildString {
+            if (frame.functionName.isNotBlank()) {
+                append(" (")
+                append(frame.functionName)
+                if (frame.functionOffset > 0) {
+                    append('+')
+                    append(frame.functionOffset)
+                }
+                append(')')
+            }
+            if (frame.buildId.isNotBlank()) {
+                append(" (BuildId: ")
+                append(frame.buildId.trim())
+                append(')')
+            }
+        }
+        return "      #${String.format("%02d", index)} pc $pcHex  $library$suffix"
+    }
+
+    private fun resolveLibrary(
+        frame: ParsedBacktraceFrame,
+        mappings: List<ParsedMemoryMapping>,
+    ): String {
+        if (frame.fileName.isNotBlank()) {
+            return frame.fileName.trim()
+        }
+
+        val mapping = mappings.firstOrNull { frame.pc >= it.beginAddress && frame.pc < it.endAddress }
+        if (mapping != null && mapping.mappingName.isNotBlank()) {
+            return mapping.mappingName
+        }
+
+        return "unknown"
+    }
+}

package/android/src/main/java/com/grafana/faro/reactnative/TombstoneModels.kt

@@ -0,0 +1,35 @@
+package com.grafana.faro.reactnative
+
+internal data class ParsedTombstoneData(
+    val arch: String = "unknown",
+    val pid: Int = 0,
+    val tid: Int = 0,
+    val signalName: String = "",
+    val signalNumber: Int = 0,
+    val abortMessage: String = "",
+    val threads: Map<Int, ParsedThreadData> = emptyMap(),
+    val memoryMappings: List<ParsedMemoryMapping> = emptyList(),
+)
+
+internal data class ParsedThreadData(
+    val id: Int = 0,
+    val name: String = "",
+    val backtrace: List<ParsedBacktraceFrame> = emptyList(),
+)
+
+internal data class ParsedBacktraceFrame(
+    val relPc: Long = 0L,
+    val pc: Long = 0L,
+    val functionName: String = "",
+    val functionOffset: Long = 0L,
+    val fileName: String = "",
+    val buildId: String = "",
+)
+
+internal data class ParsedMemoryMapping(
+    val beginAddress: Long = 0L,
+    val endAddress: Long = 0L,
+    val mappingName: String = "",
+    val buildId: String = "",
+    val loadBias: Long = 0L,
+)

package/android/src/main/java/com/grafana/faro/reactnative/TombstoneWireParser.kt

@@ -0,0 +1,235 @@
+package com.grafana.faro.reactnative
+
+import com.google.protobuf.CodedInputStream
+import com.google.protobuf.InvalidProtocolBufferException
+import com.google.protobuf.WireFormat
+
+/**
+ * Parses Android tombstone protobuf without generated [TombstoneProtos.Tombstone.parseFrom].
+ *
+ * Release builds (R8) can strip protobuf generated fields, breaking parseFrom even when the wire
+ * bytes are valid. This parser is R8-safe.
+ */
+internal object TombstoneWireParser {
+
+    private val architectureLabels = mapOf(
+        0 to "arm",
+        1 to "arm64",
+        2 to "x86",
+        3 to "x86_64",
+        4 to "riscv64",
+        5 to "unknown",
+    )
+
+    fun parse(bytes: ByteArray): ParsedTombstoneData? {
+        if (bytes.isEmpty()) {
+            return null
+        }
+
+        parseMessage(bytes)?.let { parsed ->
+            if (parsed.threads.values.any { it.backtrace.isNotEmpty() }) {
+                return parsed
+            }
+        }
+
+        // Some Android builds wrap the tombstone in an outer message; scan nested payloads.
+        for (nested in extractLengthDelimitedMessages(bytes)) {
+            parseMessage(nested)?.let { parsed ->
+                if (parsed.threads.values.any { it.backtrace.isNotEmpty() }) {
+                    return parsed
+                }
+            }
+        }
+
+        return null
+    }
+
+    private fun parseMessage(bytes: ByteArray): ParsedTombstoneData? {
+        return try {
+            val input = CodedInputStream.newInstance(bytes)
+            var arch = "unknown"
+            var pid = 0
+            var tid = 0
+            var signalName = ""
+            var signalNumber = 0
+            var abortMessage = ""
+            val threads = linkedMapOf<Int, ParsedThreadData>()
+            val memoryMappings = mutableListOf<ParsedMemoryMapping>()
+
+            while (true) {
+                val tag = input.readTag()
+                if (tag == 0) {
+                    break
+                }
+
+                when (WireFormat.getTagFieldNumber(tag)) {
+                    1 -> arch = architectureLabels[input.readEnum()] ?: "unknown"
+                    5 -> pid = input.readUInt32()
+                    6 -> tid = input.readUInt32()
+                    10 -> parseSignal(input.readBytes().toByteArray())?.let { signal ->
+                        signalName = signal.first
+                        signalNumber = signal.second
+                    }
+                    14 -> abortMessage = input.readStringRequireUtf8()
+                    16 -> parseThreadMapEntry(input.readBytes().toByteArray())?.let { (threadId, thread) ->
+                        threads[threadId] = thread
+                    }
+                    17 -> memoryMappings.add(parseMemoryMapping(input.readBytes().toByteArray()))
+                    else -> input.skipField(tag)
+                }
+            }
+
+            ParsedTombstoneData(
+                arch = arch,
+                pid = pid,
+                tid = tid,
+                signalName = signalName,
+                signalNumber = signalNumber,
+                abortMessage = abortMessage,
+                threads = threads,
+                memoryMappings = memoryMappings,
+            )
+        } catch (_: InvalidProtocolBufferException) {
+            null
+        } catch (_: IndexOutOfBoundsException) {
+            null
+        }
+    }
+
+    private fun parseSignal(bytes: ByteArray): Pair<String, Int>? {
+        val input = CodedInputStream.newInstance(bytes)
+        var number = 0
+        var name = ""
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            when (WireFormat.getTagFieldNumber(tag)) {
+                1 -> number = input.readInt32()
+                2 -> name = input.readStringRequireUtf8()
+                else -> input.skipField(tag)
+            }
+        }
+        return name to number
+    }
+
+    private fun parseThreadMapEntry(bytes: ByteArray): Pair<Int, ParsedThreadData>? {
+        val input = CodedInputStream.newInstance(bytes)
+        var threadId = 0
+        var threadBytes: ByteArray? = null
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            when (WireFormat.getTagFieldNumber(tag)) {
+                1 -> threadId = input.readUInt32()
+                2 -> threadBytes = input.readBytes().toByteArray()
+                else -> input.skipField(tag)
+            }
+        }
+        val thread = threadBytes?.let { parseThread(it) } ?: return null
+        return threadId to thread
+    }
+
+    private fun parseThread(bytes: ByteArray): ParsedThreadData {
+        val input = CodedInputStream.newInstance(bytes)
+        var id = 0
+        var name = ""
+        val backtrace = mutableListOf<ParsedBacktraceFrame>()
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            when (WireFormat.getTagFieldNumber(tag)) {
+                1 -> id = input.readInt32()
+                2 -> name = input.readStringRequireUtf8()
+                4 -> backtrace.add(parseBacktraceFrame(input.readBytes().toByteArray()))
+                else -> input.skipField(tag)
+            }
+        }
+        return ParsedThreadData(id = id, name = name, backtrace = backtrace)
+    }
+
+    private fun parseBacktraceFrame(bytes: ByteArray): ParsedBacktraceFrame {
+        val input = CodedInputStream.newInstance(bytes)
+        var relPc = 0L
+        var pc = 0L
+        var functionName = ""
+        var functionOffset = 0L
+        var fileName = ""
+        var buildId = ""
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            when (WireFormat.getTagFieldNumber(tag)) {
+                1 -> relPc = input.readUInt64()
+                2 -> pc = input.readUInt64()
+                4 -> functionName = input.readStringRequireUtf8()
+                5 -> functionOffset = input.readUInt64()
+                6 -> fileName = input.readStringRequireUtf8()
+                8 -> buildId = input.readStringRequireUtf8()
+                else -> input.skipField(tag)
+            }
+        }
+        return ParsedBacktraceFrame(
+            relPc = relPc,
+            pc = pc,
+            functionName = functionName,
+            functionOffset = functionOffset,
+            fileName = fileName,
+            buildId = buildId,
+        )
+    }
+
+    private fun parseMemoryMapping(bytes: ByteArray): ParsedMemoryMapping {
+        val input = CodedInputStream.newInstance(bytes)
+        var beginAddress = 0L
+        var endAddress = 0L
+        var mappingName = ""
+        var buildId = ""
+        var loadBias = 0L
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            when (WireFormat.getTagFieldNumber(tag)) {
+                1 -> beginAddress = input.readUInt64()
+                2 -> endAddress = input.readUInt64()
+                7 -> mappingName = input.readStringRequireUtf8()
+                8 -> buildId = input.readStringRequireUtf8()
+                9 -> loadBias = input.readUInt64()
+                else -> input.skipField(tag)
+            }
+        }
+        return ParsedMemoryMapping(
+            beginAddress = beginAddress,
+            endAddress = endAddress,
+            mappingName = mappingName,
+            buildId = buildId,
+            loadBias = loadBias,
+        )
+    }
+
+    private fun extractLengthDelimitedMessages(bytes: ByteArray): List<ByteArray> {
+        val nested = mutableListOf<ByteArray>()
+        val input = CodedInputStream.newInstance(bytes)
+        while (true) {
+            val tag = input.readTag()
+            if (tag == 0) {
+                break
+            }
+            if (WireFormat.getTagWireType(tag) == WireFormat.WIRETYPE_LENGTH_DELIMITED) {
+                nested.add(input.readBytes().toByteArray())
+            } else {
+                input.skipField(tag)
+            }
+        }
+        return nested
+    }
+}

package/android/src/main/proto/tombstone.proto

@@ -0,0 +1,62 @@
+// Android tombstone protobuf (AOSP debuggerd/proto/tombstone.proto).
+// Used to decode ApplicationExitInfo.traceInputStream for REASON_CRASH_NATIVE (API 31+).
+// https://developer.android.com/reference/android/app/ApplicationExitInfo#getTraceInputStream()
+
+syntax = "proto3";
+
+option java_package = "com.grafana.faro.reactnative.tombstone";
+option java_outer_classname = "TombstoneProtos";
+
+message Tombstone {
+  Architecture arch = 1;
+  string build_fingerprint = 2;
+  string timestamp = 4;
+  uint32 pid = 5;
+  uint32 tid = 6;
+  Signal signal_info = 10;
+  string abort_message = 14;
+  map<uint32, Thread> threads = 16;
+  repeated MemoryMapping memory_mappings = 17;
+}
+
+enum Architecture {
+  ARM32 = 0;
+  ARM64 = 1;
+  X86 = 2;
+  X86_64 = 3;
+  RISCV64 = 4;
+  NONE = 5;
+}
+
+message Signal {
+  int32 number = 1;
+  string name = 2;
+  int32 code = 3;
+  string code_name = 4;
+}
+
+message Thread {
+  int32 id = 1;
+  string name = 2;
+  repeated BacktraceFrame current_backtrace = 4;
+}
+
+message BacktraceFrame {
+  uint64 rel_pc = 1;
+  uint64 pc = 2;
+  uint64 sp = 3;
+  string function_name = 4;
+  uint64 function_offset = 5;
+  string file_name = 6;
+  uint64 file_map_offset = 7;
+  string build_id = 8;
+}
+
+message MemoryMapping {
+  uint64 begin_address = 1;
+  uint64 end_address = 2;
+  uint64 offset = 3;
+  string mapping_name = 7;
+  string build_id = 8;
+  uint64 load_bias = 9;
+}

package/android/src/test/java/com/grafana/faro/reactnative/AnrStackFiltersTest.kt

@@ -0,0 +1,28 @@
+package com.grafana.faro.reactnative
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class AnrStackFiltersTest {
+
+    @Test
+    fun isCrashHandlerStack_detectsFrameworkCrashKillerFrames() {
+        val stack = """
+            at com.android.internal.os.RuntimeInit${'$'}KillApplicationHandler.uncaughtException(RuntimeInit.java:174)
+            at java.lang.Thread.dispatchUncaughtException(Thread.java:2306)
+        """.trimIndent()
+
+        assertTrue(AnrStackFilters.isCrashHandlerStack(stack))
+    }
+
+    @Test
+    fun isCrashHandlerStack_allowsBlockedAppFrames() {
+        val stack = """
+            at com.example.MainActivity.block(MainActivity.kt:42)
+            at android.os.Handler.dispatchMessage(Handler.java:102)
+        """.trimIndent()
+
+        assertFalse(AnrStackFilters.isCrashHandlerStack(stack))
+    }
+}

package/android/src/test/java/com/grafana/faro/reactnative/AnrThreadDumpParserTest.kt

@@ -0,0 +1,38 @@
+package com.grafana.faro.reactnative
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class AnrThreadDumpParserTest {
+
+    @Test
+    fun extractMainThreadStack_parsesDalvikThreadDump() {
+        val dump = """
+            "main" prio=5 tid=1 Runnable
+              | group="main" sCount=0 ucsCount=0 flags=0 obj=0x0 self=0x0
+              at com.example.MainActivity.block(MainActivity.kt:42)
+              at android.app.Activity.performCreate(Activity.java:9000)
+            "ReferenceQueueDaemon" prio=5 tid=6 Waiting
+              at java.lang.Object.wait(Native method)
+        """.trimIndent()
+
+        val stack = AnrThreadDumpParser.extractMainThreadStack(dump)
+
+        assertTrue(stack.contains("com.example.MainActivity.block"))
+        assertFalse(stack.contains("ReferenceQueueDaemon"))
+    }
+
+    @Test
+    fun extractMainThreadStack_parsesFlatAtLines() {
+        val dump = """
+            at com.example.MainActivity.block(MainActivity.kt:42)
+            at android.app.Activity.performCreate(Activity.java:9000)
+        """.trimIndent()
+
+        val stack = AnrThreadDumpParser.extractMainThreadStack(dump)
+
+        assertTrue(stack.contains("com.example.MainActivity.block(MainActivity.kt:42)"))
+        assertTrue(stack.contains("android.app.Activity.performCreate(Activity.java:9000)"))
+    }
+}

package/android/src/test/java/com/grafana/faro/reactnative/FaroAnrCacheTest.kt

@@ -0,0 +1,81 @@
+package com.grafana.faro.reactnative
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(manifest = Config.NONE, sdk = [30])
+class FaroAnrCacheTest {
+
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        context = ApplicationProvider.getApplicationContext()
+        context.getSharedPreferences("com.grafana.faro.anr_cache", Context.MODE_PRIVATE)
+            .edit()
+            .clear()
+            .commit()
+    }
+
+    @Test
+    fun savePendingAnr_dedupesExactTimestamp() {
+        val payload = """{"type":"ANR","timestamp":1000,"stacktrace":"at foo"}"""
+
+        FaroAnrCache.savePendingAnr(context, payload)
+        FaroAnrCache.savePendingAnr(context, payload)
+
+        assertEquals(1, FaroAnrCache.getPendingAnrs(context).size)
+    }
+
+    @Test
+    fun savePendingAnr_collapsesNearbyTimestamps() {
+        FaroAnrCache.savePendingAnr(
+            context,
+            """{"type":"ANR","timestamp":1000,"stacktrace":"at foo"}""",
+        )
+        FaroAnrCache.savePendingAnr(
+            context,
+            """{"type":"ANR","timestamp":6000,"stacktrace":"at bar"}""",
+        )
+
+        assertEquals(1, FaroAnrCache.getPendingAnrs(context).size)
+    }
+
+    @Test
+    fun hasNearbyAnrDetection_matchesWithinWindow() {
+        FaroAnrCache.savePendingAnr(
+            context,
+            """{"type":"ANR","timestamp":1000,"stacktrace":"at foo"}""",
+        )
+
+        assertTrue(FaroAnrCache.hasNearbyAnrDetection(context, 5000))
+        assertFalse(FaroAnrCache.hasNearbyAnrDetection(context, 20000))
+    }
+
+    @Test
+    fun acknowledgeAnrs_removesMatchingEntries() {
+        FaroAnrCache.savePendingAnr(
+            context,
+            """{"type":"ANR","timestamp":1000,"stacktrace":"at foo"}""",
+        )
+        FaroAnrCache.savePendingAnr(
+            context,
+            """{"type":"ANR","timestamp":20000,"stacktrace":"at bar"}""",
+        )
+
+        FaroAnrCache.acknowledgeAnrs(context, listOf(1000L))
+
+        val remaining = FaroAnrCache.getPendingAnrs(context)
+        assertEquals(1, remaining.size)
+        assertTrue(remaining[0].contains("\"timestamp\":20000"))
+    }
+}