@rejourneyco/react-native 1.0.7 → 1.0.9

package/ios/Recording/StabilityMonitor.swift

@@ -38,7 +38,7 @@ private func _rjSignalHandler(_ signum: Int32) {
     case SIGTRAP: name = "SIGTRAP"
     default:      name = "SIG\(signum)"
     }
-    
+
     let incident = IncidentRecord(
         sessionId: StabilityMonitor.shared.currentSessionId ?? "unknown",
         timestampMs: UInt64(Date().timeIntervalSince1970 * 1000),
@@ -52,60 +52,63 @@ private func _rjSignalHandler(_ signum: Int32) {
             "priority": String(format: "%.2f", Thread.current.threadPriority)
         ]
     )
-    
+
     ReplayOrchestrator.shared.incrementFaultTally()
     StabilityMonitor.shared.persistIncidentSync(incident)
-    
+
+    // Flush visual frames to disk for crash safety
+    VisualCapture.shared.flushToDisk()
+
     signal(signum, SIG_DFL)
     raise(signum)
 }
 
 @objc(StabilityMonitor)
 public final class StabilityMonitor: NSObject {
-    
+
     @objc public static let shared = StabilityMonitor()
     @objc public var isMonitoring = false
     @objc public var currentSessionId: String?
-    
+
     private let _incidentStore: URL
     private let _workerQueue = DispatchQueue(label: "co.rejourney.stability", qos: .utility)
-    
+
     private static var _chainedExceptionHandler: NSUncaughtExceptionHandler?
     private static var _chainedSignalHandlers: [Int32: sig_t] = [:]
     private static let _trackedSignals: [Int32] = [SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP]
-    
+
     private override init() {
         let cache = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
         _incidentStore = cache.appendingPathComponent("rj_incidents.json")
         super.init()
     }
-    
+
     @objc public func activate() {
         guard !isMonitoring else { return }
         isMonitoring = true
-        
+
         StabilityMonitor._chainedExceptionHandler = NSGetUncaughtExceptionHandler()
         NSSetUncaughtExceptionHandler { ex in
             StabilityMonitor.shared._captureException(ex)
             StabilityMonitor._chainedExceptionHandler?(ex)
         }
-        
+
         for sig in StabilityMonitor._trackedSignals {
             StabilityMonitor._chainedSignalHandlers[sig] = signal(sig, _rjSignalHandler)
         }
-        
+
         _workerQueue.async { [weak self] in
             self?._uploadStoredIncidents()
         }
     }
-    
+
     @objc public func deactivate() {
         guard isMonitoring else { return }
         isMonitoring = false
-        
+
         NSSetUncaughtExceptionHandler(nil)
         StabilityMonitor._chainedExceptionHandler = nil
-        
+
         for sig in StabilityMonitor._trackedSignals {
             if let prev = StabilityMonitor._chainedSignalHandlers[sig] {
                 signal(sig, prev)
@@ -115,13 +118,13 @@ public final class StabilityMonitor: NSObject {
         }
         StabilityMonitor._chainedSignalHandlers.removeAll()
     }
-    
+
     @objc public func transmitStoredReport() {
         _workerQueue.async { [weak self] in
             self?._uploadStoredIncidents()
         }
     }
-    
+
     private func _captureException(_ exception: NSException) {
         let incident = IncidentRecord(
             sessionId: currentSessionId ?? "unknown",
@@ -132,25 +135,29 @@ public final class StabilityMonitor: NSObject {
             frames: _formatFrames(exception.callStackSymbols),
             context: _captureContext()
         )
-        
+
         ReplayOrchestrator.shared.incrementFaultTally()
         _persistIncident(incident)
+
+        // Flush visual frames to disk for crash safety
+        VisualCapture.shared.flushToDisk()
+
         Thread.sleep(forTimeInterval: 0.15)
     }
-    
+
     func persistIncidentSync(_ incident: IncidentRecord) {
         do {
             let data = try JSONEncoder().encode(incident)
             try data.write(to: _incidentStore, options: .atomic)
         } catch {
-            print("[Rejourney] Incident persist failed: \(error)")
+            DiagnosticLog.fault("[StabilityMonitor] Incident persist failed: \(error)")
         }
     }
-    
+
     private func _formatFrames(_ raw: [String]) -> [String] {
         raw.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
     }
-    
+
     private func _captureContext() -> [String: String] {
         [
             "threadName": Thread.current.name ?? "unnamed",
@@ -158,48 +165,49 @@ public final class StabilityMonitor: NSObject {
             "priority": String(format: "%.2f", Thread.current.threadPriority)
         ]
     }
-    
+
     private func _persistIncident(_ incident: IncidentRecord) {
         do {
             let data = try JSONEncoder().encode(incident)
             try data.write(to: _incidentStore, options: .atomic)
         } catch {
-            print("[Rejourney] Incident persist failed: \(error)")
+            DiagnosticLog.fault("[StabilityMonitor] Incident persist failed: \(error)")
         }
     }
-    
+
     private func _uploadStoredIncidents() {
         guard FileManager.default.fileExists(atPath: _incidentStore.path),
               let data = try? Data(contentsOf: _incidentStore),
               let incident = try? JSONDecoder().decode(IncidentRecord.self, from: data) else { return }
-        
+
         _transmitIncident(incident) { [weak self] ok in
-            if ok { try? FileManager.default.removeItem(at: self!._incidentStore) }
+            guard ok, let self else { return }
+            try? FileManager.default.removeItem(at: self._incidentStore)
         }
     }
-    
+
     private func _transmitIncident(_ incident: IncidentRecord, completion: @escaping (Bool) -> Void) {
         let base = SegmentDispatcher.shared.endpoint
         guard let url = URL(string: "\(base)/api/ingest/fault") else {
             completion(false)
             return
         }
-        
+
         var req = URLRequest(url: url)
         req.httpMethod = "POST"
         req.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        
+
         if let key = SegmentDispatcher.shared.apiToken {
             req.setValue(key, forHTTPHeaderField: "x-rejourney-key")
         }
-        
+
         do {
             req.httpBody = try JSONEncoder().encode(incident)
         } catch {
             completion(false)
             return
         }
-        
+
         URLSession.shared.dataTask(with: req) { _, resp, _ in
             let code = (resp as? HTTPURLResponse)?.statusCode ?? 0
             completion(code >= 200 && code < 300)
@@ -210,13 +218,13 @@ public final class StabilityMonitor: NSObject {
 @objc(FaultTracker)
 public final class FaultTracker: NSObject {
     @objc public static let shared = FaultTracker()
-    
+
     private override init() { super.init() }
-    
+
     @objc public func activate() {
         StabilityMonitor.shared.activate()
     }
-    
+
     @objc public func deactivate() {
         StabilityMonitor.shared.deactivate()
     }

package/ios/Recording/TelemetryPipeline.swift

@@ -141,6 +141,10 @@ public final class TelemetryPipeline: NSObject {
         }
     }
     
+    @objc public func getQueueDepth() -> Int {
+        _eventRing.count + _frameQueue.count
+    }
+    
     @objc private func _appSuspending() {
         guard !_draining else { return }
         _draining = true
@@ -150,16 +154,18 @@ public final class TelemetryPipeline: NSObject {
             self?._endBackgroundTask()
         }
         
-        // Flush visual frames to disk immediately
+        // Flush visual frames to disk for crash safety
         VisualCapture.shared.flushToDisk()
+        // Submit any buffered frames to the upload pipeline (even if below batch threshold)
+        VisualCapture.shared.flushBufferToNetwork()
         
         // Try to upload pending data with remaining background time
         _serialWorker.async { [weak self] in
             self?._shipPendingEvents()
             self?._shipPendingFrames()
             
-            // Allow a short delay for network operations to complete
-            Thread.sleep(forTimeInterval: 0.5)
+            // Allow time for network operations to complete
+            Thread.sleep(forTimeInterval: 2.0)
             
             DispatchQueue.main.async {
                 self?._endBackgroundTask()
@@ -300,6 +306,15 @@ public final class TelemetryPipeline: NSObject {
         _enqueue(["type": "custom", "timestamp": _ts(), "name": name, "payload": payload])
     }
     
+    @objc public func recordConsoleLogEvent(level: String, message: String) {
+        _enqueue([
+            "type": "log",
+            "timestamp": _ts(),
+            "level": level,
+            "message": message
+        ])
+    }
+    
     @objc public func recordJSErrorEvent(name: String, message: String, stack: String?) {
         var event: [String: Any] = [
             "type": "error",
@@ -311,6 +326,10 @@ public final class TelemetryPipeline: NSObject {
             event["stack"] = stack
         }
         _enqueue(event)
+        // Prioritize JS error delivery to reduce loss on fatal terminations.
+        _serialWorker.async { [weak self] in
+            self?._shipPendingEvents()
+        }
     }
     
     @objc public func recordAnrEvent(durationMs: Int, stack: String?) {
@@ -324,6 +343,10 @@ public final class TelemetryPipeline: NSObject {
             event["stack"] = stack
         }
         _enqueue(event)
+        // Prioritize ANR delivery while the process is still alive.
+        _serialWorker.async { [weak self] in
+            self?._shipPendingEvents()
+        }
     }
     
     @objc public func recordUserAssociation(_ userId: String) {
@@ -485,6 +508,12 @@ private final class EventRingBuffer {
         _storage.reserveCapacity(capacity)
     }
     
+    var count: Int {
+        _lock.lock()
+        defer { _lock.unlock() }
+        return _storage.count
+    }
+    
     func push(_ entry: EventEntry) {
         _lock.lock()
         defer { _lock.unlock() }
@@ -525,6 +554,12 @@ private final class FrameBundleQueue {
         _maxPending = maxPending
     }
     
+    var count: Int {
+        _lock.lock()
+        defer { _lock.unlock() }
+        return _queue.count
+    }
+    
     func enqueue(_ bundle: PendingFrameBundle) {
         _lock.lock()
         defer { _lock.unlock() }

package/ios/Recording/ViewHierarchyScanner.swift

@@ -136,6 +136,7 @@ import UIKit
     private func _typeName(_ v: UIView) -> String { String(describing: type(of: v)) }
     
     private func _isSensitive(_ v: UIView) -> Bool {
+        if v.accessibilityHint == "rejourney_occlude" { return true }
         if let tf = v as? UITextField, tf.isSecureTextEntry { return true }
         return false
     }

package/ios/Recording/VisualCapture.swift

@@ -25,8 +25,10 @@ public final class VisualCapture: NSObject {
     
     @objc public static let shared = VisualCapture()
     
-    @objc public var snapshotInterval: Double = 0.5
+    @objc public var snapshotInterval: Double = 1.0
     @objc public var quality: CGFloat = 0.5
+    /// Capture scale (e.g. 1.25 = capture at 80% linear size). Matches Android for parity; reduces JPEG size.
+    @objc public var captureScale: CGFloat = 1.25
     
     @objc public var isCapturing: Bool {
         _stateMachine.currentState == .capturing
@@ -58,6 +60,7 @@ public final class VisualCapture: NSObject {
     
     // Industry standard batch size (20 frames per batch, not 5)
     private let _batchSize = 20
+
     
     private override init() {
         _redactionMask = RedactionMask()
@@ -135,6 +138,13 @@ public final class VisualCapture: NSObject {
         _flushBufferToDisk()
     }
     
+    /// Submit any buffered frames to the upload pipeline immediately
+    /// (regardless of batch size threshold). Packages synchronously to
+    /// avoid race conditions during backgrounding.
+    @objc public func flushBufferToNetwork() {
+        _flushBuffer()
+    }
+    
     @objc public func activateDeferredMode() {
         _deferredUntilCommit = true
     }
@@ -152,9 +162,15 @@ public final class VisualCapture: NSObject {
         _redactionMask.remove(view)
     }
     
-    @objc public func configure(snapshotInterval: Double, jpegQuality: Double) {
+    @objc public func invalidateMaskCache() {
+        _redactionMask.invalidateCache()
+    }
+
+    
+    @objc public func configure(snapshotInterval: Double, jpegQuality: Double, captureScale: CGFloat = 1.25) {
         self.snapshotInterval = snapshotInterval
         self.quality = CGFloat(jpegQuality)
+        self.captureScale = max(1.0, captureScale)
         if _stateMachine.currentState == .capturing {
             _stopCaptureTimer()
             _startCaptureTimer()
@@ -163,15 +179,12 @@ public final class VisualCapture: NSObject {
     
     @objc public func snapshotNow() {
         DispatchQueue.main.async { [weak self] in
-            self?._captureFrame()
+            self?._captureFrame(forced: true)
         }
     }
     
     private func _startCaptureTimer() {
         _stopCaptureTimer()
-        // Industry standard: Use default run loop mode (NOT .common)
-        // This lets the timer pause during scrolling/tracking which prevents stutter
-        // The capture will resume when scrolling stops
         _captureTimer = Timer.scheduledTimer(withTimeInterval: snapshotInterval, repeats: true) { [weak self] _ in
             self?._captureFrame()
         }
@@ -182,7 +195,7 @@ public final class VisualCapture: NSObject {
         _captureTimer = nil
     }
     
-    private func _captureFrame() {
+    private func _captureFrame(forced: Bool = false) {
         guard _stateMachine.currentState == .capturing else { return }
         
         // Skip capture if app is not in foreground (prevents "not in visible window" warnings)
@@ -190,10 +203,31 @@ public final class VisualCapture: NSObject {
         
         let frameStart = CFAbsoluteTimeGetCurrent()
         
+        // 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)")
+        }
+        
+        // Map stutter prevention: when a map view is visible and its camera
+        // is still moving (user gesture or animation), skip drawHierarchy
+        // entirely — this is the call that causes GPU readback stutter on
+        // Metal/OpenGL-backed map tiles.  We resume capture at 1 FPS once
+        // the map SDK reports idle.
+        if !forced && SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle {
+            DiagnosticLog.trace("[VisualCapture] SKIPPING frame (map moving)")
+            return
+        }
+        
         // Capture the pixel buffer on the main thread (required by UIKit),
         // then move JPEG compression to the encode queue to reduce main-thread blocking.
         autoreleasepool {
-            guard let window = UIApplication.shared.windows.first(where: \.isKeyWindow) else { return }
+            guard let window = UIApplication.shared.connectedScenes
+                .compactMap({ $0 as? UIWindowScene })
+                .flatMap({ $0.windows })
+                .first(where: { $0.isKeyWindow }) else { return }
             let bounds = window.bounds
             // Guard against NaN and invalid bounds that cause CoreGraphics errors
             guard bounds.width > 0, bounds.height > 0 else { return }
@@ -201,15 +235,18 @@ public final class VisualCapture: NSObject {
             guard bounds.width.isFinite && bounds.height.isFinite else { return }
             
             let redactRects = _redactionMask.computeRects()
+            let scale = max(1.0, captureScale)
+            let scaledSize = CGSize(width: bounds.width / scale, height: bounds.height / scale)
+            guard scaledSize.width >= 1, scaledSize.height >= 1 else {
+                return
+            }
             
-            // Use UIGraphicsBeginImageContextWithOptions for lower overhead (industry pattern)
-            let screenScale: CGFloat = 1.25 // Lower scale reduces encoding time significantly
-            UIGraphicsBeginImageContextWithOptions(bounds.size, false, screenScale)
+            UIGraphicsBeginImageContextWithOptions(scaledSize, false, 1.0)
             guard let context = UIGraphicsGetCurrentContext() else {
                 UIGraphicsEndImageContext()
                 return
             }
-            
+            context.scaleBy(x: 1.0 / scale, y: 1.0 / scale)
             window.drawHierarchy(in: bounds, afterScreenUpdates: false)
             
             // Apply redactions inline while context is open
@@ -263,6 +300,8 @@ public final class VisualCapture: NSObject {
         }
     }
     
+
+    
     /// Enforce memory caps to prevent unbounded growth (industry standard backpressure)
     private func _enforceScreenshotCaps() {
         // Called with lock held
@@ -340,10 +379,20 @@ public final class VisualCapture: NSObject {
     
     /// Load and upload any pending frames from disk for a session
     @objc public func uploadPendingFrames(sessionId: String) {
-        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else { return }
+        uploadPendingFrames(sessionId: sessionId, completion: nil)
+    }
+    
+    public func uploadPendingFrames(sessionId: String, completion: ((Bool) -> Void)? = nil) {
+        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            completion?(false)
+            return
+        }
         let framesPath = cacheDir.appendingPathComponent("rj_pending").appendingPathComponent(sessionId).appendingPathComponent("frames")
         
-        guard let frameFiles = try? FileManager.default.contentsOfDirectory(at: framesPath, includingPropertiesForKeys: nil) else { return }
+        guard let frameFiles = try? FileManager.default.contentsOfDirectory(at: framesPath, includingPropertiesForKeys: nil) else {
+            completion?(true)
+            return
+        }
         
         var frames: [(Data, UInt64)] = []
         for file in frameFiles.sorted(by: { $0.lastPathComponent < $1.lastPathComponent }) {
@@ -358,18 +407,24 @@ public final class VisualCapture: NSObject {
             frames.append((data, ts))
         }
         
-        guard !frames.isEmpty, let bundle = _packageFrameBundle(images: frames, sessionEpoch: frames.first?.1 ?? 0) else { return }
+        guard !frames.isEmpty, let bundle = _packageFrameBundle(images: frames, sessionEpoch: frames.first?.1 ?? 0) else {
+            completion?(frames.isEmpty)
+            return
+        }
         
         let endTs = frames.last?.1 ?? 0
-        let fname = "\(sessionId)-\(endTs).tar.gz"
         
-        TelemetryPipeline.shared.submitFrameBundle(
+        SegmentDispatcher.shared.transmitFrameBundle(
             payload: bundle,
-            filename: fname,
             startMs: frames.first?.1 ?? 0,
             endMs: endTs,
             frameCount: frames.count
-        )
+        ) { ok in
+            if ok {
+                try? FileManager.default.removeItem(at: framesPath)
+            }
+            completion?(ok)
+        }
     }
     
     /// Clear pending frames for a session after successful upload
@@ -478,7 +533,28 @@ private final class RedactionMask {
     // sensitive views (text inputs, cameras) don't appear/disappear at 3fps.
     private var _cachedAutoRects: [CGRect] = []
     private var _lastScanTime: CFAbsoluteTime = 0
-    private let _scanCacheDurationSec: CFAbsoluteTime = 1.0
+    private let _scanCacheDurationSec: CFAbsoluteTime = 0.5
+    
+    private var _observers: [Any] = []
+    
+    init() {
+        _observers.append(NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: nil) { [weak self] _ in self?.invalidateCache() })
+        _observers.append(NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: nil) { [weak self] _ in self?.invalidateCache() })
+        _observers.append(NotificationCenter.default.addObserver(forName: UITextField.textDidChangeNotification, object: nil, queue: nil) { [weak self] _ in self?.invalidateCache() })
+        _observers.append(NotificationCenter.default.addObserver(forName: UITextView.textDidChangeNotification, object: nil, queue: nil) { [weak self] _ in self?.invalidateCache() })
+    }
+    
+    deinit {
+        for observer in _observers {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+    
+    func invalidateCache() {
+        _lock.lock()
+        _lastScanTime = 0
+        _lock.unlock()
+    }
     
     // View class names that should always be masked (privacy sensitive)
     private let _sensitiveClassNames: Set<String> = [
@@ -594,14 +670,10 @@ private final class RedactionMask {
     }
     
     private func _keyWindow() -> UIWindow? {
-        if #available(iOS 15.0, *) {
-            return UIApplication.shared.connectedScenes
-                .compactMap { $0 as? UIWindowScene }
-                .flatMap { $0.windows }
-                .first { $0.isKeyWindow }
-        } else {
-            return UIApplication.shared.windows.first { $0.isKeyWindow }
-        }
+        return UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.isKeyWindow }
     }
     
     private func _scanForSensitiveViews(in view: UIView, rects: inout [CGRect], depth: Int = 0) {
@@ -638,6 +710,10 @@ private final class RedactionMask {
     }
     
     private func _shouldMask(_ view: UIView) -> Bool {
+        if view.accessibilityHint == "rejourney_occlude" {
+            return true
+        }
+        
         // 1. Mask ALL text input fields by default (privacy first)
         // This includes password fields, instructions, notes, etc.
         if view is UITextField {

package/ios/Rejourney.mm

@@ -70,11 +70,11 @@ RCT_EXPORT_MODULE()
 
 #pragma mark - Tap Event Emission (no-ops, dead tap detection is native-side)
 
-RCT_EXPORT_METHOD(addListener:(NSString *)eventName) {
+RCT_EXPORT_METHOD(addListener : (NSString *)eventName) {
   // No-op: dead tap detection is handled natively in TelemetryPipeline
 }
 
-RCT_EXPORT_METHOD(removeListeners:(double)count) {
+RCT_EXPORT_METHOD(removeListeners : (double)count) {
   // No-op: dead tap detection is handled natively in TelemetryPipeline
 }
 
@@ -195,6 +195,26 @@ RCT_EXPORT_METHOD(getUserIdentity : (RCTPromiseResolveBlock)
   [impl getUserIdentity:resolve reject:reject];
 }
 
+RCT_EXPORT_METHOD(setAnonymousId : (NSString *)anonymousId resolve : (
+    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+  RejourneyImpl *impl = [self ensureImpl];
+  if (!impl) {
+    resolve(@{@"success" : @NO});
+    return;
+  }
+  [impl setAnonymousId:anonymousId resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getAnonymousId : (RCTPromiseResolveBlock)
+                      resolve reject : (RCTPromiseRejectBlock)reject) {
+  RejourneyImpl *impl = [self ensureImpl];
+  if (!impl) {
+    resolve([NSNull null]);
+    return;
+  }
+  [impl getAnonymousId:resolve reject:reject];
+}
+
 #pragma mark - Events and Tracking
 
 RCT_EXPORT_METHOD(logEvent : (NSString *)eventType details : (NSDictionary *)
@@ -312,12 +332,11 @@ RCT_EXPORT_METHOD(setDebugMode : (BOOL)enabled resolve : (
   [impl setDebugMode:enabled resolve:resolve reject:reject];
 }
 
-RCT_EXPORT_METHOD(setRemoteConfig : (BOOL)rejourneyEnabled 
-                  recordingEnabled : (BOOL)recordingEnabled 
-                  sampleRate : (double)sampleRate 
-                  maxRecordingMinutes : (double)maxRecordingMinutes 
-                  resolve : (RCTPromiseResolveBlock)resolve 
-                  reject : (RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(setRemoteConfig : (BOOL)rejourneyEnabled recordingEnabled : (
+    BOOL)recordingEnabled sampleRate : (double)
+                      sampleRate maxRecordingMinutes : (double)
+                          maxRecordingMinutes resolve : (RCTPromiseResolveBlock)
+                              resolve reject : (RCTPromiseRejectBlock)reject) {
   RejourneyImpl *impl = [self ensureImpl];
   if (!impl) {
     resolve(@{@"success" : @NO});

package/ios/Utility/ImageBlur.swift

@@ -18,7 +18,6 @@ import UIKit
 import Accelerate
 
 extension UIImage {
-    /// Apply Gaussian blur to the image
     func gaussianBlur(radius: CGFloat) -> UIImage? {
         guard let cgImage = cgImage else { return nil }