@rejourneyco/react-native 1.0.10 → 1.0.12

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

@@ -483,6 +483,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/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

@@ -429,6 +429,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/VisualCapture.swift

@@ -206,9 +206,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/ios/Rejourney.h

@@ -24,10 +24,14 @@
 #import <ReactCommon/RCTTurboModule.h>
 #if __has_include(<RejourneySpec/RejourneySpec.h>)
 #import <RejourneySpec/RejourneySpec.h>
+#define RJ_USE_NEW_ARCH_CODEGEN 1
 #elif __has_include("RejourneySpec.h")
 #import "RejourneySpec.h"
+#define RJ_USE_NEW_ARCH_CODEGEN 1
+#endif
 #endif
 
+#if defined(RCT_NEW_ARCH_ENABLED) && defined(RJ_USE_NEW_ARCH_CODEGEN)
 @interface Rejourney : NSObject <NativeRejourneySpec>
 #else
 @interface Rejourney : NSObject <RCTBridgeModule>

package/ios/Rejourney.mm

@@ -33,8 +33,10 @@
 #import <ReactCommon/RCTTurboModule.h>
 #if __has_include(<RejourneySpec/RejourneySpec.h>)
 #import <RejourneySpec/RejourneySpec.h>
+#define RJ_USE_NEW_ARCH_CODEGEN 1
 #elif __has_include("RejourneySpec.h")
 #import "RejourneySpec.h"
+#define RJ_USE_NEW_ARCH_CODEGEN 1
 #endif
 #endif
 
@@ -110,7 +112,7 @@ RCT_EXPORT_METHOD(removeListeners : (double)count) {
   return _impl;
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
+#if defined(RCT_NEW_ARCH_ENABLED) && defined(RJ_USE_NEW_ARCH_CODEGEN)
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeRejourneySpecJSI>(params);
@@ -139,20 +141,6 @@ RCT_EXPORT_METHOD(startSession : (NSString *)userId apiUrl : (NSString *)
               reject:reject];
 }
 
-RCT_EXPORT_METHOD(startSessionWithOptions : (NSDictionary *)options resolve : (
-    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
-  RejourneyImpl *impl = [self ensureImpl];
-  if (!impl) {
-    resolve(@{
-      @"success" : @NO,
-      @"sessionId" : @"",
-      @"error" : @"Native module not available"
-    });
-    return;
-  }
-  [impl startSessionWithOptions:options resolve:resolve reject:reject];
-}
-
 RCT_EXPORT_METHOD(stopSession : (RCTPromiseResolveBlock)
                       resolve reject : (RCTPromiseRejectBlock)reject) {
   RejourneyImpl *impl = [self ensureImpl];

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/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.10",
+    "version": "1.0.12",
     "description": "Rejourney Session Recording SDK for React Native",
     "main": "lib/commonjs/index.js",
     "module": "lib/module/index.js",

package/rejourney.podspec

@@ -18,6 +18,15 @@ Pod::Spec.new do |s|
   s.exclude_files = "ios/build/**/*"
   s.library      = "z"
 
-  # Dependencies
-  install_modules_dependencies(s)
+  # React Native core dependencies so headers like `React/RCTBridgeModule.h`
+  # are always available, regardless of React Native version or architecture.
+  # On modern React Native, `React-Core` is the canonical dependency.
+  s.dependency "React-Core"
+  s.dependency "ReactCommon/turbomodule/core"
+
+  # New Architecture / Codegen integration (RN 0.71+). On older RN versions
+  # this helper is not defined, so we guard it.
+  if respond_to?(:install_modules_dependencies)
+    install_modules_dependencies(s)
+  end
 end

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;