@rejourneyco/react-native 1.0.8 → 1.0.10

package/ios/Recording/AnrSentinel.swift

@@ -18,64 +18,64 @@ import Foundation
 
 @objc(AnrSentinel)
 public final class AnrSentinel: NSObject {
-    
+
     @objc public static let shared = AnrSentinel()
-    
+
     private let _freezeThreshold: TimeInterval = 5.0
     private let _pollFrequency: TimeInterval = 2.0
-    
+
     private var _watchThread: Thread?
     private var _volatile = VolatileState()
     private let _stateLock = os_unfair_lock_t.allocate(capacity: 1)
-    
+
     private override init() {
         _stateLock.initialize(to: os_unfair_lock())
         super.init()
     }
-    
+
     deinit {
         _stateLock.deallocate()
     }
-    
+
     @objc public func activate() {
         os_unfair_lock_lock(_stateLock)
         guard _watchThread == nil else {
             os_unfair_lock_unlock(_stateLock)
             return
         }
-        
+
         _volatile.running = true
         _volatile.lastResponse = Date().timeIntervalSince1970
-        
+
         let t = Thread { [weak self] in self?._watchLoop() }
         t.name = "co.rejourney.anr"
         t.qualityOfService = .utility
         _watchThread = t
         os_unfair_lock_unlock(_stateLock)
-        
+
         t.start()
     }
-    
+
     @objc public func halt() {
         os_unfair_lock_lock(_stateLock)
         _volatile.running = false
         _watchThread = nil
         os_unfair_lock_unlock(_stateLock)
     }
-    
+
     private func _watchLoop() {
         while true {
             os_unfair_lock_lock(_stateLock)
             let running = _volatile.running
             os_unfair_lock_unlock(_stateLock)
             guard running else { break }
-            
+
             _sendPing()
             Thread.sleep(forTimeInterval: _pollFrequency)
             _checkPong()
         }
     }
-    
+
     private func _sendPing() {
         os_unfair_lock_lock(_stateLock)
         if _volatile.awaitingPong {
@@ -84,7 +84,7 @@ public final class AnrSentinel: NSObject {
         }
         _volatile.awaitingPong = true
         os_unfair_lock_unlock(_stateLock)
-        
+
         DispatchQueue.main.async { [weak self] in
             guard let self else { return }
             os_unfair_lock_lock(self._stateLock)
@@ -93,30 +93,62 @@ public final class AnrSentinel: NSObject {
             os_unfair_lock_unlock(self._stateLock)
         }
     }
-    
+
     private func _checkPong() {
         os_unfair_lock_lock(_stateLock)
         let awaiting = _volatile.awaitingPong
         let last = _volatile.lastResponse
+        let lastReportedAt = _volatile.lastAnrReport
         os_unfair_lock_unlock(_stateLock)
-        
+
         guard awaiting else { return }
-        
-        let delta = Date().timeIntervalSince1970 - last
+
+        let now = Date().timeIntervalSince1970
+        let delta = now - last
         if delta >= _freezeThreshold {
+            // Avoid spamming duplicate ANRs while one long freeze persists.
+            if now - lastReportedAt < _freezeThreshold {
+                return
+            }
+
+            os_unfair_lock_lock(_stateLock)
+            _volatile.lastAnrReport = now
+            _volatile.lastResponse = now
+            _volatile.awaitingPong = false
+            os_unfair_lock_unlock(_stateLock)
+
             _reportFreeze(duration: delta)
         }
     }
-    
+
     private func _reportFreeze(duration: TimeInterval) {
         DiagnosticLog.emit(.caution, "Main thread frozen for \(String(format: "%.1f", duration))s")
-        
+
         ReplayOrchestrator.shared.incrementStalledTally()
-        
+
         let trace = Thread.callStackSymbols.joined(separator: "\n")
         let ms = Int(duration * 1000)
-        
+
         TelemetryPipeline.shared.recordAnrEvent(durationMs: ms, stack: trace)
+
+        // Persist ANR incident and send through /api/ingest/fault so ANRs survive
+        // process termination/background upload loss, similar to crash recovery.
+        let incident = IncidentRecord(
+            sessionId: StabilityMonitor.shared.currentSessionId ?? ReplayOrchestrator.shared.replayId ?? "unknown",
+            timestampMs: UInt64(Date().timeIntervalSince1970 * 1000),
+            category: "anr",
+            identifier: "MainThreadFrozen",
+            detail: "Main thread unresponsive for \(ms)ms",
+            frames: trace
+                .split(separator: "\n")
+                .map { String($0).trimmingCharacters(in: .whitespacesAndNewlines) },
+            context: [
+                "durationMs": String(ms),
+                "threadState": "blocked"
+            ]
+        )
+        StabilityMonitor.shared.persistIncidentSync(incident)
+        StabilityMonitor.shared.transmitStoredReport()
     }
 }
 
@@ -124,18 +156,19 @@ private struct VolatileState {
     var running = false
     var awaitingPong = false
     var lastResponse: TimeInterval = 0
+    var lastAnrReport: TimeInterval = 0
 }
 
 @objc(ResponsivenessWatcher)
 public final class ResponsivenessWatcher: NSObject {
     @objc public static let shared = ResponsivenessWatcher()
-    
+
     private override init() { super.init() }
-    
+
     @objc public func activate() {
         AnrSentinel.shared.activate()
     }
-    
+
     @objc public func halt() {
         AnrSentinel.shared.halt()
     }

package/ios/Recording/InteractionRecorder.swift

@@ -101,6 +101,7 @@ public final class InteractionRecorder: NSObject {
         for touch in touches {
             switch touch.phase {
             case .began:
+                VisualCapture.shared.invalidateMaskCache()
                 SpecialCases.shared.notifyTouchBegan()
             case .ended, .cancelled:
                 SpecialCases.shared.notifyTouchEnded()

package/ios/Recording/RejourneyURLProtocol.swift

@@ -0,0 +1,216 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/// Intercepts URLSession network traffic globally for Rejourney Session Replay.
+@objc(RejourneyURLProtocol)
+public class RejourneyURLProtocol: URLProtocol, URLSessionDataDelegate, URLSessionTaskDelegate {
+    
+    // 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)
+    }()
+    
+    @objc public static func enable() {
+        URLProtocol.registerClass(RejourneyURLProtocol.self)
+        
+        // Swizzle URLSessionConfiguration.protocolClasses to automatically inject our protocol
+        // into custom sessions (e.g. used by SDWebImage, AlamoFire, etc.)
+        swizzleProtocolClasses()
+    }
+    
+    private static var isSwizzled = false
+    
+    /// Store the original IMP so we can call through to it safely.
+    private static var originalProtocolClassesIMP: IMP?
+    
+    private static func swizzleProtocolClasses() {
+        guard !isSwizzled else { return }
+        
+        let configClass: AnyClass = URLSessionConfiguration.self
+        let originalSel = #selector(getter: URLSessionConfiguration.protocolClasses)
+        let swizzledSel = #selector(RejourneyURLProtocol.rj_protocolClasses)
+        
+        guard let originalMethod = class_getInstanceMethod(configClass, originalSel),
+              let swizzledMethod = class_getInstanceMethod(RejourneyURLProtocol.self, swizzledSel) else {
+            return
+        }
+        
+        // Add the swizzled method onto URLSessionConfiguration itself so that
+        // method_exchangeImplementations works within a single class.
+        let didAdd = class_addMethod(
+            configClass,
+            swizzledSel,
+            method_getImplementation(swizzledMethod),
+            method_getTypeEncoding(swizzledMethod)
+        )
+        
+        if didAdd, let addedMethod = class_getInstanceMethod(configClass, swizzledSel) {
+            originalProtocolClassesIMP = method_getImplementation(originalMethod)
+            method_exchangeImplementations(originalMethod, addedMethod)
+        }
+        
+        isSwizzled = true
+    }
+    
+    /// Replacement getter injected into URLSessionConfiguration.
+    /// After exchange, `self` IS a URLSessionConfiguration instance.
+    @objc private func rj_protocolClasses() -> [AnyClass]? {
+        // Call through to the original implementation via the saved IMP
+        typealias OriginalFunc = @convention(c) (AnyObject, Selector) -> [AnyClass]?
+        var classes: [AnyClass] = []
+        
+        if let imp = RejourneyURLProtocol.originalProtocolClassesIMP {
+            let original = unsafeBitCast(imp, to: OriginalFunc.self)
+            classes = original(self, #selector(getter: URLSessionConfiguration.protocolClasses)) ?? []
+        }
+        
+        // Inject our protocol at the beginning if not already present
+        if !classes.contains(where: { $0 == RejourneyURLProtocol.self }) {
+            classes.insert(RejourneyURLProtocol.self, at: 0)
+        }
+        
+        return classes
+    }
+
+    
+    @objc public static func disable() {
+        URLProtocol.unregisterClass(RejourneyURLProtocol.self)
+    }
+    
+    public override class func canInit(with request: URLRequest) -> Bool {
+        guard let url = request.url,
+              let scheme = url.scheme,
+              ["http", "https"].contains(scheme) else {
+            return false
+        }
+        
+        // Prevent infinite loop by not intercepting our own forwarded requests
+        if URLProtocol.property(forKey: RejourneyURLProtocol._handledKey, in: request) != nil {
+            return false
+        }
+        
+        return true
+    }
+    
+    public override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+        return request
+    }
+    
+    public override func startLoading() {
+        guard let request = (request as NSURLRequest).mutableCopy() as? NSMutableURLRequest else {
+            return
+        }
+        
+        URLProtocol.setProperty(true, forKey: RejourneyURLProtocol._handledKey, in: request)
+        
+        _startMs = Int64(Date().timeIntervalSince1970 * 1000)
+        _dataTask = _session.dataTask(with: request as URLRequest)
+        _dataTask?.resume()
+    }
+    
+    public override func stopLoading() {
+        _dataTask?.cancel()
+        _dataTask = nil
+    }
+    
+    // MARK: - URLSessionDataDelegate
+    
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        client?.urlProtocol(self, didLoad: data)
+    }
+    
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        _response = response
+        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
+        completionHandler(.allow)
+    }
+    
+    // MARK: - URLSessionTaskDelegate
+    
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        _endMs = Int64(Date().timeIntervalSince1970 * 1000)
+        _error = error
+        
+        if let error = error {
+            client?.urlProtocol(self, didFailWithError: error)
+        } else {
+            client?.urlProtocolDidFinishLoading(self)
+        }
+        
+        _logRequest(task: task)
+    }
+    
+    private func _logRequest(task: URLSessionTask) {
+        guard let req = task.originalRequest, let url = req.url else { return }
+        
+        let duration = _endMs - _startMs
+        let isSuccess = _error == nil && ((_response as? HTTPURLResponse)?.statusCode ?? 0) < 400
+        let statusCode = (_response as? HTTPURLResponse)?.statusCode ?? 0
+        let method = req.httpMethod ?? "GET"
+        
+        var urlStr = url.absoluteString
+        if urlStr.count > 300 {
+            urlStr = String(urlStr.prefix(300))
+        }
+        
+        let pathStr = url.path
+        let reqSize = req.httpBody?.count ?? 0
+        let resSize = task.countOfBytesReceived
+        
+        var event: [String: Any] = [
+            "requestId": "n_\(UUID().uuidString)",
+            "method": method,
+            "url": urlStr,
+            "urlPath": pathStr.isEmpty ? "/" : pathStr,
+            "urlHost": url.host ?? "",
+            "statusCode": statusCode,
+            "duration": duration,
+            "startTimestamp": _startMs,
+            "endTimestamp": _endMs,
+            "success": isSuccess
+        ]
+        
+        if reqSize > 0 { event["requestBodySize"] = reqSize }
+        if resSize > 0 { event["responseBodySize"] = resSize }
+        
+        if let cType = req.value(forHTTPHeaderField: "Content-Type") {
+            event["requestContentType"] = cType
+        }
+        
+        if let hr = _response as? HTTPURLResponse, let cType = hr.value(forHTTPHeaderField: "Content-Type") {
+            event["responseContentType"] = cType
+        }
+        
+        if let e = _error {
+            event["errorMessage"] = e.localizedDescription
+        }
+        
+        TelemetryPipeline.shared.recordNetworkEvent(details: event)
+    }
+}