@rejourneyco/react-native 1.0.7

package/ios/Recording/AnrSentinel.swift

@@ -0,0 +1,142 @@
+/**
+ * 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
+
+@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 {
+            os_unfair_lock_unlock(_stateLock)
+            return
+        }
+        _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)
+            self._volatile.lastResponse = Date().timeIntervalSince1970
+            self._volatile.awaitingPong = false
+            os_unfair_lock_unlock(self._stateLock)
+        }
+    }
+    
+    private func _checkPong() {
+        os_unfair_lock_lock(_stateLock)
+        let awaiting = _volatile.awaitingPong
+        let last = _volatile.lastResponse
+        os_unfair_lock_unlock(_stateLock)
+        
+        guard awaiting else { return }
+        
+        let delta = Date().timeIntervalSince1970 - last
+        if delta >= _freezeThreshold {
+            _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)
+    }
+}
+
+private struct VolatileState {
+    var running = false
+    var awaitingPong = false
+    var lastResponse: 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/EventBuffer.swift

@@ -0,0 +1,326 @@
+/**
+ * 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
+
+/// Write-first event buffer for crash-safe event persistence.
+/// Events are written to disk on append for crash safety.
+/// JSONL format (one JSON object per line).
+@objc(RJEventBuffer)
+public final class EventBuffer: NSObject {
+    
+    @objc public static let shared = EventBuffer()
+    
+    private let _lock = NSLock()
+    private var _sessionId: String?
+    private var _eventsFile: URL?
+    private var _metaFile: URL?
+    private var _fileHandle: FileHandle?
+    private var _eventCount: Int = 0
+    private var _lastEventTimestamp: Int64 = 0
+    private var _pendingRootPath: URL?
+    private var _isShutdown = false
+    
+    @objc public var eventCount: Int {
+        _lock.lock()
+        defer { _lock.unlock() }
+        return _eventCount
+    }
+    
+    @objc public var lastEventTimestamp: Int64 {
+        _lock.lock()
+        defer { _lock.unlock() }
+        return _lastEventTimestamp
+    }
+    
+    private override init() {
+        super.init()
+    }
+    
+    // MARK: - Public API
+    
+    @objc public func configure(sessionId: String) {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        _closeFileHandle()
+        
+        _sessionId = sessionId
+        _isShutdown = false
+        
+        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            DiagnosticLog.debugStorage(op: "CONFIGURE", key: sessionId, success: false, detail: "No cache directory")
+            return
+        }
+        
+        _pendingRootPath = cacheDir.appendingPathComponent("rj_pending")
+        let sessionDir = _pendingRootPath!.appendingPathComponent(sessionId)
+        
+        do {
+            try FileManager.default.createDirectory(at: sessionDir, withIntermediateDirectories: true)
+        } catch {
+            DiagnosticLog.debugStorage(op: "CONFIGURE", key: sessionId, success: false, detail: "Failed to create directory: \(error)")
+            return
+        }
+        
+        _eventsFile = sessionDir.appendingPathComponent("events.jsonl")
+        _metaFile = sessionDir.appendingPathComponent("buffer_meta.json")
+        
+        _countExistingEvents()
+        _openFileHandle()
+        
+        DiagnosticLog.debugStorage(op: "CONFIGURE", key: sessionId, success: true, detail: "Ready with \(_eventCount) existing events")
+    }
+    
+    @objc public func appendEvent(_ event: [String: Any]) -> Bool {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        guard !_isShutdown else {
+            DiagnosticLog.debugStorage(op: "APPEND", key: event["type"] as? String ?? "unknown", success: false, detail: "Buffer is shutdown")
+            return false
+        }
+        
+        return _writeEventToDisk(event)
+    }
+    
+    @objc public func flush() -> Bool {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        guard let handle = _fileHandle else { return false }
+        
+        do {
+            try handle.synchronize()
+            _saveMeta()
+            return true
+        } catch {
+            DiagnosticLog.debugStorage(op: "FLUSH", key: _sessionId ?? "", success: false, detail: "\(error)")
+            return false
+        }
+    }
+    
+    @objc public func shutdown() {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        _isShutdown = true
+        _saveMeta()
+        _closeFileHandle()
+    }
+    
+    @objc public func readPendingEvents() -> [[String: Any]] {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        guard let eventsFile = _eventsFile, FileManager.default.fileExists(atPath: eventsFile.path) else {
+            return []
+        }
+        
+        var events: [[String: Any]] = []
+        
+        do {
+            let content = try String(contentsOf: eventsFile, encoding: .utf8)
+            let lines = content.components(separatedBy: .newlines)
+            
+            for line in lines where !line.isEmpty {
+                if let data = line.data(using: .utf8),
+                   let event = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                    events.append(event)
+                }
+            }
+        } catch {
+            DiagnosticLog.debugStorage(op: "READ", key: _sessionId ?? "", success: false, detail: "\(error)")
+        }
+        
+        return events
+    }
+    
+    @objc public func clearEvents() {
+        _lock.lock()
+        defer { _lock.unlock() }
+        
+        _closeFileHandle()
+        
+        if let eventsFile = _eventsFile {
+            try? FileManager.default.removeItem(at: eventsFile)
+        }
+        if let metaFile = _metaFile {
+            try? FileManager.default.removeItem(at: metaFile)
+        }
+        
+        _eventCount = 0
+        _lastEventTimestamp = 0
+        
+        _openFileHandle()
+    }
+    
+    @objc public func clearSession(_ sessionId: String) {
+        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else { return }
+        let sessionDir = cacheDir.appendingPathComponent("rj_pending").appendingPathComponent(sessionId)
+        try? FileManager.default.removeItem(at: sessionDir)
+    }
+    
+    /// Returns list of session IDs that have pending data on disk
+    @objc public func getPendingSessions() -> [String] {
+        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else { return [] }
+        let pendingRoot = cacheDir.appendingPathComponent("rj_pending")
+        
+        guard let contents = try? FileManager.default.contentsOfDirectory(at: pendingRoot, includingPropertiesForKeys: nil) else {
+            return []
+        }
+        
+        return contents.compactMap { url in
+            let eventsFile = url.appendingPathComponent("events.jsonl")
+            if FileManager.default.fileExists(atPath: eventsFile.path) {
+                return url.lastPathComponent
+            }
+            return nil
+        }
+    }
+    
+    /// Read events from a specific session's pending data
+    @objc public func readEventsForSession(_ sessionId: String) -> [[String: Any]] {
+        guard let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else { return [] }
+        let eventsFile = cacheDir.appendingPathComponent("rj_pending").appendingPathComponent(sessionId).appendingPathComponent("events.jsonl")
+        
+        guard FileManager.default.fileExists(atPath: eventsFile.path) else { return [] }
+        
+        var events: [[String: Any]] = []
+        
+        do {
+            let content = try String(contentsOf: eventsFile, encoding: .utf8)
+            let lines = content.components(separatedBy: .newlines)
+            
+            for line in lines where !line.isEmpty {
+                if let data = line.data(using: .utf8),
+                   let event = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                    events.append(event)
+                }
+            }
+        } catch {
+            DiagnosticLog.debugStorage(op: "READ_SESSION", key: sessionId, success: false, detail: "\(error)")
+        }
+        
+        return events
+    }
+    
+    // MARK: - Private Methods
+    
+    private func _countExistingEvents() {
+        guard let eventsFile = _eventsFile, FileManager.default.fileExists(atPath: eventsFile.path) else {
+            _eventCount = 0
+            _lastEventTimestamp = 0
+            return
+        }
+        
+        do {
+            let content = try String(contentsOf: eventsFile, encoding: .utf8)
+            let lines = content.components(separatedBy: .newlines)
+            
+            var count = 0
+            var lastTs: Int64 = 0
+            
+            for line in lines where !line.isEmpty {
+                if let data = line.data(using: .utf8),
+                   let event = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                    count += 1
+                    if let ts = event["timestamp"] as? Int64, ts > lastTs {
+                        lastTs = ts
+                    } else if let ts = event["timestamp"] as? Int, Int64(ts) > lastTs {
+                        lastTs = Int64(ts)
+                    }
+                }
+            }
+            
+            _eventCount = count
+            _lastEventTimestamp = lastTs
+            
+            // Load meta if exists
+            if let metaFile = _metaFile, FileManager.default.fileExists(atPath: metaFile.path) {
+                if let metaData = try? Data(contentsOf: metaFile),
+                   let meta = try? JSONSerialization.jsonObject(with: metaData) as? [String: Any] {
+                    // Could track uploadedEventCount here
+                }
+            }
+        } catch {
+            _eventCount = 0
+            _lastEventTimestamp = 0
+        }
+    }
+    
+    private func _openFileHandle() {
+        guard let eventsFile = _eventsFile else { return }
+        
+        if !FileManager.default.fileExists(atPath: eventsFile.path) {
+            FileManager.default.createFile(atPath: eventsFile.path, contents: nil)
+        }
+        
+        do {
+            _fileHandle = try FileHandle(forWritingTo: eventsFile)
+            try _fileHandle?.seekToEnd()
+        } catch {
+            DiagnosticLog.debugStorage(op: "OPEN_HANDLE", key: _sessionId ?? "", success: false, detail: "\(error)")
+        }
+    }
+    
+    private func _closeFileHandle() {
+        try? _fileHandle?.close()
+        _fileHandle = nil
+    }
+    
+    private func _writeEventToDisk(_ event: [String: Any]) -> Bool {
+        guard let handle = _fileHandle else {
+            _openFileHandle()
+            guard _fileHandle != nil else { return false }
+            return _writeEventToDisk(event)
+        }
+        
+        do {
+            let data = try JSONSerialization.data(withJSONObject: event)
+            var line = data
+            line.append(0x0A) // newline
+            
+            try handle.write(contentsOf: line)
+            
+            _eventCount += 1
+            if let ts = event["timestamp"] as? Int64 {
+                _lastEventTimestamp = ts
+            } else if let ts = event["timestamp"] as? Int {
+                _lastEventTimestamp = Int64(ts)
+            }
+            
+            return true
+        } catch {
+            DiagnosticLog.debugStorage(op: "WRITE", key: event["type"] as? String ?? "unknown", success: false, detail: "\(error)")
+            return false
+        }
+    }
+    
+    private func _saveMeta() {
+        guard let metaFile = _metaFile else { return }
+        
+        let meta: [String: Any] = [
+            "eventCount": _eventCount,
+            "lastEventTimestamp": _lastEventTimestamp,
+            "savedAt": Date().timeIntervalSince1970 * 1000
+        ]
+        
+        if let data = try? JSONSerialization.data(withJSONObject: meta) {
+            try? data.write(to: metaFile)
+        }
+    }
+}