@grafana/faro-react-native 1.2.0 → 1.3.0

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

@@ -4,9 +4,8 @@ import android.app.ActivityManager
 import android.app.ApplicationExitInfo
 import android.content.Context
 import android.os.Build
+import android.util.Log
 import org.json.JSONObject
-import java.io.BufferedReader
-import java.io.InputStreamReader
 
 /**
  * Android Crash Reporter using ApplicationExitInfo API (Android 11+).
@@ -23,7 +22,6 @@ import java.io.InputStreamReader
  * ## Supported Exit Reasons
  * - REASON_CRASH: Java/Kotlin exception crash
  * - REASON_CRASH_NATIVE: Native (NDK) crash
- * - REASON_ANR: Application Not Responding
  * - REASON_LOW_MEMORY: Killed due to low memory
  * - REASON_EXCESSIVE_RESOURCE_USAGE: Killed due to excessive resource usage
  *
@@ -36,6 +34,17 @@ object FaroCrashReporter {
     private const val PREFS_NAME = "com.grafana.faro.crash_reporter"
     private const val KEY_LAST_PROCESSED_TIMESTAMP = "last_processed_timestamp"
 
+    /**
+     * Persists a text tombstone backtrace for the next [REASON_CRASH_NATIVE] replay.
+     *
+     * Use when [ApplicationExitInfo.getTraceInputStream] is null (common on emulators)
+     * and the app can capture a native backtrace immediately before a fatal native exit.
+     */
+    @JvmStatic
+    fun cachePendingNativeCrashTrace(context: Context, trace: String) {
+        FaroNativeCrashTrace.cachePendingNativeCrashTrace(context, trace)
+    }
+
     /**
      * Gets crash reports from previous sessions as JSON strings.
      *
@@ -48,6 +57,7 @@ object FaroCrashReporter {
      */
     @JvmStatic
     fun getCrashReports(context: Context): List<String>? {
+        FaroUncaughtExceptionHandler.install(context)
         // ApplicationExitInfo requires Android 11 (API 30)
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             return null
@@ -70,32 +80,47 @@ object FaroCrashReporter {
         val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
         val lastProcessedTimestamp = prefs.getLong(KEY_LAST_PROCESSED_TIMESTAMP, 0)
 
+        val pendingTrace = FaroCrashTraceCache.peekPendingCrashTrace(context)
+        var usedPendingTrace = false
+
         val crashReports = mutableListOf<String>()
         var latestTimestamp = lastProcessedTimestamp
-
-        for (exitInfo in exitInfoList) {
-            // Skip already processed entries
-            if (exitInfo.timestamp <= lastProcessedTimestamp) {
-                continue
-            }
-
-            // Only process crash-related exit reasons
-            if (!isCrashReason(exitInfo.reason)) {
+        val reportedTimestamps = mutableSetOf<Long>()
+
+        // Android can return multiple ApplicationExitInfo rows for one fatal exit
+        // (e.g. REASON_CRASH plus a companion row with no trace). Collapse to one
+        // report per timestamp and share the UncaughtExceptionHandler cache.
+        val candidates = exitInfoList
+            .filter { it.timestamp > lastProcessedTimestamp && isCrashReason(it.reason) }
+            .groupBy { it.timestamp }
+            .mapValues { (_, exits) -> pickBestExitInfo(exits) }
+            .toSortedMap()
+
+        for ((timestamp, exitInfo) in candidates) {
+            if (reportedTimestamps.contains(timestamp)) {
                 continue
             }
 
-            // Track the latest timestamp
             if (exitInfo.timestamp > latestTimestamp) {
                 latestTimestamp = exitInfo.timestamp
             }
 
-            // Convert to JSON
-            val jsonString = exportExitInfoAsJSON(exitInfo)
+            val jsonString = exportExitInfoAsJSON(context, exitInfo, pendingTrace) { consumed ->
+                if (consumed) {
+                    usedPendingTrace = true
+                }
+            }
+
             if (jsonString != null) {
                 crashReports.add(jsonString)
+                reportedTimestamps.add(timestamp)
             }
         }
 
+        if (usedPendingTrace) {
+            FaroCrashTraceCache.clearPendingCrashTrace(context)
+        }
+
         // Update the last processed timestamp
         if (latestTimestamp > lastProcessedTimestamp) {
             prefs.edit()
@@ -107,7 +132,41 @@ object FaroCrashReporter {
     }
 
     /**
-     * Check if the exit reason indicates a crash or ANR.
+     * Prefer the row that already carries a trace stream; otherwise keep the first entry.
+     */
+    private fun pickBestExitInfo(exits: List<ApplicationExitInfo>): ApplicationExitInfo {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return exits.first()
+        }
+
+        return exits.maxByOrNull { exit ->
+            var score = 0
+            if (exit.reason == ApplicationExitInfo.REASON_CRASH) {
+                score += 4
+            } else if (exit.reason == ApplicationExitInfo.REASON_CRASH_NATIVE) {
+                score += 3
+            }
+            val trace = readExitTrace(exit).text
+            if (trace.isNotEmpty()) {
+                score += 2
+            }
+            if (TombstoneBacktraceFormatter.looksLikeNativeBacktrace(trace)) {
+                score += 3
+            }
+            if (hasExceptionHeader(trace)) {
+                score += 2
+            }
+            val description = exit.description?.trim().orEmpty()
+            if (description.isNotEmpty()) {
+                score += 1
+            }
+            score
+        } ?: exits.first()
+    }
+
+    /**
+     * Check if the exit reason should be replayed as a previous-session crash.
+     * ANRs are excluded: ANRInstrumentation reports them with the blocked main-thread stack.
      */
     private fun isCrashReason(reason: Int): Boolean {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
@@ -117,7 +176,6 @@ object FaroCrashReporter {
         return when (reason) {
             ApplicationExitInfo.REASON_CRASH,
             ApplicationExitInfo.REASON_CRASH_NATIVE,
-            ApplicationExitInfo.REASON_ANR,
             ApplicationExitInfo.REASON_LOW_MEMORY,
             ApplicationExitInfo.REASON_EXCESSIVE_RESOURCE_USAGE -> true
             else -> false
@@ -127,7 +185,12 @@ object FaroCrashReporter {
     /**
      * Convert ApplicationExitInfo to JSON string matching iOS format.
      */
-    private fun exportExitInfoAsJSON(exitInfo: ApplicationExitInfo): String? {
+    private fun exportExitInfoAsJSON(
+        context: Context,
+        exitInfo: ApplicationExitInfo,
+        pendingTrace: FaroCrashTraceCache.PendingTrace?,
+        onPendingTraceUsed: (Boolean) -> Unit,
+    ): String? {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
             return null
         }
@@ -145,7 +208,10 @@ object FaroCrashReporter {
             json.put("status", exitInfo.status)
 
             // Description - human-readable description
-            json.put("description", exitInfo.description ?: getDefaultDescription(exitInfo.reason))
+            val rawDescription = exitInfo.description?.trim().orEmpty()
+            val description = rawDescription.takeIf { it.isNotEmpty() && !isGenericDescription(it) }
+                ?: getDefaultDescription(exitInfo.reason)
+            json.put("description", description)
 
             // Process info
             json.put("processName", exitInfo.processName ?: "")
@@ -154,10 +220,57 @@ object FaroCrashReporter {
             // Importance (Android-specific)
             json.put("importance", exitInfo.importance)
 
-            // Stack trace (if available)
-            val trace = getTraceInfo(exitInfo)
+            if (isAnrTimeoutDescription(rawDescription)) {
+                // ANRInstrumentation reports these with type ANR.
+                return null
+            }
+
+            val parsedExitTrace = readExitTrace(exitInfo)
+            val cachedTrace = cachedTraceForExit(context, exitInfo, pendingTrace)
+            val trace = resolveCrashTrace(
+                exitTrace = parsedExitTrace.text,
+                cachedTrace = cachedTrace,
+                isNativeCrash = exitInfo.reason == ApplicationExitInfo.REASON_CRASH_NATIVE,
+            )
+
+            if (FaroAnrCache.hasNearbyAnrDetection(context, exitInfo.timestamp) &&
+                trace.isEmpty() &&
+                !hasMeaningfulDescription(exitInfo)
+            ) {
+                // Suppress empty generic crash rows that duplicate a nearby ANR report.
+                // Real crashes with a trace still surface even when an ANR happened nearby.
+                return null
+            }
+
             if (trace.isNotEmpty()) {
+                if (parsedExitTrace.text.isEmpty() && cachedTrace.isNotEmpty()) {
+                    onPendingTraceUsed(true)
+                } else if (cachedTrace.isNotEmpty() && trace == cachedTrace) {
+                    onPendingTraceUsed(true)
+                }
                 json.put("trace", trace)
+
+                val signal = parsedExitTrace.signal.trim()
+                if (signal.isNotEmpty()) {
+                    json.put("signal", signal)
+                }
+
+                if (TombstoneBacktraceFormatter.looksLikeNativeBacktrace(trace)) {
+                    val preview = trace.lineSequence().firstOrNull { it.contains("#00 pc") }?.trim().orEmpty()
+                    Log.i(
+                        TAG,
+                        "[Faro crash native] Exporting crash report with tombstone trace (${trace.lineSequence().count()} lines) preview=$preview",
+                    )
+                }
+            } else if (!hasMeaningfulDescription(exitInfo)) {
+                // Skip duplicate/no-signal rows that would surface as generic "crash" in the UI.
+                if (exitInfo.reason == ApplicationExitInfo.REASON_CRASH_NATIVE) {
+                    Log.w(
+                        TAG,
+                        "[Faro crash native] Skipping CRASH_NATIVE without tombstone trace (traceInputStream was null and no cached native backtrace)",
+                    )
+                }
+                return null
             }
 
             json.toString()
@@ -166,6 +279,115 @@ object FaroCrashReporter {
         }
     }
 
+    private fun cachedTraceForExit(
+        context: Context,
+        exitInfo: ApplicationExitInfo,
+        pendingTrace: FaroCrashTraceCache.PendingTrace?,
+    ): String {
+        val cached = FaroCrashTraceCache.traceForExitTimestamp(context, pendingTrace, exitInfo.timestamp)
+        if (cached.isEmpty()) {
+            return ""
+        }
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R &&
+            exitInfo.reason == ApplicationExitInfo.REASON_CRASH_NATIVE
+        ) {
+            cached.takeIf { TombstoneBacktraceFormatter.looksLikeNativeBacktrace(it) }.orEmpty()
+        } else {
+            cached
+        }
+    }
+
+    /**
+     * ApplicationExitInfo traces on emulators often contain only "at …" frame lines.
+     * UncaughtExceptionHandler cache includes the exception class + message header
+     * required for plugin titles (e.g. java.lang.NullPointerException).
+     */
+    private fun resolveCrashTrace(
+        exitTrace: String,
+        cachedTrace: String,
+        isNativeCrash: Boolean,
+    ): String {
+        val exit = exitTrace.trim()
+        val cached = cachedTrace.trim()
+
+        if (isNativeCrash) {
+            if (TombstoneBacktraceFormatter.looksLikeNativeBacktrace(exit)) {
+                return exit
+            }
+            if (TombstoneBacktraceFormatter.looksLikeNativeBacktrace(cached)) {
+                return cached
+            }
+            return exit.ifEmpty { cached }
+        }
+
+        if (exit.isEmpty()) {
+            return cached
+        }
+        if (cached.isEmpty()) {
+            return exit
+        }
+
+        val exitHasHeader = hasExceptionHeader(exit)
+        val cachedHasHeader = hasExceptionHeader(cached)
+
+        return when {
+            cachedHasHeader && !exitHasHeader -> cached
+            exitHasHeader && !cachedHasHeader -> exit
+            cached.length > exit.length -> cached
+            else -> exit
+        }
+    }
+
+    private fun readExitTrace(exitInfo: ApplicationExitInfo): ApplicationExitTraceReader.ParsedExitTrace {
+        return ApplicationExitTraceReader.read(exitInfo)
+    }
+
+    private fun isAnrTimeoutDescription(description: String): Boolean {
+        val normalized = description.trim().lowercase()
+        if (normalized.isEmpty()) {
+            return false
+        }
+        return normalized.contains("input dispatching timed out") ||
+            normalized.contains("not responding") ||
+            normalized.contains("application not responding")
+    }
+
+    private fun hasExceptionHeader(trace: String): Boolean {
+        return trace.lineSequence().any { line ->
+            val trimmed = line.trim()
+            trimmed.isNotEmpty() &&
+                !trimmed.startsWith("at ") &&
+                !trimmed.startsWith("#") &&
+                trimmed.contains('.') &&
+                !trimmed.startsWith("Caused by:")
+        }
+    }
+
+    private fun isGenericDescription(description: String): Boolean {
+        val normalized = description.trim().lowercase()
+        return normalized in setOf(
+            "crash",
+            "native crash",
+            "application crash",
+            "application crash (java/kotlin)",
+            "application crash (native)",
+        )
+    }
+
+    private fun hasMeaningfulDescription(exitInfo: ApplicationExitInfo): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return false
+        }
+
+        val description = exitInfo.description?.trim().orEmpty()
+        if (description.isEmpty()) {
+            return false
+        }
+
+        return !isGenericDescription(description)
+    }
+
     /**
      * Get human-readable reason string from exit reason code.
      */
@@ -209,33 +431,4 @@ object FaroCrashReporter {
             else -> "Application crash"
         }
     }
-
-    /**
-     * Get stack trace info from ApplicationExitInfo.
-     */
-    private fun getTraceInfo(exitInfo: ApplicationExitInfo): String {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
-            return ""
-        }
-
-        return try {
-            val traceInputStream = exitInfo.traceInputStream ?: return ""
-            val reader = BufferedReader(InputStreamReader(traceInputStream))
-            val trace = StringBuilder()
-            var lineCount = 0
-            val maxLines = 100 // Limit trace length
-
-            reader.useLines { lines ->
-                for (line in lines) {
-                    if (lineCount >= maxLines) break
-                    trace.appendLine(line)
-                    lineCount++
-                }
-            }
-
-            trace.toString().trim()
-        } catch (e: Exception) {
-            ""
-        }
-    }
 }

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

@@ -0,0 +1,75 @@
+package com.grafana.faro.reactnative
+
+import android.content.Context
+
+/**
+ * Persists a pending native crash stack between process death and the next launch.
+ */
+internal object FaroCrashTraceCache {
+    private const val PREFS_NAME = "com.grafana.faro.crash_trace_cache"
+    private const val KEY_TRACE = "pending_trace"
+    private const val KEY_TIMESTAMP = "pending_timestamp"
+    private const val MAX_TIMESTAMP_DELTA_MS = 10_000L
+
+    fun savePendingCrashTrace(context: Context, trace: String, timestampMs: Long) {
+        // commit() not apply(): the process is killed immediately after uncaughtException.
+        context.applicationContext
+            .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putString(KEY_TRACE, trace)
+            .putLong(KEY_TIMESTAMP, timestampMs)
+            .commit()
+    }
+
+    data class PendingTrace(val trace: String, val timestampMs: Long)
+
+    /**
+     * Returns a cached trace without clearing it so multiple ApplicationExitInfo
+     * rows for the same crash can share the UncaughtExceptionHandler stack.
+     */
+    fun peekPendingCrashTrace(context: Context): PendingTrace? {
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val trace = prefs.getString(KEY_TRACE, null)?.trim().orEmpty()
+        val cachedTimestamp = prefs.getLong(KEY_TIMESTAMP, 0L)
+
+        if (trace.isEmpty() || cachedTimestamp == 0L) {
+            return null
+        }
+
+        return PendingTrace(trace, cachedTimestamp)
+    }
+
+    fun traceForExitTimestamp(context: Context, pending: PendingTrace?, exitTimestampMs: Long): String {
+        if (pending == null) {
+            return ""
+        }
+        val delta = kotlin.math.abs(exitTimestampMs - pending.timestampMs)
+        if (delta > MAX_TIMESTAMP_DELTA_MS) {
+            clearPendingCrashTrace(context)
+            return ""
+        }
+        return pending.trace
+    }
+
+    fun clearPendingCrashTrace(context: Context) {
+        context.applicationContext
+            .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .remove(KEY_TRACE)
+            .remove(KEY_TIMESTAMP)
+            .apply()
+    }
+
+    /**
+     * @deprecated Prefer peek + clearPendingCrashTrace so one crash can backfill several exit rows.
+     */
+    fun consumePendingCrashTrace(context: Context, exitTimestampMs: Long): String? {
+        val pending = peekPendingCrashTrace(context) ?: return null
+        val trace = traceForExitTimestamp(context, pending, exitTimestampMs)
+        if (trace.isEmpty()) {
+            return null
+        }
+        clearPendingCrashTrace(context)
+        return trace
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.grafana.faro.reactnative
+
+import android.content.Context
+import android.util.Log
+
+/**
+ * Public helpers for NDK crash reporting integrations.
+ *
+ * Apps can call [cachePendingNativeCrashTrace] immediately before an intentional native
+ * crash when ApplicationExitInfo.traceInputStream is unavailable (common on emulators).
+ * The cached tombstone text is attached on the next launch when the exit reason is
+ * REASON_CRASH_NATIVE.
+ */
+object FaroNativeCrashTrace {
+
+    private const val TAG = "FaroCrashReporter"
+
+    /**
+     * Persists a text tombstone backtrace for the next ApplicationExitInfo replay.
+     *
+     * The trace must contain native frame lines (`#00 pc … libfoo.so`) so the Faro
+     * collector can run NDK retrace.
+     */
+    @JvmStatic
+    fun cachePendingNativeCrashTrace(context: Context, trace: String) {
+        val trimmed = trace.trim()
+        if (trimmed.isEmpty()) {
+            Log.w(TAG, "[Faro crash native] Ignoring empty pending native trace cache")
+            return
+        }
+        if (!TombstoneBacktraceFormatter.looksLikeNativeBacktrace(trimmed)) {
+            Log.w(TAG, "[Faro crash native] Ignoring pending native trace without #00 pc frames")
+            return
+        }
+
+        FaroCrashTraceCache.savePendingCrashTrace(context, trimmed, System.currentTimeMillis())
+        Log.i(TAG, "[Faro crash native] Cached pending native tombstone (${trimmed.lineSequence().count()} lines)")
+    }
+}

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

@@ -3,10 +3,12 @@ package com.grafana.faro.reactnative
 import android.os.Build
 import android.os.Process
 import android.os.SystemClock
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -174,6 +176,14 @@ class FaroReactNativeModule(reactContext: ReactApplicationContext) :
         // Configure timeout
         val timeout = if (config.hasKey("timeout")) config.getDouble("timeout").toLong() else 5000L
         ANRTracker.timeout = timeout
+        ANRTracker.applicationContext = reactApplicationContext.applicationContext
+
+        ANRTracker.onAnrDetected = { payload ->
+            // Emit from the ANR tracker thread. runOnUiQueueThread would defer until the
+            // main looper runs — but during a debug ANR the UI thread is blocked, so the
+            // event would not reach JS until the freeze ends (and may be lost on app kill).
+            sendEvent("onANRDetected", payload)
+        }
         
         // Start new tracker
         anrTracker = ANRTracker()
@@ -185,10 +195,34 @@ class FaroReactNativeModule(reactContext: ReactApplicationContext) :
      */
     @ReactMethod
     fun stopANRTracking() {
+        ANRTracker.onAnrDetected = null
+        ANRTracker.applicationContext = null
         anrTracker?.stopTracking()
         anrTracker = null
     }
 
+    /**
+     * Returns unsent ANRs persisted on disk (peek; does not clear).
+     */
+    @ReactMethod
+    fun getPendingANRs(promise: Promise) {
+        promise.resolve(pendingAnrsWritableArray())
+    }
+
+    /**
+     * Removes ANRs from the pending cache after JS has reported them.
+     */
+    @ReactMethod
+    fun acknowledgeANRs(timestamps: ReadableArray, promise: Promise) {
+        val ackTimestamps = mutableListOf<Long>()
+        for (i in 0 until timestamps.size()) {
+            ackTimestamps.add(timestamps.getDouble(i).toLong())
+        }
+        FaroAnrCache.acknowledgeAnrs(reactApplicationContext, ackTimestamps)
+        ANRTracker.acknowledgeInMemory(ackTimestamps)
+        promise.resolve(null)
+    }
+
     /**
      * Get ANR status (list of detected ANRs)
      *
@@ -196,13 +230,57 @@ class FaroReactNativeModule(reactContext: ReactApplicationContext) :
      */
     @ReactMethod
     fun getANRStatus(promise: Promise) {
-        val anrList = ANRTracker.getANRStatus()
-        ANRTracker.resetANR()
-        
-        if (anrList != null) {
-            val writableArray = com.facebook.react.bridge.Arguments.createArray()
-            for (anr in anrList) {
-                writableArray.pushString(anr)
+        promise.resolve(pendingAnrsWritableArray())
+    }
+
+    private fun pendingAnrsWritableArray(): com.facebook.react.bridge.WritableArray? {
+        val diskPending = FaroAnrCache.getPendingAnrs(reactApplicationContext)
+        val memoryPending = ANRTracker.getANRStatus().orEmpty()
+        val merged = mergePendingAnrs(diskPending, memoryPending)
+
+        if (merged.isEmpty()) {
+            return null
+        }
+
+        val writableArray = Arguments.createArray()
+        for (anr in merged) {
+            writableArray.pushString(anr)
+        }
+        return writableArray
+    }
+
+    private fun mergePendingAnrs(diskPending: List<String>, memoryPending: List<String>): List<String> {
+        val merged = ArrayList<String>(diskPending.size + memoryPending.size)
+        val seenTimestamps = mutableSetOf<Long>()
+
+        for (payload in diskPending + memoryPending) {
+            val timestamp = try {
+                org.json.JSONObject(payload).optLong("timestamp", 0L)
+            } catch (_: Exception) {
+                0L
+            }
+            if (timestamp == 0L || timestamp in seenTimestamps) {
+                continue
+            }
+            seenTimestamps.add(timestamp)
+            merged.add(payload)
+        }
+
+        return merged
+    }
+
+    /**
+     * Historical ANRs from ApplicationExitInfo (Android 11+), Sentry AnrV2 style.
+     * Separate from [getCrashReport] so ANRs are not replayed as generic crashes.
+     */
+    @ReactMethod
+    fun getHistoricalAnrReports(promise: Promise) {
+        val anrReports = FaroAnrReporter.getAnrReports(reactApplicationContext)
+
+        if (anrReports != null) {
+            val writableArray = Arguments.createArray()
+            for (report in anrReports) {
+                writableArray.pushString(report)
             }
             promise.resolve(writableArray)
         } else {
@@ -214,7 +292,7 @@ class FaroReactNativeModule(reactContext: ReactApplicationContext) :
      * Get crash reports from previous app sessions
      *
      * Uses Android's ApplicationExitInfo API (Android 11+) to retrieve
-     * crash and ANR information from previous sessions.
+     * crash information from previous sessions (ANRs excluded).
      *
      * @param promise Promise to resolve with the crash reports list
      */
@@ -233,6 +311,19 @@ class FaroReactNativeModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * Required for NativeEventEmitter on modern React Native versions.
+     */
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep: required for RN event subscription bookkeeping.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Keep: required for RN event subscription bookkeeping.
+    }
+
     /**
      * Send an event to JavaScript
      */

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

@@ -10,6 +10,7 @@ import com.facebook.react.uimanager.ViewManager
  */
 class FaroReactNativePackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        FaroUncaughtExceptionHandler.install(reactContext)
         return listOf(FaroReactNativeModule(reactContext))
     }