@rejourneyco/react-native 1.0.7 → 1.0.8

package/README.md

@@ -26,4 +26,4 @@ Full integration guides and API reference: https://rejourney.co/docs/reactnative
 
 ## License
 
-Licensed under Apache 2.0
+Licensed under Apache 2.0

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

@@ -709,26 +709,28 @@ class RejourneyModuleImpl(
     fun getSDKMetrics(promise: Promise) {
         val dispatcher = SegmentDispatcher.shared
         val pipeline = TelemetryPipeline.shared
+        val telemetry = dispatcher.sdkTelemetrySnapshot(pipeline?.getQueueDepth() ?: 0)
+        
+        fun toIntValue(key: String): Int = (telemetry[key] as? Number)?.toInt() ?: 0
+        fun toDoubleValue(key: String, fallback: Double = 0.0): Double = (telemetry[key] as? Number)?.toDouble() ?: fallback
+        fun toLongValue(key: String): Long? = (telemetry[key] as? Number)?.toLong()
         
         promise.resolve(Arguments.createMap().apply {
-            putInt("uploadSuccessCount", dispatcher.uploadSuccessCount)
-            putInt("uploadFailureCount", dispatcher.uploadFailureCount)
-            putInt("retryAttemptCount", 0)
-            putInt("circuitBreakerOpenCount", dispatcher.circuitBreakerOpenCount)
-            putInt("memoryEvictionCount", 0)
-            putInt("offlinePersistCount", 0)
-            putInt("sessionStartCount", if (ReplayOrchestrator.shared?.replayId != null) 1 else 0)
-            putInt("crashCount", 0)
-            
-            val total = dispatcher.uploadSuccessCount + dispatcher.uploadFailureCount
-            putDouble("uploadSuccessRate", if (total > 0) dispatcher.uploadSuccessCount.toDouble() / total else 1.0)
-            
-            putDouble("avgUploadDurationMs", 0.0)
-            putInt("currentQueueDepth", pipeline?.getQueueDepth() ?: 0)
-            putNull("lastUploadTime")
-            putNull("lastRetryTime")
-            putDouble("totalBytesUploaded", dispatcher.totalBytesUploaded.toDouble())
-            putInt("totalBytesEvicted", 0)
+            putInt("uploadSuccessCount", toIntValue("uploadSuccessCount"))
+            putInt("uploadFailureCount", toIntValue("uploadFailureCount"))
+            putInt("retryAttemptCount", toIntValue("retryAttemptCount"))
+            putInt("circuitBreakerOpenCount", toIntValue("circuitBreakerOpenCount"))
+            putInt("memoryEvictionCount", toIntValue("memoryEvictionCount"))
+            putInt("offlinePersistCount", toIntValue("offlinePersistCount"))
+            putInt("sessionStartCount", toIntValue("sessionStartCount"))
+            putInt("crashCount", toIntValue("crashCount"))
+            putDouble("uploadSuccessRate", toDoubleValue("uploadSuccessRate", 1.0))
+            putDouble("avgUploadDurationMs", toDoubleValue("avgUploadDurationMs", 0.0))
+            putInt("currentQueueDepth", toIntValue("currentQueueDepth"))
+            toLongValue("lastUploadTime")?.let { putDouble("lastUploadTime", it.toDouble()) } ?: putNull("lastUploadTime")
+            toLongValue("lastRetryTime")?.let { putDouble("lastRetryTime", it.toDouble()) } ?: putNull("lastRetryTime")
+            putDouble("totalBytesUploaded", toDoubleValue("totalBytesUploaded", 0.0))
+            putDouble("totalBytesEvicted", toDoubleValue("totalBytesEvicted", 0.0))
         })
     }
 

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

@@ -29,6 +29,7 @@ import android.widget.EditText
 import android.widget.ImageButton
 import java.lang.ref.WeakReference
 import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.atomic.AtomicLong
 import kotlin.math.abs
 import kotlin.math.sqrt
 
@@ -59,6 +60,7 @@ class InteractionRecorder private constructor(private val context: Context) {
     private val inputObservers = CopyOnWriteArrayList<WeakReference<EditText>>()
     private val navigationStack = mutableListOf<String>()
     private val coalesceWindow: Long = 300 // ms
+    private val lastInteractionTimestampMs = AtomicLong(0L)
     
     internal var currentActivity: WeakReference<Activity>? = null
     
@@ -86,8 +88,11 @@ class InteractionRecorder private constructor(private val context: Context) {
         gestureAggregator = null
         inputObservers.clear()
         navigationStack.clear()
+        lastInteractionTimestampMs.set(0L)
     }
     
+    fun latestInteractionTimestampMs(): Long = lastInteractionTimestampMs.get()
+    
     fun observeTextField(field: EditText) {
         if (inputObservers.any { it.get() === field }) return
         inputObservers.add(WeakReference(field))
@@ -122,13 +127,27 @@ class InteractionRecorder private constructor(private val context: Context) {
         window.callback = object : Window.Callback by original {
             override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
                 if (event != null) {
+                    markInteractionNow()
                     agg.processTouchEvent(event)
+
+                    // Notify SpecialCases about touch phases for touch-based
+                    // map idle detection (Mapbox v10+ fallback).
+                    when (event.actionMasked) {
+                        MotionEvent.ACTION_DOWN ->
+                            SpecialCases.shared.notifyTouchBegan()
+                        MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL ->
+                            SpecialCases.shared.notifyTouchEnded()
+                    }
                 }
                 return original.dispatchTouchEvent(event)
             }
         }
     }
     
+    private fun markInteractionNow() {
+        lastInteractionTimestampMs.set(System.currentTimeMillis())
+    }
+    
     private fun removeGlobalTouchListener() {
         val window = installedWindow?.get()
         if (window != null) {
@@ -450,6 +469,11 @@ private class GestureAggregator(
     }
     
     private fun resolveTarget(location: PointF): String {
+        // When a map view is visible, skip the expensive hit-test walk
+        // through the deep SurfaceView/TextureView hierarchy.
+        if (SpecialCases.shared.mapVisible) {
+            return "map"
+        }
         return "view_${location.x.toInt()}_${location.y.toInt()}"
     }
     
@@ -462,6 +486,10 @@ private class GestureAggregator(
      * (e.g. TextView inside a Pressable), not the clickable Pressable itself.
      */
     private fun isViewInteractive(location: PointF): Boolean {
+        // Skip the expensive hierarchy walk when a map is visible to
+        // prevent micro-stutter during pan/zoom gestures.
+        if (SpecialCases.shared.mapVisible) return false
+        
         val activity = recorder.currentActivity?.get() ?: return false
         val decorView = activity.window?.decorView ?: return false
         val hit = findViewAt(decorView, location.x.toInt(), location.y.toInt()) ?: return false

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

@@ -87,7 +87,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             DeviceRegistrar.shared?.endpoint = value
         }
     
-    var snapshotInterval: Double = 0.33
+    var snapshotInterval: Double = 1.0
     var compressionLevel: Double = 0.5
     var visualCaptureEnabled: Boolean = true
     var interactionCaptureEnabled: Boolean = true
@@ -169,20 +169,20 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     }
     
     fun beginReplay(apiToken: String, serverEndpoint: String, captureSettings: Map<String, Any>? = null) {
-        DiagnosticLog.notice("[ReplayOrchestrator] ★★★ beginReplay v2 ★★★")
+        DiagnosticLog.trace("[ReplayOrchestrator] beginReplay v2")
         val perf = PerformanceSnapshot.capture()
         DiagnosticLog.debugSessionCreate("ORCHESTRATOR_INIT", "beginReplay", perf)
-        DiagnosticLog.notice("[ReplayOrchestrator] beginReplay called, endpoint=$serverEndpoint")
+        DiagnosticLog.trace("[ReplayOrchestrator] beginReplay called, endpoint=$serverEndpoint")
         
         this.apiToken = apiToken
         this.serverEndpoint = serverEndpoint
         applySettings(captureSettings)
         
         DiagnosticLog.debugSessionCreate("CREDENTIAL_START", "Requesting device credential")
-        DiagnosticLog.notice("[ReplayOrchestrator] Requesting credential from DeviceRegistrar.shared=${DeviceRegistrar.shared != null}")
+        DiagnosticLog.trace("[ReplayOrchestrator] Requesting credential from DeviceRegistrar.shared=${DeviceRegistrar.shared != null}")
         
         DeviceRegistrar.shared?.obtainCredential(apiToken) { ok, cred ->
-            DiagnosticLog.notice("[ReplayOrchestrator] Credential callback: ok=$ok, cred=${cred?.take(20) ?: "null"}...")
+            DiagnosticLog.trace("[ReplayOrchestrator] Credential callback: ok=$ok, cred=${cred?.take(20) ?: "null"}...")
             if (!ok) {
                 DiagnosticLog.debugSessionCreate("CREDENTIAL_FAIL", "Failed")
                 DiagnosticLog.caution("[ReplayOrchestrator] Credential fetch FAILED - recording cannot start")
@@ -194,7 +194,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             SegmentDispatcher.shared.apiToken = apiToken
             SegmentDispatcher.shared.credential = cred
             
-            DiagnosticLog.notice("[ReplayOrchestrator] Credential OK, calling monitorNetwork")
+            DiagnosticLog.trace("[ReplayOrchestrator] Credential OK, calling monitorNetwork")
             monitorNetwork(apiToken)
         }
     }
@@ -217,7 +217,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         initSession()
         TelemetryPipeline.shared?.activateDeferredMode()
         
-        val renderCfg = computeRender(3, "standard")
+        val renderCfg = computeRender(1, "standard")
         
         if (visualCaptureEnabled) {
             VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
@@ -267,6 +267,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             "screensVisited" to visitedScreens.toList(),
             "screenCount" to visitedScreens.toSet().size
         )
+        val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
         
         SegmentDispatcher.shared.evaluateReplayRetention(sid, metrics) { retain, reason ->
             // UI operations MUST run on main thread
@@ -287,7 +288,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             }
             finalized = true
             
-            SegmentDispatcher.shared.concludeReplay(sid, termMs, bgTimeMs, metrics) { ok ->
+            SegmentDispatcher.shared.concludeReplay(sid, termMs, bgTimeMs, metrics, queueDepthAtFinalize) { ok ->
                 if (ok) clearRecovery()
                 completion?.invoke(true, ok)
             }
@@ -324,7 +325,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         // If recording is disabled, disable visual capture
         if (!recordingEnabled) {
             visualCaptureEnabled = false
-            DiagnosticLog.notice("[ReplayOrchestrator] Visual capture disabled by remote config (recordingEnabled=false)")
+            DiagnosticLog.trace("[ReplayOrchestrator] Visual capture disabled by remote config (recordingEnabled=false)")
         }
         
         // If already recording, restart the duration limit timer with updated config
@@ -332,7 +333,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             startDurationLimitTimer()
         }
         
-        DiagnosticLog.notice("[ReplayOrchestrator] Remote config applied: rejourneyEnabled=$rejourneyEnabled, recordingEnabled=$recordingEnabled, sampleRate=$sampleRate%, maxRecording=${maxRecordingMinutes}min, isSampledIn=$recordingEnabled")
+        DiagnosticLog.trace("[ReplayOrchestrator] Remote config applied: rejourneyEnabled=$rejourneyEnabled, recordingEnabled=$recordingEnabled, sampleRate=$sampleRate%, maxRecording=${maxRecordingMinutes}min, isSampledIn=$recordingEnabled")
     }
     
     fun unredactView(view: View) {
@@ -387,8 +388,9 @@ class ReplayOrchestrator private constructor(private val context: Context) {
                 "crashCount" to 1,
                 "durationSeconds" to ((nowMs - origStart) / 1000).toInt()
             )
+            val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
             
-            SegmentDispatcher.shared.concludeReplay(recId, nowMs, 0, crashMetrics) { ok ->
+            SegmentDispatcher.shared.concludeReplay(recId, nowMs, 0, crashMetrics, queueDepthAtFinalize) { ok ->
                 clearRecovery()
                 completion(if (ok) recId else null)
             }
@@ -467,10 +469,10 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     }
     
     private fun monitorNetwork(token: String) {
-        DiagnosticLog.notice("[ReplayOrchestrator] monitorNetwork called")
+        DiagnosticLog.trace("[ReplayOrchestrator] monitorNetwork called")
         val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
         if (connectivityManager == null) {
-            DiagnosticLog.notice("[ReplayOrchestrator] No ConnectivityManager, starting recording directly")
+            DiagnosticLog.trace("[ReplayOrchestrator] No ConnectivityManager, starting recording directly")
             beginRecording(token)
             return
         }
@@ -496,12 +498,12 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             // Check current network state immediately (callback only fires on CHANGES)
             val activeNetwork = connectivityManager.activeNetwork
             val capabilities = activeNetwork?.let { connectivityManager.getNetworkCapabilities(it) }
-            DiagnosticLog.notice("[ReplayOrchestrator] Network check: activeNetwork=${activeNetwork != null}, capabilities=${capabilities != null}")
+            DiagnosticLog.trace("[ReplayOrchestrator] Network check: activeNetwork=${activeNetwork != null}, capabilities=${capabilities != null}")
             if (capabilities != null) {
                 handleNetworkChange(capabilities, token)
             } else {
                 // No active network - start recording anyway, uploads will retry when network available
-                DiagnosticLog.notice("[ReplayOrchestrator] No active network, starting recording anyway")
+                DiagnosticLog.trace("[ReplayOrchestrator] No active network, starting recording anyway")
                 mainHandler.post { beginRecording(token) }
             }
         } catch (e: Exception) {
@@ -543,27 +545,27 @@ class ReplayOrchestrator private constructor(private val context: Context) {
     }
     
     private fun beginRecording(token: String) {
-        DiagnosticLog.notice("[ReplayOrchestrator] beginRecording called, live=$live")
+        DiagnosticLog.trace("[ReplayOrchestrator] beginRecording called, live=$live")
         if (live) {
-            DiagnosticLog.notice("[ReplayOrchestrator] Already live, skipping")
+            DiagnosticLog.trace("[ReplayOrchestrator] Already live, skipping")
             return
         }
         live = true
         
         this.apiToken = token
         initSession()
-        DiagnosticLog.notice("[ReplayOrchestrator] Session initialized: replayId=$replayId")
+        DiagnosticLog.trace("[ReplayOrchestrator] Session initialized: replayId=$replayId")
         
         // Reactivate the dispatcher in case it was halted from a previous session
         SegmentDispatcher.shared.activate()
         TelemetryPipeline.shared?.activate()
         
-        val renderCfg = computeRender(3, "high")
-        DiagnosticLog.notice("[ReplayOrchestrator] VisualCapture.shared=${VisualCapture.shared != null}, visualCaptureEnabled=$visualCaptureEnabled")
+        val renderCfg = computeRender(1, "standard")
+        DiagnosticLog.trace("[ReplayOrchestrator] VisualCapture.shared=${VisualCapture.shared != null}, visualCaptureEnabled=$visualCaptureEnabled")
         VisualCapture.shared?.configure(renderCfg.first, renderCfg.second)
         
         if (visualCaptureEnabled) {
-            DiagnosticLog.notice("[ReplayOrchestrator] Starting VisualCapture")
+            DiagnosticLog.trace("[ReplayOrchestrator] Starting VisualCapture")
             VisualCapture.shared?.beginCapture(replayStartMs)
         }
         if (interactionCaptureEnabled) InteractionRecorder.shared?.activate()
@@ -574,7 +576,7 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         // Start duration limit timer based on remote config
         startDurationLimitTimer()
         
-        DiagnosticLog.notice("[ReplayOrchestrator] beginRecording completed")
+        DiagnosticLog.trace("[ReplayOrchestrator] beginRecording completed")
     }
     
     // MARK: - Duration Limit Timer
@@ -591,19 +593,19 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         val remaining = if (maxMs > elapsed) maxMs - elapsed else 0L
         
         if (remaining <= 0) {
-            DiagnosticLog.notice("[ReplayOrchestrator] Duration limit already exceeded, stopping session")
+            DiagnosticLog.trace("[ReplayOrchestrator] Duration limit already exceeded, stopping session")
             endReplay()
             return
         }
         
         durationLimitRunnable = Runnable {
             if (!live) return@Runnable
-            DiagnosticLog.notice("[ReplayOrchestrator] Recording duration limit reached (${maxMinutes}min), stopping session")
+            DiagnosticLog.trace("[ReplayOrchestrator] Recording duration limit reached (${maxMinutes}min), stopping session")
             endReplay()
         }
         mainHandler.postDelayed(durationLimitRunnable!!, remaining)
         
-        DiagnosticLog.notice("[ReplayOrchestrator] Duration limit timer set: ${remaining / 1000}s remaining (max ${maxMinutes}min)")
+        DiagnosticLog.trace("[ReplayOrchestrator] Duration limit timer set: ${remaining / 1000}s remaining (max ${maxMinutes}min)")
     }
     
     private fun stopDurationLimitTimer() {
@@ -704,6 +706,13 @@ class ReplayOrchestrator private constructor(private val context: Context) {
             return
         }
         
+        // Throttle hierarchy capture when map is visible and animating —
+        // ViewHierarchyScanner traverses the full view tree including map's
+        // deep SurfaceView/TextureView children, adding main-thread pressure.
+        if (SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle) {
+            return
+        }
+        
         val hierarchy = ViewHierarchyScanner.shared?.captureHierarchy() ?: return
         
         val hash = hierarchyHash(hierarchy)
@@ -729,12 +738,12 @@ class ReplayOrchestrator private constructor(private val context: Context) {
 }
 
 private fun computeRender(fps: Int, tier: String): Pair<Double, Double> {
-    val interval = 1.0 / fps.coerceIn(1, 99)
-    val quality = when (tier.lowercase()) {
-        "low" -> 0.4
-        "standard" -> 0.5
-        "high" -> 0.6
-        else -> 0.5
-    }
-    return Pair(interval, quality)
+    val tierLower = tier.lowercase()
+    return when (tierLower) {
+        "minimal" -> Pair(2.0, 0.4)  // 0.5 fps for maximum size reduction
+        "low" -> Pair(1.0 / fps.coerceIn(1, 99), 0.4)
+        "standard" -> Pair(1.0 / fps.coerceIn(1, 99), 0.5)
+        "high" -> Pair(1.0 / fps.coerceIn(1, 99), 0.55)
+        else -> Pair(1.0 / fps.coerceIn(1, 99), 0.5)
+    }
 }