@grafana/faro-react-native 1.2.1 → 1.3.1

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

@@ -0,0 +1,163 @@
+package com.grafana.faro.reactnative
+
+import android.content.Context
+import android.content.SharedPreferences
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Persists pending ANR payloads between detection and JS delivery.
+ *
+ * ANRs are written with [commit] on the ANR tracker thread as soon as the 5s
+ * threshold fires, so a process kill before the React bridge can emit still
+ * leaves a recoverable record for the next launch.
+ */
+internal object FaroAnrCache {
+    private const val PREFS_NAME = "com.grafana.faro.anr_cache"
+    private const val KEY_PENDING_ANRS = "pending_anrs"
+    private const val KEY_DETECTED_ANR_TIMESTAMPS = "detected_anr_timestamps"
+    private const val MAX_PENDING_ENTRIES = 50
+    private const val MAX_DETECTED_TIMESTAMP_ENTRIES = 50
+    /** Match window between ANRTracker detection time and ApplicationExitInfo exit time. */
+    private const val MAX_TIMESTAMP_DELTA_MS = 10_000L
+
+    fun savePendingAnr(context: Context, payload: String) {
+        val newObj = try {
+            JSONObject(payload)
+        } catch (_: Exception) {
+            return
+        }
+        val newTimestamp = newObj.optLong("timestamp", 0L)
+        if (newTimestamp == 0L) {
+            return
+        }
+
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val array = JSONArray(prefs.getString(KEY_PENDING_ANRS, "[]") ?: "[]")
+
+        for (i in 0 until array.length()) {
+            val existing = array.optJSONObject(i) ?: continue
+            val existingTimestamp = existing.optLong("timestamp", 0L)
+            if (existingTimestamp == newTimestamp) {
+                return
+            }
+            if (isWithinDetectionWindow(existingTimestamp, newTimestamp)) {
+                // Collapse repeated tracker detections for the same blocked period.
+                return
+            }
+        }
+
+        array.put(newObj)
+        trimOldestEntries(array)
+
+        recordDetectionTimestamp(prefs, newTimestamp)
+
+        // commit() not apply(): the process may be killed immediately after ANR detection.
+        prefs.edit()
+            .putString(KEY_PENDING_ANRS, array.toString())
+            .commit()
+    }
+
+    /**
+     * Returns true when Faro already recorded an ANR near [exitTimestampMs].
+     * Used to skip ApplicationExitInfo crash replays of the same blocked-main-thread event.
+     */
+    fun hasNearbyAnrDetection(context: Context, exitTimestampMs: Long): Boolean {
+        if (exitTimestampMs <= 0L) {
+            return false
+        }
+
+        for (payload in getPendingAnrs(context)) {
+            val timestamp = try {
+                JSONObject(payload).optLong("timestamp", 0L)
+            } catch (_: Exception) {
+                0L
+            }
+            if (isWithinDetectionWindow(timestamp, exitTimestampMs)) {
+                return true
+            }
+        }
+
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val detected = JSONArray(prefs.getString(KEY_DETECTED_ANR_TIMESTAMPS, "[]") ?: "[]")
+        for (i in 0 until detected.length()) {
+            val timestamp = detected.optLong(i, 0L)
+            if (isWithinDetectionWindow(timestamp, exitTimestampMs)) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    private fun recordDetectionTimestamp(prefs: SharedPreferences, timestampMs: Long) {
+        val detected = JSONArray(prefs.getString(KEY_DETECTED_ANR_TIMESTAMPS, "[]") ?: "[]")
+        for (i in 0 until detected.length()) {
+            if (detected.optLong(i, 0L) == timestampMs) {
+                return
+            }
+        }
+        detected.put(timestampMs)
+        while (detected.length() > MAX_DETECTED_TIMESTAMP_ENTRIES) {
+            detected.remove(0)
+        }
+        prefs.edit()
+            .putString(KEY_DETECTED_ANR_TIMESTAMPS, detected.toString())
+            .commit()
+    }
+
+    private fun isWithinDetectionWindow(anrTimestampMs: Long, exitTimestampMs: Long): Boolean {
+        if (anrTimestampMs <= 0L) {
+            return false
+        }
+        return kotlin.math.abs(exitTimestampMs - anrTimestampMs) <= MAX_TIMESTAMP_DELTA_MS
+    }
+
+    fun getPendingAnrs(context: Context): List<String> {
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val array = JSONArray(prefs.getString(KEY_PENDING_ANRS, "[]") ?: "[]")
+        val result = ArrayList<String>(array.length())
+        for (i in 0 until array.length()) {
+            val obj = array.optJSONObject(i) ?: continue
+            result.add(obj.toString())
+        }
+        return result
+    }
+
+    /** Records an ANR exit timestamp so [FaroCrashReporter] skips duplicate crash rows. */
+    fun recordDetectionTimestamp(context: Context, timestampMs: Long) {
+        if (timestampMs <= 0L) {
+            return
+        }
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        recordDetectionTimestamp(prefs, timestampMs)
+    }
+
+    fun acknowledgeAnrs(context: Context, timestamps: Collection<Long>) {
+        if (timestamps.isEmpty()) {
+            return
+        }
+
+        val timestampSet = timestamps.toSet()
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val array = JSONArray(prefs.getString(KEY_PENDING_ANRS, "[]") ?: "[]")
+        val remaining = JSONArray()
+
+        for (i in 0 until array.length()) {
+            val obj = array.optJSONObject(i) ?: continue
+            if (obj.optLong("timestamp", 0L) !in timestampSet) {
+                remaining.put(obj)
+            }
+        }
+
+        prefs.edit()
+            .putString(KEY_PENDING_ANRS, remaining.toString())
+            .commit()
+    }
+
+    private fun trimOldestEntries(array: JSONArray) {
+        while (array.length() > MAX_PENDING_ENTRIES) {
+            array.remove(0)
+        }
+    }
+}

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

@@ -0,0 +1,163 @@
+package com.grafana.faro.reactnative
+
+import android.app.ActivityManager
+import android.app.ApplicationExitInfo
+import android.content.Context
+import android.os.Build
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+/**
+ * Reports ANRs from ApplicationExitInfo (Android 11+), Sentry AnrV2 style.
+ *
+ * Kept separate from [FaroCrashReporter] so ANR timeout rows are not replayed as
+ * generic previous-session `crash` events (no message / duplicate rows).
+ */
+object FaroAnrReporter {
+
+    private const val PREFS_NAME = "com.grafana.faro.anr_reporter"
+    private const val KEY_LAST_PROCESSED_TIMESTAMP = "last_processed_anr_timestamp"
+
+    @JvmStatic
+    fun getAnrReports(context: Context): List<String>? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return null
+        }
+
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+            ?: return null
+
+        val exitInfoList = activityManager.getHistoricalProcessExitReasons(
+            context.packageName,
+            0,
+            10,
+        )
+
+        if (exitInfoList.isEmpty()) {
+            return null
+        }
+
+        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val lastProcessedTimestamp = prefs.getLong(KEY_LAST_PROCESSED_TIMESTAMP, 0)
+
+        val reports = mutableListOf<String>()
+        var latestTimestamp = lastProcessedTimestamp
+
+        val anrExits = exitInfoList
+            .filter { it.timestamp > lastProcessedTimestamp && it.reason == ApplicationExitInfo.REASON_ANR }
+            .groupBy { it.timestamp }
+            .mapValues { (_, exits) -> pickBestAnrExit(exits) }
+            .toSortedMap()
+
+        for ((timestamp, exitInfo) in anrExits) {
+            if (exitInfo.timestamp > latestTimestamp) {
+                latestTimestamp = exitInfo.timestamp
+            }
+
+            val json = exportAnrAsJSON(context, exitInfo) ?: continue
+            reports.add(json)
+        }
+
+        if (latestTimestamp > lastProcessedTimestamp) {
+            prefs.edit()
+                .putLong(KEY_LAST_PROCESSED_TIMESTAMP, latestTimestamp)
+                .apply()
+        }
+
+        return if (reports.isEmpty()) null else reports
+    }
+
+    private fun pickBestAnrExit(exits: List<ApplicationExitInfo>): ApplicationExitInfo {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return exits.first()
+        }
+
+        return exits.maxByOrNull { exit ->
+            var score = 0
+            if (getTraceInfo(exit).isNotEmpty()) {
+                score += 2
+            }
+            val description = exit.description?.trim().orEmpty()
+            if (description.isNotEmpty()) {
+                score += 1
+            }
+            score
+        } ?: exits.first()
+    }
+
+    private fun exportAnrAsJSON(context: Context, exitInfo: ApplicationExitInfo): String? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return null
+        }
+
+        val fullTrace = getTraceInfo(exitInfo)
+        if (fullTrace.isEmpty()) {
+            // Align with Sentry: skip ANRs without an actionable trace stream.
+            return null
+        }
+
+        val mainStack = AnrThreadDumpParser.extractMainThreadStack(fullTrace)
+        if (mainStack.isEmpty() || AnrStackFilters.isCrashHandlerStack(mainStack)) {
+            return null
+        }
+
+        val rawDescription = exitInfo.description?.trim().orEmpty()
+        val description = rawDescription.ifEmpty { "Application Not Responding" }
+
+        FaroAnrCache.recordDetectionTimestamp(context, exitInfo.timestamp)
+
+        // duration is the configured watchdog threshold (set via startANRTracking), not the
+        // measured main-thread block time — AppExitInfo does not expose exact freeze duration.
+        // TODO: consider renaming the JSON field to detectionThresholdMs for clarity.
+        return JSONObject().apply {
+            put("type", "ANR")
+            put("timestamp", exitInfo.timestamp)
+            put("duration", ANRTracker.timeout)
+            put("stacktrace", mainStack)
+            put("description", description)
+            put("source", "AppExitInfo")
+            put("processName", exitInfo.processName ?: "")
+            put("pid", exitInfo.pid)
+        }.toString()
+    }
+
+    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 = 500
+
+            reader.useLines { lines ->
+                for (line in lines) {
+                    if (lineCount >= maxLines) break
+                    trace.appendLine(line)
+                    lineCount++
+                }
+            }
+
+            trace.toString().trim()
+        } catch (_: Exception) {
+            ""
+        }
+    }
+}
+
+/**
+ * Reject watchdog snapshots taken while the process is tearing down after a crash.
+ * Uses only Android framework and Faro SDK frame names.
+ */
+internal object AnrStackFilters {
+    fun isCrashHandlerStack(stack: String): Boolean {
+        val normalized = stack.lowercase()
+        return normalized.contains("handleapplicationcrash") ||
+            normalized.contains("killapplicationhandler") ||
+            normalized.contains("farouncaughtexceptionhandler")
+    }
+}