@rejourneyco/react-native 1.0.11 → 1.0.13

package/README.md

@@ -64,22 +64,29 @@ Rejourney.trackScreen('Custom Screen Name');
 
 ## Custom Events & Metadata
 
-You can track custom events and assign metadata to sessions to filter and segment them later.
+Track user actions and attach session-level context for filtering and segmentation in the dashboard.
 
 ```typescript
 import { Rejourney } from '@rejourneyco/react-native';
 
-// Log custom events
-Rejourney.logEvent('button_clicked', { buttonName: 'signup' });
+// Log custom events with optional properties
+Rejourney.logEvent('signup_completed');
+Rejourney.logEvent('purchase_completed', {
+  plan: 'pro',
+  amount: 29.99
+});
 
-// Add custom session metadata
+// Attach session-level metadata (key-value context)
 Rejourney.setMetadata('plan', 'premium');
 Rejourney.setMetadata({
-  role: 'tester',
-  ab_test_group: 'A'
+  role: 'admin',
+  ab_variant: 'checkout_v2'
 });
 ```
 
+**Events** = things that happened (actions, timestamped, can occur multiple times)
+**Metadata** = who the user is / what state they're in (session-level, one value per key)
+
 ## API Reference & Compatibility
 
 Rejourney supports both a standardized `Rejourney.` namespace and standalone function exports (AKA calls). Both are fully supported.

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()
@@ -483,6 +487,10 @@ class ReplayOrchestrator private constructor(private val context: Context) {
 
     fun logScreenView(screenId: String) {
         if (screenId.isEmpty()) return
+        if (visitedScreens.size >= 500) {
+            val excess = visitedScreens.size - 250
+            repeat(excess) { visitedScreens.removeAt(0) }
+        }
         visitedScreens.add(screenId)
         currentScreenName = screenId
         if (hierarchyCaptureEnabled) captureHierarchy()

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

@@ -125,15 +125,17 @@ class SegmentDispatcher private constructor() {
     private val scope = CoroutineScope(workerExecutor.asCoroutineDispatcher() + SupervisorJob())
     
     private val httpClient: OkHttpClient = OkHttpClient.Builder()
-        .connectTimeout(5, TimeUnit.SECONDS) // Short timeout for debugging
+        .connectTimeout(5, TimeUnit.SECONDS)
         .readTimeout(10, TimeUnit.SECONDS)
         .writeTimeout(10, TimeUnit.SECONDS)
-        // Mirror iOS URLProtocol: ensure native upload/auth traffic is captured
-        .addInterceptor(RejourneyNetworkInterceptor())
+        // Intentionally NO RejourneyNetworkInterceptor here: intercepting our
+        // own upload traffic creates redundant network events, wastes bandwidth,
+        // and can cause circular upload→intercept→upload chains.
         .build()
     
     private val retryQueue = mutableListOf<PendingUpload>()
     private val retryLock = ReentrantLock()
+    private val maxRetryQueueSize = 20
     private var active = true
     
     fun configure(replayId: String, apiToken: String?, credential: String?, projectId: String?, isSampledIn: Boolean = true) {
@@ -411,6 +413,9 @@ class SegmentDispatcher private constructor() {
         if (upload.attempt < 3) {
             val retry = upload.copy(attempt = upload.attempt + 1)
             retryLock.withLock {
+                if (retryQueue.size >= maxRetryQueueSize) {
+                    retryQueue.removeAt(0)
+                }
                 retryQueue.add(retry)
             }
             metricsLock.withLock {

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/Recording/RejourneyURLProtocol.swift

@@ -18,22 +18,26 @@ import Foundation
 
 /// Intercepts URLSession network traffic globally for Rejourney Session Replay.
 @objc(RejourneyURLProtocol)
-public class RejourneyURLProtocol: URLProtocol, URLSessionDataDelegate, URLSessionTaskDelegate {
+public class RejourneyURLProtocol: URLProtocol {
     
-    // We tag requests that we've already handled so we don't intercept them repeatedly.
     private static let _handledKey = "co.rejourney.handled"
     
     private var _dataTask: URLSessionDataTask?
     private var _startMs: Int64 = 0
     private var _endMs: Int64 = 0
-    private var _responseData: Data?
     private var _response: URLResponse?
     private var _error: Error?
     
-    // Session used to forward the intercepted request execution
-    private lazy var _session: URLSession = {
-        let config = URLSessionConfiguration.default
-        return URLSession(configuration: config, delegate: self, delegateQueue: nil)
+    /// Shared forwarding session. Uses ephemeral config with protocol classes
+    /// stripped to prevent self-interception, and a delegate adapter that routes
+    /// callbacks to the correct RejourneyURLProtocol instance via a task map.
+    /// This avoids the per-instance URLSession retain cycle that previously
+    /// leaked every intercepted request (~1-3MB each).
+    private static let _delegateAdapter = SessionDelegateAdapter()
+    private static let _sharedSession: URLSession = {
+        let cfg = URLSessionConfiguration.ephemeral
+        cfg.protocolClasses = []
+        return URLSession(configuration: cfg, delegate: _delegateAdapter, delegateQueue: nil)
     }()
     
     @objc public static func enable() {
@@ -130,30 +134,32 @@ public class RejourneyURLProtocol: URLProtocol, URLSessionDataDelegate, URLSessi
         URLProtocol.setProperty(true, forKey: RejourneyURLProtocol._handledKey, in: request)
         
         _startMs = Int64(Date().timeIntervalSince1970 * 1000)
-        _dataTask = _session.dataTask(with: request as URLRequest)
-        _dataTask?.resume()
+        let task = Self._sharedSession.dataTask(with: request as URLRequest)
+        Self._delegateAdapter.register(task: task, protocol: self)
+        _dataTask = task
+        task.resume()
     }
     
     public override func stopLoading() {
-        _dataTask?.cancel()
+        if let task = _dataTask {
+            Self._delegateAdapter.unregister(task: task)
+            task.cancel()
+        }
         _dataTask = nil
     }
     
-    // MARK: - URLSessionDataDelegate
+    // MARK: - Callbacks from SessionDelegateAdapter
     
-    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+    fileprivate func handleDidReceiveData(_ data: Data) {
         client?.urlProtocol(self, didLoad: data)
     }
     
-    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+    fileprivate func handleDidReceiveResponse(_ response: URLResponse) {
         _response = response
         client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
-        completionHandler(.allow)
     }
     
-    // MARK: - URLSessionTaskDelegate
-    
-    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    fileprivate func handleDidComplete(error: Error?) {
         _endMs = Int64(Date().timeIntervalSince1970 * 1000)
         _error = error
         
@@ -162,7 +168,9 @@ public class RejourneyURLProtocol: URLProtocol, URLSessionDataDelegate, URLSessi
         } else {
             client?.urlProtocolDidFinishLoading(self)
         }
-        
+    }
+    
+    fileprivate func handleDidCompleteLogging(task: URLSessionTask) {
         _logRequest(task: task)
     }
     
@@ -214,3 +222,45 @@ public class RejourneyURLProtocol: URLProtocol, URLSessionDataDelegate, URLSessi
         TelemetryPipeline.shared.recordNetworkEvent(details: event)
     }
 }
+
+/// Routes URLSession delegate callbacks to the correct RejourneyURLProtocol
+/// instance using a task-to-protocol map. Uses weak references to avoid
+/// retaining protocol instances that have been stopped by the URL loading system.
+private final class SessionDelegateAdapter: NSObject, URLSessionDataDelegate, URLSessionTaskDelegate {
+    private let _lock = NSLock()
+    private let _taskMap = NSMapTable<URLSessionTask, RejourneyURLProtocol>.strongToWeakObjects()
+    
+    func register(task: URLSessionTask, protocol proto: RejourneyURLProtocol) {
+        _lock.lock()
+        _taskMap.setObject(proto, forKey: task)
+        _lock.unlock()
+    }
+    
+    func unregister(task: URLSessionTask) {
+        _lock.lock()
+        _taskMap.removeObject(forKey: task)
+        _lock.unlock()
+    }
+    
+    private func proto(for task: URLSessionTask) -> RejourneyURLProtocol? {
+        _lock.lock()
+        defer { _lock.unlock() }
+        return _taskMap.object(forKey: task)
+    }
+    
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        proto(for: dataTask)?.handleDidReceiveData(data)
+    }
+    
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        proto(for: dataTask)?.handleDidReceiveResponse(response)
+        completionHandler(.allow)
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        guard let p = proto(for: task) else { return }
+        p.handleDidComplete(error: error)
+        p.handleDidCompleteLogging(task: task)
+        unregister(task: task)
+    }
+}

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()
@@ -429,6 +433,9 @@ public final class ReplayOrchestrator: NSObject {
 
     @objc public func logScreenView(_ screenId: String) {
         guard !screenId.isEmpty else { return }
+        if _visitedScreens.count >= 500 {
+            _visitedScreens.removeFirst(_visitedScreens.count - 250)
+        }
         _visitedScreens.append(screenId)
         currentScreenName = screenId
         if hierarchyCaptureEnabled { _captureHierarchy() }

package/ios/Recording/SegmentDispatcher.swift

@@ -44,17 +44,21 @@ final class SegmentDispatcher {
     }()
     
     private let httpSession: URLSession = {
-        // Industry standard: Use ephemeral config with explicit connection limits
         let cfg = URLSessionConfiguration.ephemeral
         cfg.httpMaximumConnectionsPerHost = 4
         cfg.waitsForConnectivity = true
         cfg.timeoutIntervalForRequest = 30
         cfg.timeoutIntervalForResource = 60
+        // Strip our own protocol to prevent self-interception. Without this,
+        // every SDK upload is intercepted by RejourneyURLProtocol which
+        // generates redundant network events and wastes resources.
+        cfg.protocolClasses = cfg.protocolClasses?.filter { $0 != RejourneyURLProtocol.self } ?? []
         return URLSession(configuration: cfg)
     }()
     
     private var retryQueue: [PendingUpload] = []
     private let retryLock = NSLock()
+    private let maxRetryQueueSize = 20
     private var active = true
     
     private let metricsLock = NSLock()
@@ -332,6 +336,9 @@ final class SegmentDispatcher {
             var retry = upload
             retry.attempt += 1
             retryLock.lock()
+            if retryQueue.count >= maxRetryQueueSize {
+                retryQueue.removeFirst()
+            }
             retryQueue.append(retry)
             retryLock.unlock()
             

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()
         
@@ -206,9 +234,16 @@ public final class VisualCapture: NSObject {
         // Refresh map detection state (very cheap shallow walk)
         SpecialCases.shared.refreshMapState()
         
-        // Debug-only: confirm capture is running and map state
         if _frameCounter < 5 || _frameCounter % 30 == 0 {
-            DiagnosticLog.trace("[VisualCapture] frame#\(_frameCounter) mapVisible=\(SpecialCases.shared.mapVisible) mapIdle=\(SpecialCases.shared.mapIdle) forced=\(forced)")
+            var info = mach_task_basic_info()
+            var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+            let _ = withUnsafeMutablePointer(to: &info) {
+                $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                    task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+                }
+            }
+            let memMB = Double(info.resident_size) / 1_048_576.0
+            DiagnosticLog.trace("[VisualCapture] frame#\(_frameCounter) mapVisible=\(SpecialCases.shared.mapVisible) mapIdle=\(SpecialCases.shared.mapIdle) forced=\(forced) residentMB=\(String(format: "%.0f", memMB))")
         }
         
         // Map stutter prevention: when a map view is visible and its camera

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/commonjs/sdk/autoTracking.js

@@ -902,6 +902,9 @@ function trackScreen(screenName) {
   }
   const previousScreen = currentScreen;
   currentScreen = screenName;
+  if (screensVisited.length >= 500) {
+    screensVisited.splice(0, screensVisited.length - 250);
+  }
   screensVisited.push(screenName);
   const uniqueScreens = new Set(screensVisited);
   metrics.uniqueScreensCount = uniqueScreens.size;

package/lib/commonjs/sdk/metricsTracking.js

@@ -141,6 +141,9 @@ function incrementErrorCount() {
   metrics.totalEvents++;
 }
 function addScreenVisited(screenName) {
+  if (metrics.screensVisited.length >= 500) {
+    metrics.screensVisited.splice(0, metrics.screensVisited.length - 250);
+  }
   metrics.screensVisited.push(screenName);
   metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
 }

package/lib/commonjs/sdk/networkInterceptor.js

@@ -91,13 +91,10 @@ async function getFetchResponseSize(response) {
     const parsed = parseInt(contentLength, 10);
     if (Number.isFinite(parsed) && parsed > 0) return parsed;
   }
-  try {
-    const cloned = response.clone();
-    const buffer = await cloned.arrayBuffer();
-    return buffer.byteLength;
-  } catch {
-    return 0;
-  }
+
+  // Don't clone+buffer the full body just to measure size when
+  // content-length is missing — this doubles memory for large responses.
+  return 0;
 }
 function getXhrResponseSize(xhr) {
   try {
@@ -347,6 +344,9 @@ function interceptXHR() {
     }
     data.t = Date.now();
     const onComplete = () => {
+      this.removeEventListener('load', onComplete);
+      this.removeEventListener('error', onComplete);
+      this.removeEventListener('abort', onComplete);
       const endTime = Date.now();
       const responseBodySize = config.captureSizes ? getXhrResponseSize(this) : 0;
       queueRequest({

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/lib/module/sdk/autoTracking.js

@@ -872,6 +872,9 @@ export function trackScreen(screenName) {
   }
   const previousScreen = currentScreen;
   currentScreen = screenName;
+  if (screensVisited.length >= 500) {
+    screensVisited.splice(0, screensVisited.length - 250);
+  }
   screensVisited.push(screenName);
   const uniqueScreens = new Set(screensVisited);
   metrics.uniqueScreensCount = uniqueScreens.size;

package/lib/module/sdk/metricsTracking.js

@@ -123,6 +123,9 @@ export function incrementErrorCount() {
   metrics.totalEvents++;
 }
 export function addScreenVisited(screenName) {
+  if (metrics.screensVisited.length >= 500) {
+    metrics.screensVisited.splice(0, metrics.screensVisited.length - 250);
+  }
   metrics.screensVisited.push(screenName);
   metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
 }

package/lib/module/sdk/networkInterceptor.js

@@ -80,13 +80,10 @@ async function getFetchResponseSize(response) {
     const parsed = parseInt(contentLength, 10);
     if (Number.isFinite(parsed) && parsed > 0) return parsed;
   }
-  try {
-    const cloned = response.clone();
-    const buffer = await cloned.arrayBuffer();
-    return buffer.byteLength;
-  } catch {
-    return 0;
-  }
+
+  // Don't clone+buffer the full body just to measure size when
+  // content-length is missing — this doubles memory for large responses.
+  return 0;
 }
 function getXhrResponseSize(xhr) {
   try {
@@ -336,6 +333,9 @@ function interceptXHR() {
     }
     data.t = Date.now();
     const onComplete = () => {
+      this.removeEventListener('load', onComplete);
+      this.removeEventListener('error', onComplete);
+      this.removeEventListener('abort', onComplete);
       const endTime = Date.now();
       const responseBodySize = config.captureSizes ? getXhrResponseSize(this) : 0;
       queueRequest({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rejourneyco/react-native",
-    "version": "1.0.11",
+    "version": "1.0.13",
     "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;

package/src/sdk/autoTracking.ts

@@ -1035,6 +1035,9 @@ export function trackScreen(screenName: string): void {
 
   const previousScreen = currentScreen;
   currentScreen = screenName;
+  if (screensVisited.length >= 500) {
+    screensVisited.splice(0, screensVisited.length - 250);
+  }
   screensVisited.push(screenName);
 
   const uniqueScreens = new Set(screensVisited);

package/src/sdk/metricsTracking.ts

@@ -153,6 +153,9 @@ export function incrementErrorCount(): void {
 }
 
 export function addScreenVisited(screenName: string): void {
+    if (metrics.screensVisited.length >= 500) {
+        metrics.screensVisited.splice(0, metrics.screensVisited.length - 250);
+    }
     metrics.screensVisited.push(screenName);
     metrics.uniqueScreensCount = new Set(metrics.screensVisited).size;
 }

package/src/sdk/networkInterceptor.ts

@@ -98,13 +98,9 @@ async function getFetchResponseSize(response: Response): Promise<number> {
     if (Number.isFinite(parsed) && parsed > 0) return parsed;
   }
 
-  try {
-    const cloned = response.clone();
-    const buffer = await cloned.arrayBuffer();
-    return buffer.byteLength;
-  } catch {
-    return 0;
-  }
+  // Don't clone+buffer the full body just to measure size when
+  // content-length is missing — this doubles memory for large responses.
+  return 0;
 }
 
 function getXhrResponseSize(xhr: XMLHttpRequest): number {
@@ -403,6 +399,10 @@ function interceptXHR(): void {
     data.t = Date.now();
 
     const onComplete = () => {
+      this.removeEventListener('load', onComplete);
+      this.removeEventListener('error', onComplete);
+      this.removeEventListener('abort', onComplete);
+
       const endTime = Date.now();
 
       const responseBodySize = config.captureSizes ? getXhrResponseSize(this) : 0;