@rejourneyco/react-native 1.0.8 → 1.0.9

package/android/src/main/java/com/rejourney/RejourneyModuleImpl.kt

@@ -45,6 +45,7 @@ import com.rejourney.platform.TaskRemovedListener
 import com.rejourney.recording.*
 import kotlinx.coroutines.*
 import java.security.MessageDigest
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
@@ -68,9 +69,11 @@ class RejourneyModuleImpl(
         var sdkVersion = "1.0.1"
         
         private const val SESSION_TIMEOUT_MS = 60_000L // 60 seconds
+        private const val SESSION_ROLLOVER_GRACE_MS = 2_000L
         
         private const val PREFS_NAME = "com.rejourney.prefs"
         private const val KEY_USER_IDENTITY = "user_identity"
+        private const val KEY_ANONYMOUS_ID = "anonymous_id"
     }
 
     // State machine
@@ -143,8 +146,14 @@ class RejourneyModuleImpl(
                 registerActivityLifecycleCallbacks()
                 registerProcessLifecycleObserver()
                 
-                // Transmit any stored crash reports
-                StabilityMonitor.getInstance(reactContext).transmitStoredReport()
+                // Recover any session interrupted by a previous crash.
+                // Transmit stored fault reports only after recovery restores auth context.
+                ReplayOrchestrator.getInstance(reactContext).recoverInterruptedReplay { recoveredId ->
+                    if (recoveredId != null) {
+                        DiagnosticLog.notice("[Rejourney] Recovered crashed session: $recoveredId")
+                    }
+                    StabilityMonitor.getInstance(reactContext).transmitStoredReport()
+                }
                 
                 // Android-specific: OEM detection and task removed handling
                 setupOEMSpecificHandling()
@@ -252,16 +261,52 @@ class RejourneyModuleImpl(
                 
                 DiagnosticLog.notice("[Rejourney] 🔄 Session timeout! Ending session '$oldSessionId' and creating new one")
 
+                val restartStarted = AtomicBoolean(false)
+                val triggerRestart: (String) -> Unit = { source ->
+                    if (restartStarted.compareAndSet(false, true)) {
+                        DiagnosticLog.notice("[Rejourney] Session rollover trigger source=$source, oldSession=$oldSessionId")
+                        mainHandler.post { startNewSessionAfterTimeout() }
+                    }
+                }
+
+                mainHandler.postDelayed({
+                    if (!restartStarted.get()) {
+                        DiagnosticLog.caution("[Rejourney] Session rollover grace timeout reached (${SESSION_ROLLOVER_GRACE_MS}ms), forcing new session start")
+                    }
+                    triggerRestart("grace_timeout")
+                }, SESSION_ROLLOVER_GRACE_MS)
+
                 backgroundScope.launch {
-                    ReplayOrchestrator.shared?.endReplay { success, uploaded ->
+                    val orchestrator = ReplayOrchestrator.shared
+                    if (orchestrator == null) {
+                        triggerRestart("orchestrator_missing")
+                        return@launch
+                    }
+
+                    orchestrator.endReplayWithReason("background_timeout") { success, uploaded ->
                         DiagnosticLog.notice("[Rejourney] Old session ended (success: $success, uploaded: $uploaded)")
-                        mainHandler.post { startNewSessionAfterTimeout() }
+                        triggerRestart("end_replay_callback")
                     }
                 }
             } else {
-                // Resume existing session
-                state = SessionState.Active(currentState.sessionId, currentState.startTimeMs)
-                DiagnosticLog.notice("[Rejourney] ▶️ Resuming session '${currentState.sessionId}'")
+                val orchestratorSessionId = ReplayOrchestrator.shared?.replayId
+                if (orchestratorSessionId.isNullOrEmpty()) {
+                    // The old session can end while app is backgrounded (e.g. duration limit).
+                    // Do not resume a dead session; start a fresh one.
+                    state = SessionState.Idle
+                    DiagnosticLog.notice("[Rejourney] Session ended while backgrounded, starting fresh session on foreground")
+                    mainHandler.post { startNewSessionAfterTimeout() }
+                    return
+                }
+
+                if (orchestratorSessionId != currentState.sessionId) {
+                    state = SessionState.Active(orchestratorSessionId, System.currentTimeMillis())
+                    DiagnosticLog.notice("[Rejourney] ▶️ Foreground reconciled to active session '$orchestratorSessionId' (was '${currentState.sessionId}')")
+                } else {
+                    // Resume existing session
+                    state = SessionState.Active(currentState.sessionId, currentState.startTimeMs)
+                    DiagnosticLog.notice("[Rejourney] ▶️ Resuming session '${currentState.sessionId}'")
+                }
                 
                 // Record foreground event
                 TelemetryPipeline.shared?.recordAppForeground(backgroundDuration)
@@ -494,6 +539,7 @@ class RejourneyModuleImpl(
                 state = SessionState.Idle
             }
             
+            
             // Android-specific: Stop SessionLifecycleService
             stopSessionLifecycleService()
 
@@ -502,7 +548,7 @@ class RejourneyModuleImpl(
                 return@post
             }
 
-            ReplayOrchestrator.shared?.endReplay { success, uploaded ->
+            ReplayOrchestrator.shared?.endReplayWithReason("user_initiated") { success, uploaded ->
                 DiagnosticLog.replayEnded(targetSid)
                 
                 promise.resolve(Arguments.createMap().apply {
@@ -554,6 +600,30 @@ class RejourneyModuleImpl(
         promise.resolve(currentUserIdentity)
     }
 
+    fun setAnonymousId(anonymousId: String, promise: Promise) {
+        try {
+            val prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            if (anonymousId.isBlank()) {
+                prefs.edit().remove(KEY_ANONYMOUS_ID).apply()
+            } else {
+                prefs.edit().putString(KEY_ANONYMOUS_ID, anonymousId).apply()
+            }
+        } catch (e: Exception) {
+            DiagnosticLog.fault("[Rejourney] Failed to persist anonymous ID: ${e.message}")
+        }
+
+        promise.resolve(createResultMap(true))
+    }
+
+    fun getAnonymousId(promise: Promise) {
+        try {
+            val prefs = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            promise.resolve(prefs.getString(KEY_ANONYMOUS_ID, null))
+        } catch (_: Exception) {
+            promise.resolve(null)
+        }
+    }
+
     fun logEvent(eventType: String, details: ReadableMap, promise: Promise) {
         // Handle network_request events specially
         if (eventType == "network_request") {
@@ -589,6 +659,17 @@ class RejourneyModuleImpl(
             return
         }
 
+        // Handle console log events - preserve type:"log" with level and message
+        // so the dashboard replay can display them in the console terminal
+        if (eventType == "log") {
+            val detailsMap = details.toHashMap()
+            val level = detailsMap["level"]?.toString() ?: "log"
+            val message = detailsMap["message"]?.toString() ?: ""
+            TelemetryPipeline.shared?.recordConsoleLogEvent(level, message)
+            promise.resolve(createResultMap(true))
+            return
+        }
+
         // All other events go through custom event recording
         val payload = try {
             val json = org.json.JSONObject(details.toHashMap()).toString()

package/android/src/main/java/com/rejourney/engine/DeviceRegistrar.kt

@@ -64,6 +64,7 @@ class DeviceRegistrar private constructor(private val context: Context) {
     // Private State
     private val prefsKey = "com.rejourney.device"
     private val fingerprintKey = "device_fingerprint"
+    private val fallbackIdKey = "device_fallback_id"
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     
     private val httpClient: OkHttpClient = OkHttpClient.Builder()
@@ -169,7 +170,6 @@ class DeviceRegistrar private constructor(private val context: Context) {
         var composite = packageName
         composite += Build.MODEL
         composite += Build.MANUFACTURER
-        composite += Build.VERSION.RELEASE
         composite += getAndroidId()
         
         return sha256(composite)
@@ -177,12 +177,27 @@ class DeviceRegistrar private constructor(private val context: Context) {
     
     private fun getAndroidId(): String {
         return try {
-            Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID) ?: java.util.UUID.randomUUID().toString()
+            Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
+                ?: stableDeviceFallback()
         } catch (e: Exception) {
-            java.util.UUID.randomUUID().toString()
+            stableDeviceFallback()
         }
     }
     
+    /**
+     * Returns a SharedPreferences-persisted UUID so the fingerprint stays stable
+     * even when ANDROID_ID is unavailable (restricted profiles, some OEM devices).
+     */
+    private fun stableDeviceFallback(): String {
+        val prefs = context.getSharedPreferences(prefsKey, Context.MODE_PRIVATE)
+        val existing = prefs.getString(fallbackIdKey, null)
+        if (existing != null) return existing
+        
+        val fresh = java.util.UUID.randomUUID().toString()
+        prefs.edit().putString(fallbackIdKey, fresh).apply()
+        return fresh
+    }
+    
     // Server Communication
     
     private suspend fun fetchServerCredential(

package/android/src/main/java/com/rejourney/engine/RejourneyImpl.kt

@@ -30,6 +30,7 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.ProcessLifecycleOwner
 import com.rejourney.recording.*
 import java.security.MessageDigest
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
@@ -45,26 +46,26 @@ sealed class SessionState {
 
 /**
  * Main SDK implementation aligned with iOS RejourneyImpl.swift
- * 
+ *
  * This class provides the core SDK functionality for native Android usage.
  * For React Native, use RejourneyModuleImpl instead.
  */
-class RejourneyImpl private constructor(private val context: Context) : 
+class RejourneyImpl private constructor(private val context: Context) :
     Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {
 
     companion object {
         @Volatile
         private var instance: RejourneyImpl? = null
-        
+
         fun getInstance(context: Context): RejourneyImpl {
             return instance ?: synchronized(this) {
                 instance ?: RejourneyImpl(context.applicationContext).also { instance = it }
             }
         }
-        
+
         val shared: RejourneyImpl?
             get() = instance
-            
+
         var sdkVersion = "1.0.1"
     }
 
@@ -81,14 +82,23 @@ class RejourneyImpl private constructor(private val context: Context) :
 
     // Session timeout threshold (60 seconds)
     private val sessionTimeoutMs = 60_000L
+    private val sessionRolloverGraceMs = 2_000L
 
     private val mainHandler = Handler(Looper.getMainLooper())
-    
+
     @Volatile
     private var isInitialized = false
 
     init {
         setupLifecycleListeners()
+
+        // Recover sessions interrupted by a previous crash first, then send stored faults.
+        ReplayOrchestrator.getInstance(context).recoverInterruptedReplay { recoveredId ->
+            if (recoveredId != null) {
+                DiagnosticLog.notice("[Rejourney] Recovered crashed session: $recoveredId")
+            }
+            StabilityMonitor.getInstance(context).transmitStoredReport()
+        }
     }
 
     private fun setupLifecycleListeners() {
@@ -97,10 +107,10 @@ class RejourneyImpl private constructor(private val context: Context) :
             mainHandler.post {
                 ProcessLifecycleOwner.get().lifecycle.addObserver(this)
             }
-            
+
             // Register activity callbacks
             (context.applicationContext as? Application)?.registerActivityLifecycleCallbacks(this)
-            
+
         } catch (e: Exception) {
             DiagnosticLog.fault("[Rejourney] Failed to setup lifecycle listeners: ${e.message}")
         }
@@ -123,7 +133,7 @@ class RejourneyImpl private constructor(private val context: Context) :
                     state = SessionState.Paused(currentState.sessionId, currentState.startTimeMs)
                     backgroundEntryTimeMs = System.currentTimeMillis()
                     DiagnosticLog.notice("[Rejourney] ⏸️ Session '${currentState.sessionId}' paused (app backgrounded)")
-                    
+
                     TelemetryPipeline.shared?.dispatchNow()
                     SegmentDispatcher.shared.shipPending()
                 }
@@ -158,16 +168,49 @@ class RejourneyImpl private constructor(private val context: Context) :
 
                 DiagnosticLog.notice("[Rejourney] 🔄 Session timeout! Ending session '$oldSessionId' and creating new one")
 
-                Thread {
-                    ReplayOrchestrator.shared?.endReplay { success, uploaded ->
-                        DiagnosticLog.notice("[Rejourney] Old session ended (success: $success, uploaded: $uploaded)")
+                val restartStarted = AtomicBoolean(false)
+                val triggerRestart: (String) -> Unit = { source ->
+                    if (restartStarted.compareAndSet(false, true)) {
+                        DiagnosticLog.notice("[Rejourney] Session rollover trigger source=$source, oldSession=$oldSessionId")
                         mainHandler.post { startNewSessionAfterTimeout() }
                     }
+                }
+
+                mainHandler.postDelayed({
+                    if (!restartStarted.get()) {
+                        DiagnosticLog.caution("[Rejourney] Session rollover grace timeout reached (${sessionRolloverGraceMs}ms), forcing new session start")
+                    }
+                    triggerRestart("grace_timeout")
+                }, sessionRolloverGraceMs)
+
+                Thread {
+                    val orchestrator = ReplayOrchestrator.shared
+                    if (orchestrator == null) {
+                        triggerRestart("orchestrator_missing")
+                    } else {
+                        orchestrator.endReplayWithReason("background_timeout") { success, uploaded ->
+                            DiagnosticLog.notice("[Rejourney] Old session ended (success: $success, uploaded: $uploaded)")
+                            triggerRestart("end_replay_callback")
+                        }
+                    }
                 }.start()
             } else {
-                // Resume existing session
-                state = SessionState.Active(currentState.sessionId, currentState.startTimeMs)
-                DiagnosticLog.notice("[Rejourney] ▶️ Resuming session '${currentState.sessionId}'")
+                val orchestratorSessionId = ReplayOrchestrator.shared?.replayId
+                if (orchestratorSessionId.isNullOrEmpty()) {
+                    state = SessionState.Idle
+                    DiagnosticLog.notice("[Rejourney] Session ended while backgrounded, starting fresh session on foreground")
+                    mainHandler.post { startNewSessionAfterTimeout() }
+                    return
+                }
+
+                if (orchestratorSessionId != currentState.sessionId) {
+                    state = SessionState.Active(orchestratorSessionId, System.currentTimeMillis())
+                    DiagnosticLog.notice("[Rejourney] ▶️ Foreground reconciled to active session '$orchestratorSessionId' (was '${currentState.sessionId}')")
+                } else {
+                    // Resume existing session
+                    state = SessionState.Active(currentState.sessionId, currentState.startTimeMs)
+                    DiagnosticLog.notice("[Rejourney] ▶️ Resuming session '${currentState.sessionId}'")
+                }
 
                 TelemetryPipeline.shared?.recordAppForeground(backgroundDuration)
                 StabilityMonitor.shared?.transmitStoredReport()
@@ -323,7 +366,7 @@ class RejourneyImpl private constructor(private val context: Context) :
                 return@post
             }
 
-            ReplayOrchestrator.shared?.endReplay { success, uploaded ->
+            ReplayOrchestrator.shared?.endReplayWithReason("user_initiated") { success, uploaded ->
                 DiagnosticLog.replayEnded(targetSid)
                 callback?.invoke(success, targetSid, uploaded)
             }
@@ -385,6 +428,15 @@ class RejourneyImpl private constructor(private val context: Context) :
             return
         }
 
+        // Handle console log events - preserve type:"log" with level and message
+        // so the dashboard replay can display them in the console terminal
+        if (eventType == "log") {
+            val level = details?.get("level")?.toString() ?: "log"
+            val message = details?.get("message")?.toString() ?: ""
+            TelemetryPipeline.shared?.recordConsoleLogEvent(level, message)
+            return
+        }
+
         val payload = try {
             org.json.JSONObject(details ?: emptyMap<String, Any>()).toString()
         } catch (e: Exception) {
@@ -499,7 +551,7 @@ class RejourneyImpl private constructor(private val context: Context) :
                 else -> {}
             }
         }
-        
+
         try {
             (context.applicationContext as? Application)?.unregisterActivityLifecycleCallbacks(this)
             mainHandler.post {

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,100 @@
+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 host = request.url.host
+
+        // Skip Rejourney's own API traffic to avoid ingestion duplication (mirrors iOS RejourneyURLProtocol)
+        if (host.contains("api.rejourney.co") || host.contains("rejourney")) {
+            return chain.proceed(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!!
+    }
+}