@rejourneyco/react-native 1.0.8 → 1.0.10

package/android/src/main/java/com/rejourney/recording/AnrSentinel.kt

@@ -55,6 +55,11 @@ class AnrSentinel private constructor() {
     
     fun activate() {
         if (isActive.getAndSet(true)) return
+
+        // Reset watchdog state on each activation to avoid stale timings from
+        // previous app background periods.
+        lastResponseTime.set(System.currentTimeMillis())
+        pongSequence.set(pingSequence.get())
         
         startWatchdog()
     }
@@ -87,7 +92,7 @@ class AnrSentinel private constructor() {
                     val elapsed = System.currentTimeMillis() - lastResponseTime.get()
                     val missedPongs = pingSequence.get() - pongSequence.get()
                     
-                    if (elapsed > anrThresholdMs && missedPongs > 0) {
+                    if (elapsed >= anrThresholdMs && missedPongs > 0) {
                         captureAnr(elapsed)
                         
                         // Reset to avoid duplicate reports
@@ -113,12 +118,32 @@ class AnrSentinel private constructor() {
                 "${element.className}.${element.methodName}(${element.fileName}:${element.lineNumber})"
             }
             
-            ReplayOrchestrator.shared?.incrementFaultTally()
+            ReplayOrchestrator.shared?.incrementStalledTally()
             
             // Route ANR through TelemetryPipeline so it arrives in the events
             // batch and the backend ingest worker can insert it into the anrs table
             val stackStr = frames.joinToString("\n")
             TelemetryPipeline.shared?.recordAnrEvent(durationMs, stackStr)
+
+            // Persist ANR incident and send through /api/ingest/fault so ANRs survive
+            // process termination/background upload loss, similar to crash recovery.
+            val sessionId = StabilityMonitor.shared?.currentSessionId
+                ?: ReplayOrchestrator.shared?.replayId
+                ?: "unknown"
+            val incident = IncidentRecord(
+                sessionId = sessionId,
+                timestampMs = System.currentTimeMillis(),
+                category = "anr",
+                identifier = "MainThreadFrozen",
+                detail = "Main thread unresponsive for ${durationMs}ms",
+                frames = frames,
+                context = mapOf(
+                    "durationMs" to durationMs.toString(),
+                    "threadState" to "blocked"
+                )
+            )
+            StabilityMonitor.shared?.persistIncidentSync(incident)
+            StabilityMonitor.shared?.transmitStoredReport()
             
             DiagnosticLog.fault("ANR detected: ${durationMs}ms hang")
             

package/android/src/main/java/com/rejourney/recording/InteractionRecorder.kt

@@ -133,8 +133,10 @@ class InteractionRecorder private constructor(private val context: Context) {
                     // Notify SpecialCases about touch phases for touch-based
                     // map idle detection (Mapbox v10+ fallback).
                     when (event.actionMasked) {
-                        MotionEvent.ACTION_DOWN ->
+                        MotionEvent.ACTION_DOWN -> {
+                            VisualCapture.shared?.invalidateMaskCache()
                             SpecialCases.shared.notifyTouchBegan()
+                        }
                         MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL ->
                             SpecialCases.shared.notifyTouchEnded()
                     }

package/android/src/main/java/com/rejourney/recording/RejourneyNetworkInterceptor.kt

@@ -0,0 +1,93 @@
+package com.rejourney.recording
+
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.io.IOException
+import java.util.UUID
+
+/**
+ * Native OkHttp Interceptor for Rejourney
+ *
+ * Captures native network traffic and routes it to the Rejourney TelemetryPipeline.
+ * To use, add this interceptor to your native OkHttpClient:
+ * val client = OkHttpClient.Builder()
+ *     .addInterceptor(RejourneyNetworkInterceptor())
+ *     .build()
+ */
+class RejourneyNetworkInterceptor : Interceptor {
+
+    @Throws(IOException::class)
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request()
+        val startMs = System.currentTimeMillis()
+
+        var response: Response? = null
+        var error: Exception? = null
+
+        try {
+            response = chain.proceed(request)
+        } catch (e: Exception) {
+            error = e
+            throw e
+        } finally {
+            try {
+                val endMs = System.currentTimeMillis()
+                val duration = endMs - startMs
+
+                val isSuccess = response?.isSuccessful == true
+                val statusCode = response?.code ?: 0
+
+                val urlStr = request.url.toString()
+                val pathStr = request.url.encodedPath
+
+                var maxUrlStr = urlStr
+                if (maxUrlStr.length > 300) {
+                    maxUrlStr = maxUrlStr.substring(0, 300)
+                }
+
+                val reqSize = request.body?.contentLength()?.takeIf { it >= 0 }?.toInt() ?: 0
+                val resSize = response?.body?.contentLength()?.takeIf { it >= 0 }?.toInt() ?: 0
+
+                val event = mutableMapOf<String, Any>(
+                    "requestId" to "n_${UUID.randomUUID()}",
+                    "method" to request.method,
+                    "url" to maxUrlStr,
+                    "urlPath" to pathStr,
+                    "urlHost" to request.url.host,
+                    "statusCode" to statusCode,
+                    "duration" to duration,
+                    "startTimestamp" to startMs,
+                    "endTimestamp" to endMs,
+                    "success" to isSuccess
+                )
+
+                if (reqSize > 0) {
+                    event["requestBodySize"] = reqSize
+                }
+                
+                request.body?.contentType()?.let {
+                    event["requestContentType"] = it.toString()
+                }
+
+                if (resSize > 0) {
+                    event["responseBodySize"] = resSize
+                }
+                
+                response?.body?.contentType()?.let {
+                    event["responseContentType"] = it.toString()
+                }
+
+                error?.let {
+                    event["errorMessage"] = it.message ?: "Network error"
+                }
+
+                TelemetryPipeline.shared?.recordNetworkEvent(event)
+
+            } catch (ignore: Exception) {
+                // Ignore to avoid breaking the application network call
+            }
+        }
+
+        return response!!
+    }
+}