@rejourneyco/react-native 1.0.12 → 1.0.14

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

@@ -60,6 +60,7 @@ import kotlin.concurrent.withLock
  */
 sealed class SessionState {
     object Idle : SessionState()
+    data class Starting(val sessionId: String, val startTimeMs: Long) : SessionState()
     data class Active(val sessionId: String, val startTimeMs: Long) : SessionState()
     data class Paused(val sessionId: String, val startTimeMs: Long) : SessionState()
     object Terminated : SessionState()
@@ -488,9 +489,16 @@ class RejourneyModuleImpl(
             // Check if already active
             stateLock.withLock {
                 val currentState = state
-                if (currentState is SessionState.Active) {
-                    promise.resolve(createResultMap(true, currentState.sessionId))
-                    return@post
+                when (currentState) {
+                    is SessionState.Active -> {
+                        promise.resolve(createResultMap(true, currentState.sessionId))
+                        return@post
+                    }
+                    is SessionState.Starting -> {
+                        promise.resolve(createResultMap(true, currentState.sessionId))
+                        return@post
+                    }
+                    else -> Unit
                 }
             }
 
@@ -522,10 +530,10 @@ class RejourneyModuleImpl(
                 DiagnosticLog.fault("[Rejourney] CRITICAL: No current activity available for capture!")
             }
 
-            // Pre-generate session ID to ensure consistency between JS and native
-            val sid = "session_${System.currentTimeMillis()}_${java.util.UUID.randomUUID().toString().replace("-", "").lowercase()}"
-            ReplayOrchestrator.shared?.replayId = sid
-            TelemetryPipeline.shared?.currentReplayId = sid
+            val pendingSessionId = "session_${System.currentTimeMillis()}_${java.util.UUID.randomUUID().toString().replace("-", "").lowercase()}"
+            stateLock.withLock {
+                state = SessionState.Starting(pendingSessionId, System.currentTimeMillis())
+            }
 
             // Begin replay
             ReplayOrchestrator.shared?.beginReplay(
@@ -539,6 +547,7 @@ class RejourneyModuleImpl(
 
             // Allow orchestrator time to spin up
             mainHandler.postDelayed({
+                val sid = ReplayOrchestrator.shared?.replayId ?: pendingSessionId
                 stateLock.withLock {
                     state = SessionState.Active(sid, System.currentTimeMillis())
                 }

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

@@ -279,10 +279,14 @@ class ReplayOrchestrator private constructor(private val context: Context) {
         )
         val queueDepthAtFinalize = TelemetryPipeline.shared?.getQueueDepth() ?: 0
 
+        // Capture the current generation so a stale halt posted here won't
+        // stop a new session's capture that starts before this block runs.
+        val haltGeneration = VisualCapture.shared?.captureGeneration ?: -1
+
         // Do local teardown immediately so lifecycle rollover never depends on network latency.
         mainHandler.post {
             TelemetryPipeline.shared?.shutdown()
-            VisualCapture.shared?.halt()
+            VisualCapture.shared?.halt(haltGeneration)
             InteractionRecorder.shared?.deactivate()
             StabilityMonitor.shared?.deactivate()
             AnrSentinel.shared?.deactivate()

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

@@ -159,9 +159,12 @@ class TelemetryPipeline private constructor(private val context: Context) {
     fun shutdown() {
         heartbeatRunnable?.let { mainHandler.removeCallbacks(it) }
         heartbeatRunnable = null
-        
+
         SegmentDispatcher.shared.halt()
         appSuspending()
+
+        // Clear pending frame bundles so they don't leak into the next session
+        frameQueue.clear()
     }
     
     fun finalizeAndShip() {
@@ -181,9 +184,12 @@ class TelemetryPipeline private constructor(private val context: Context) {
     }
     
     fun submitFrameBundle(payload: ByteArray, filename: String, startMs: Long, endMs: Long, frameCount: Int) {
-        DiagnosticLog.trace("[TelemetryPipeline] submitFrameBundle: $frameCount frames, ${payload.size} bytes, deferredMode=$deferredMode")
+        // Capture the session ID now so frames are always attributed to the
+        // session that was active when they were captured, not when they ship.
+        val capturedSessionId = currentReplayId
+        DiagnosticLog.trace("[TelemetryPipeline] submitFrameBundle: $frameCount frames, ${payload.size} bytes, deferredMode=$deferredMode, session=$capturedSessionId")
         serialWorker.execute {
-            val bundle = PendingFrameBundle(filename, payload, startMs, endMs, frameCount)
+            val bundle = PendingFrameBundle(filename, payload, startMs, endMs, frameCount, capturedSessionId)
             frameQueue.enqueue(bundle)
             if (!deferredMode) shipPendingFrames()
         }
@@ -233,11 +239,23 @@ class TelemetryPipeline private constructor(private val context: Context) {
             DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: no frames in queue")
             return
         }
-        if (currentReplayId == null) {
-            DiagnosticLog.caution("[TelemetryPipeline] shipPendingFrames: no currentReplayId, requeueing")
+
+        // Determine which session these frames belong to. Prefer the session ID
+        // captured at enqueue time; fall back to the current active session.
+        val targetSession = next.sessionId ?: currentReplayId
+        if (targetSession == null) {
+            DiagnosticLog.caution("[TelemetryPipeline] shipPendingFrames: no session ID, requeueing")
             frameQueue.requeue(next)
             return
         }
+
+        // Drop frames that belong to a session that is no longer active —
+        // they would be uploaded under the wrong session and cause flickering.
+        if (next.sessionId != null && next.sessionId != currentReplayId && currentReplayId != null) {
+            DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: dropping ${next.count} stale frames from session ${next.sessionId} (current=${currentReplayId})")
+            serialWorker.execute { shipPendingFrames() }
+            return
+        }
         
         DiagnosticLog.trace("[TelemetryPipeline] shipPendingFrames: transmitting ${next.count} frames to SegmentDispatcher")
         
@@ -641,7 +659,8 @@ private data class PendingFrameBundle(
     val payload: ByteArray,
     val rangeStart: Long,
     val rangeEnd: Long,
-    val count: Int
+    val count: Int,
+    val sessionId: String? = null
 )
 
 private class FrameBundleQueue(private val maxPending: Int) {
@@ -671,4 +690,8 @@ private class FrameBundleQueue(private val maxPending: Int) {
     }
     
     fun size(): Int = queue.size
+
+    fun clear() {
+        lock.withLock { queue.clear() }
+    }
 }

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

@@ -79,6 +79,8 @@ class VisualCapture private constructor(private val context: Context) {
     private var deferredUntilCommit = false
     private var framesDiskPath: File? = null
     private var currentSessionId: String? = null
+    @Volatile var captureGeneration: Int = 0
+        private set
     
     private val mainHandler = Handler(Looper.getMainLooper())
     
@@ -103,10 +105,35 @@ class VisualCapture private constructor(private val context: Context) {
     
     fun beginCapture(sessionOrigin: Long) {
         DiagnosticLog.trace("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}, state=${stateMachine.currentState}")
+
+        // If we're still in CAPTURING state (halt() from previous session hasn't
+        // run yet due to async mainHandler.post), force-halt first to prevent the
+        // stale halt from stopping the new session's capture later.
+        if (stateMachine.currentState == CaptureState.CAPTURING) {
+            DiagnosticLog.trace("[VisualCapture] Force-halting stale capture before starting new session")
+            stopCaptureTimer()
+            stateMachine.transition(CaptureState.HALTED)
+        }
+
         if (!stateMachine.transition(CaptureState.CAPTURING)) {
             DiagnosticLog.trace("[VisualCapture] beginCapture REJECTED - state transition failed from ${stateMachine.currentState}")
             return
         }
+
+        // Bump generation so any stale halt() posted by the previous session
+        // (via mainHandler.post) becomes a no-op and doesn't stop this capture.
+        captureGeneration++
+
+        // Discard any frames left over from a previous session to prevent
+        // cross-session frame leakage (frames from session A appearing in session B).
+        stateLock.withLock {
+            val staleCount = screenshots.size
+            if (staleCount > 0) {
+                DiagnosticLog.trace("[VisualCapture] Clearing $staleCount stale frames from previous session")
+                screenshots.clear()
+            }
+        }
+
         sessionEpoch = sessionOrigin
         frameCounter.set(0)
         
@@ -122,7 +149,13 @@ class VisualCapture private constructor(private val context: Context) {
         startCaptureTimer()
     }
     
-    fun halt() {
+    fun halt(expectedGeneration: Int = -1) {
+        // If a specific generation is expected (async/posted halt from a previous
+        // session), skip if a new session has already started capture.
+        if (expectedGeneration >= 0 && expectedGeneration != captureGeneration) {
+            DiagnosticLog.trace("[VisualCapture] Skipping stale halt (gen=$expectedGeneration, current=$captureGeneration)")
+            return
+        }
         if (!stateMachine.transition(CaptureState.HALTED)) return
         stopCaptureTimer()
         

package/ios/Engine/RejourneyImpl.swift

@@ -27,6 +27,7 @@ public final class RejourneyImpl: NSObject {
 
     private enum SessionState {
         case idle
+        case starting(sessionId: String, startTime: TimeInterval)
         case active(sessionId: String, startTime: TimeInterval)
         case paused(sessionId: String, startTime: TimeInterval)
         case terminated
@@ -353,12 +354,14 @@ public final class RejourneyImpl: NSObject {
             }
 
             self.stateLock.lock()
-            if case .active(let sid, _) = self.state {
+            switch self.state {
+            case .active(let sid, _), .starting(let sid, _):
                 self.stateLock.unlock()
                 resolve(["success": true, "sessionId": sid])
                 return
+            default:
+                self.stateLock.unlock()
             }
-            self.stateLock.unlock()
 
             if !userId.isEmpty && userId != "anonymous" && !userId.hasPrefix("anon_") {
                 self.currentUserIdentity = userId
@@ -376,11 +379,17 @@ public final class RejourneyImpl: NSObject {
             // Activate native network interception
             RejourneyURLProtocol.enable()
 
+            let pendingSessionId = "session_\(Int(Date().timeIntervalSince1970 * 1000))_\(UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased())"
+            let pendingStart = Date().timeIntervalSince1970
+            self.stateLock.lock()
+            self.state = .starting(sessionId: pendingSessionId, startTime: pendingStart)
+            self.stateLock.unlock()
+
             ReplayOrchestrator.shared.beginReplay(apiToken: publicKey, serverEndpoint: apiUrl, captureSettings: config)
 
             // Allow orchestrator time to spin up
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-                let sid = ReplayOrchestrator.shared.replayId ?? UUID().uuidString
+                let sid = ReplayOrchestrator.shared.replayId ?? pendingSessionId
                 let start = Date().timeIntervalSince1970
 
                 self.stateLock.lock()

package/ios/Recording/ReplayOrchestrator.swift

@@ -235,10 +235,14 @@ public final class ReplayOrchestrator: NSObject {
         ]
         let queueDepthAtFinalize = TelemetryPipeline.shared.getQueueDepth()
 
+        // Capture the current generation so a stale halt posted here won't
+        // stop a new session's capture that starts before this block runs.
+        let haltGeneration = VisualCapture.shared.captureGeneration
+
         // Do local teardown immediately so lifecycle rollover never depends on network latency.
         DispatchQueue.main.async {
             TelemetryPipeline.shared.shutdown()
-            VisualCapture.shared.halt()
+            VisualCapture.shared.halt(expectedGeneration: haltGeneration)
             InteractionRecorder.shared.deactivate()
             FaultTracker.shared.deactivate()
             ResponsivenessWatcher.shared.halt()

package/ios/Recording/TelemetryPipeline.swift

@@ -127,6 +127,9 @@ public final class TelemetryPipeline: NSObject {
         
         SegmentDispatcher.shared.halt()
         _appSuspending()
+
+        // Clear pending frame bundles so they don't leak into the next session
+        _frameQueue.clear()
     }
     
     @objc public func finalizeAndShip() {
@@ -146,8 +149,11 @@ public final class TelemetryPipeline: NSObject {
     }
     
     @objc public func submitFrameBundle(payload: Data, filename: String, startMs: UInt64, endMs: UInt64, frameCount: Int) {
+        // Capture the session ID now so frames are always attributed to the
+        // session that was active when they were captured, not when they ship.
+        let capturedSessionId = currentReplayId
         _serialWorker.async {
-            let bundle = PendingFrameBundle(tag: filename, payload: payload, rangeStart: startMs, rangeEnd: endMs, count: frameCount)
+            let bundle = PendingFrameBundle(tag: filename, payload: payload, rangeStart: startMs, rangeEnd: endMs, count: frameCount, sessionId: capturedSessionId)
             self._frameQueue.enqueue(bundle)
             if !self._deferredMode { self._shipPendingFrames() }
         }
@@ -246,7 +252,19 @@ public final class TelemetryPipeline: NSObject {
     }
     
     private func _shipPendingFrames() {
-        guard !_deferredMode, let next = _frameQueue.dequeue(), currentReplayId != nil else { return }
+        guard !_deferredMode, let next = _frameQueue.dequeue() else { return }
+
+        guard currentReplayId != nil else {
+            _frameQueue.requeue(next)
+            return
+        }
+
+        // Drop frames that belong to a session that is no longer active
+        if let bundleSession = next.sessionId, bundleSession != currentReplayId {
+            DiagnosticLog.trace("[TelemetryPipeline] Dropping \(next.count) stale frames from session \(bundleSession)")
+            _shipPendingFrames()
+            return
+        }
         
         SegmentDispatcher.shared.transmitFrameBundle(
             payload: next.payload,
@@ -569,6 +587,7 @@ private struct PendingFrameBundle {
     let rangeStart: UInt64
     let rangeEnd: UInt64
     let count: Int
+    let sessionId: String?
 }
 
 private final class FrameBundleQueue {
@@ -605,4 +624,10 @@ private final class FrameBundleQueue {
         defer { _lock.unlock() }
         _queue.insert(bundle, at: 0)
     }
+
+    func clear() {
+        _lock.lock()
+        defer { _lock.unlock() }
+        _queue.removeAll()
+    }
 }

package/ios/Recording/VisualCapture.swift

@@ -44,6 +44,7 @@ public final class VisualCapture: NSObject {
     private var _deferredUntilCommit = false
     private var _framesDiskPath: URL?
     private var _currentSessionId: String?
+    @objc public private(set) var captureGeneration: Int = 0
     
     // Use OperationQueue like industry standard - serialized, utility QoS
     private let _encodeQueue: OperationQueue = {
@@ -105,7 +106,28 @@ public final class VisualCapture: NSObject {
     }
     
     @objc public func beginCapture(sessionOrigin: UInt64) {
+        // If still in CAPTURING state (halt() from previous session hasn't
+        // run yet), force-halt first to prevent it from stopping the new session.
+        if _stateMachine.currentState == .capturing {
+            DiagnosticLog.trace("[VisualCapture] Force-halting stale capture before starting new session")
+            _stopCaptureTimer()
+            _ = _stateMachine.transition(to: .halted)
+        }
+
         guard _stateMachine.transition(to: .capturing) else { return }
+
+        // Bump generation so any stale halt() becomes a no-op
+        captureGeneration += 1
+
+        // Discard leftover frames from the previous session
+        _stateLock.lock()
+        let staleCount = _screenshots.count
+        if staleCount > 0 {
+            DiagnosticLog.trace("[VisualCapture] Clearing \(staleCount) stale frames from previous session")
+            _screenshots.removeAll()
+        }
+        _stateLock.unlock()
+
         _sessionEpoch = sessionOrigin
         _frameCounter = 0
         
@@ -120,7 +142,13 @@ public final class VisualCapture: NSObject {
         _startCaptureTimer()
     }
     
-    @objc public func halt() {
+    @objc public func halt(expectedGeneration: Int = -1) {
+        // If a specific generation is expected (async/posted halt from a previous
+        // session), skip if a new session has already started capture.
+        if expectedGeneration >= 0 && expectedGeneration != captureGeneration {
+            DiagnosticLog.trace("[VisualCapture] Skipping stale halt (gen=\(expectedGeneration), current=\(captureGeneration))")
+            return
+        }
         guard _stateMachine.transition(to: .halted) else { return }
         _stopCaptureTimer()
         

package/lib/commonjs/index.js

@@ -292,7 +292,7 @@ let _authErrorSubscription = null;
 let _currentAppState = 'active'; // Default to active, will be updated on init
 let _userIdentity = null;
 let _backgroundEntryTime = null; // Track when app went to background
-let _storedMetadata = {}; // Accumulate metadata for session rollover
+const _storedMetadata = {}; // Accumulate metadata for session rollover
 
 // Session timeout - must match native side (60 seconds)
 const SESSION_TIMEOUT_MS = 60_000;

package/lib/module/index.js

@@ -189,7 +189,7 @@ let _authErrorSubscription = null;
 let _currentAppState = 'active'; // Default to active, will be updated on init
 let _userIdentity = null;
 let _backgroundEntryTime = null; // Track when app went to background
-let _storedMetadata = {}; // Accumulate metadata for session rollover
+const _storedMetadata = {}; // Accumulate metadata for session rollover
 
 // Session timeout - must match native side (60 seconds)
 const SESSION_TIMEOUT_MS = 60_000;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rejourneyco/react-native",
-    "version": "1.0.12",
+    "version": "1.0.14",
     "description": "Rejourney Session Recording SDK for React Native",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",

package/src/index.ts

@@ -212,7 +212,7 @@ let _authErrorSubscription: { remove: () => void } | null = null;
 let _currentAppState: string = 'active'; // Default to active, will be updated on init
 let _userIdentity: string | null = null;
 let _backgroundEntryTime: number | null = null; // Track when app went to background
-let _storedMetadata: Record<string, string | number | boolean> = {}; // Accumulate metadata for session rollover
+const _storedMetadata: Record<string, string | number | boolean> = {}; // Accumulate metadata for session rollover
 
 // Session timeout - must match native side (60 seconds)
 const SESSION_TIMEOUT_MS = 60_000;