pulse-updates 1.0.0

package/ios/PulseUpdates/ErrorRecovery/PulseErrorRecovery.swift

@@ -0,0 +1,415 @@
+//  PulseErrorRecovery.swift
+//  Based on expo-updates ErrorRecovery
+
+import Foundation
+
+#if canImport(React)
+import React
+#else
+// Fallback declarations for when React module isn't directly available
+public typealias RCTFatalHandler = (NSError?) -> Void
+public typealias RCTFatalExceptionHandler = (NSException?) -> Void
+
+@_silgen_name("RCTGetFatalHandler")
+func RCTGetFatalHandler() -> RCTFatalHandler?
+
+@_silgen_name("RCTSetFatalHandler")
+func RCTSetFatalHandler(_ handler: RCTFatalHandler?)
+
+@_silgen_name("RCTGetFatalExceptionHandler")
+func RCTGetFatalExceptionHandler() -> RCTFatalExceptionHandler?
+
+@_silgen_name("RCTSetFatalExceptionHandler")
+func RCTSetFatalExceptionHandler(_ handler: RCTFatalExceptionHandler?)
+
+// Notification names
+extension NSNotification.Name {
+    static let RCTJavaScriptDidFailToLoad = NSNotification.Name("RCTJavaScriptDidFailToLoadNotification")
+    static let RCTContentDidAppear = NSNotification.Name("RCTContentDidAppearNotification")
+}
+#endif
+
+// MARK: - Error Recovery Delegate
+
+internal protocol PulseErrorRecoveryDelegate: AnyObject {
+    var remoteLoadStatus: PulseRemoteLoadStatus { get }
+    var checkOnLaunch: String { get }
+
+    func getLaunchedUpdate() -> PulseUpdateInfo?
+    func relaunch(completion: @escaping (_ error: Error?, _ success: Bool) -> Void)
+    func loadRemoteUpdate()
+
+    func markFailedLaunchForLaunchedUpdate()
+    func markSuccessfulLaunchForLaunchedUpdate()
+
+    func throwException(_ exception: NSException)
+}
+
+// MARK: - Error Recovery
+
+/**
+ * Entry point and main handler for the error recovery flow.
+ *
+ * This error recovery flow is intended to be lightweight and is *not* a full safety net whose
+ * purpose is to avoid crashes at all costs. Rather, its primary purpose is to prevent bad updates
+ * from "bricking" an app by causing crashes before there is ever a chance to download a fix.
+ *
+ * When an error is caught, the pipeline is started and executes the following tasks serially:
+ * (a) check for a new update and start downloading if there is one
+ * (b) if there is a new update, reload and launch the new update
+ * (c) if not, or if another error occurs, fall back to an older working update (if one exists)
+ * (d) crash.
+ *
+ * Importantly, (b) and (c) will be taken out of the pipeline as soon as the first root view render
+ * occurs. If any update modifies persistent state in a non-backwards-compatible way, it isn't
+ * safe to automatically roll back; we use the first root view render as a rough proxy for this.
+ */
+public final class PulseErrorRecovery: NSObject {
+
+    enum Task {
+        case waitForRemoteUpdate
+        case launchNew
+        case launchCached
+        case crash
+    }
+
+    private static let errorLogFileName = "pulse-error.log"
+    private static let remoteLoadTimeoutMs = 5000
+
+    internal weak var delegate: PulseErrorRecoveryDelegate?
+
+    private var pipeline: [Task]
+    private var isRunning: Bool
+    private var isWaitingForRemoteUpdate: Bool
+    private var rctContentHasAppeared: Bool
+    private let remoteLoadTimeout: Int
+
+    private let errorRecoveryQueue: DispatchQueue
+
+    private var encounteredErrors: [Any]
+
+    private var previousFatalErrorHandler: RCTFatalHandler?
+    private var previousFatalExceptionHandler: RCTFatalExceptionHandler?
+
+    public convenience override init() {
+        self.init(
+            errorRecoveryQueue: DispatchQueue(label: "pulse.errorRecoveryQueue"),
+            remoteLoadTimeout: PulseErrorRecovery.remoteLoadTimeoutMs
+        )
+    }
+
+    public required init(
+        errorRecoveryQueue: DispatchQueue,
+        remoteLoadTimeout: Int
+    ) {
+        self.pipeline = [
+            .waitForRemoteUpdate,
+            .launchNew,
+            .launchCached,
+            .crash
+        ]
+        self.isRunning = false
+        self.isWaitingForRemoteUpdate = false
+        self.rctContentHasAppeared = false
+        self.errorRecoveryQueue = errorRecoveryQueue
+        self.remoteLoadTimeout = remoteLoadTimeout
+        self.encounteredErrors = []
+    }
+
+    public func startMonitoring() {
+        setRCTErrorHandlers()
+    }
+
+    public func handle(error: NSError) {
+        startPipeline(withEncounteredError: error)
+        PulseErrorRecovery.writeErrorOrExceptionToLog(error)
+    }
+
+    public func handle(exception: NSException) {
+        startPipeline(withEncounteredError: exception)
+        PulseErrorRecovery.writeErrorOrExceptionToLog(exception)
+    }
+
+    public func notify(newRemoteLoadStatus newStatus: PulseRemoteLoadStatus) {
+        errorRecoveryQueue.async {
+            if !self.isWaitingForRemoteUpdate {
+                return
+            }
+
+            self.isWaitingForRemoteUpdate = false
+            if newStatus != .newUpdateLoaded {
+                self.pipeline.removeAll { $0 == .launchNew }
+            }
+            self.runNextTask()
+        }
+    }
+
+    // MARK: - Pipeline Tasks
+
+    private func startPipeline(withEncounteredError encounteredError: Any) {
+        errorRecoveryQueue.async {
+            self.encounteredErrors.append(encounteredError)
+
+            if let launchedUpdate = self.delegate?.getLaunchedUpdate(),
+               launchedUpdate.successfulLaunchCount > 0 {
+                self.pipeline.removeAll { $0 == .launchCached }
+            } else if !self.rctContentHasAppeared {
+                self.delegate?.markFailedLaunchForLaunchedUpdate()
+            }
+
+            if !self.isRunning {
+                self.isRunning = true
+                self.runNextTask()
+            }
+        }
+    }
+
+    private func runNextTask() {
+        dispatchPrecondition(condition: .onQueue(errorRecoveryQueue))
+        guard let nextTask = pipeline.first else { return }
+        pipeline.removeFirst()
+
+        switch nextTask {
+        case .waitForRemoteUpdate:
+            pulseLog("ErrorRecovery: attempting to fetch a new update, waiting")
+            waitForRemoteLoaderToFinish()
+        case .launchNew:
+            pulseLog("ErrorRecovery: launching a new update")
+            tryRelaunchFromCache()
+        case .launchCached:
+            pulseLog("ErrorRecovery: launching a cached update")
+            tryRelaunchFromCache()
+        case .crash:
+            pulseLog("ErrorRecovery: could not recover from error, crashing")
+            crash()
+        }
+    }
+
+    private func waitForRemoteLoaderToFinish() {
+        dispatchPrecondition(condition: .onQueue(errorRecoveryQueue))
+
+        if let delegate = delegate, delegate.remoteLoadStatus == .newUpdateLoaded {
+            runNextTask()
+        } else if let delegate = delegate,
+                  delegate.checkOnLaunch.uppercased() != "NEVER" || delegate.remoteLoadStatus == .loading {
+            isWaitingForRemoteUpdate = true
+            if delegate.remoteLoadStatus != .loading {
+                delegate.loadRemoteUpdate()
+            }
+
+            errorRecoveryQueue.asyncAfter(deadline: DispatchTime.now() + .milliseconds(remoteLoadTimeout)) {
+                if !self.isWaitingForRemoteUpdate {
+                    return
+                }
+
+                self.isWaitingForRemoteUpdate = false
+                self.pipeline.removeAll { $0 == .launchNew }
+                self.runNextTask()
+            }
+            return
+        } else {
+            pipeline.removeAll { $0 == .launchNew }
+            runNextTask()
+        }
+    }
+
+    private func tryRelaunchFromCache() {
+        dispatchPrecondition(condition: .onQueue(errorRecoveryQueue))
+        delegate?.relaunch { error, success in
+            self.errorRecoveryQueue.async {
+                if !success {
+                    if let error = error {
+                        self.encounteredErrors.append(error)
+                    }
+
+                    self.pipeline.removeAll { $0 == .launchNew || $0 == .launchCached }
+                    self.runNextTask()
+                } else {
+                    self.isRunning = false
+                }
+            }
+        }
+    }
+
+    private func crash() {
+        guard let initialError = encounteredErrors.first else { return }
+        encounteredErrors.removeFirst()
+
+        if let initialError = initialError as? NSError,
+           let previousFatalErrorHandler = previousFatalErrorHandler {
+            previousFatalErrorHandler(initialError)
+        } else if let initialError = initialError as? NSException,
+                  let previousFatalExceptionHandler = previousFatalExceptionHandler {
+            previousFatalExceptionHandler(initialError)
+        }
+
+        var name: NSExceptionName
+        var reason: String?
+        var userInfo: [AnyHashable: Any]
+
+        if let initialError = initialError as? NSError {
+            name = NSExceptionName(rawValue: "PulseFatalError: \(initialError.localizedDescription)")
+            reason = initialError.localizedDescription
+            userInfo = initialError.userInfo
+        } else if let initialError = initialError as? NSException {
+            name = initialError.name
+            reason = initialError.reason
+            userInfo = initialError.userInfo ?? [:]
+        } else {
+            return
+        }
+
+        userInfo["PulseUpdatesLaterEncounteredErrors"] = encounteredErrors
+        delegate?.throwException(NSException(name: name, reason: reason, userInfo: userInfo))
+    }
+
+    // MARK: - Monitoring / Lifecycle
+
+    private func registerObservers() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleJavaScriptDidFailToLoad),
+            name: NSNotification.Name.RCTJavaScriptDidFailToLoad,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleContentDidAppear),
+            name: NSNotification.Name.RCTContentDidAppear,
+            object: nil
+        )
+    }
+
+    private func unregisterObservers() {
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.RCTJavaScriptDidFailToLoad, object: nil)
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.RCTContentDidAppear, object: nil)
+    }
+
+    @objc private func handleJavaScriptDidFailToLoad() {
+        unregisterObservers()
+    }
+
+    @objc private func handleContentDidAppear() {
+        unregisterObservers()
+        delegate?.markSuccessfulLaunchForLaunchedUpdate()
+        errorRecoveryQueue.async {
+            self.rctContentHasAppeared = true
+            self.pipeline = self.pipeline.filter { task in
+                task == .waitForRemoteUpdate || task == .crash
+            }
+        }
+        // Wait 10s before unsetting error handlers
+        errorRecoveryQueue.asyncAfter(deadline: DispatchTime.now() + .seconds(10)) {
+            self.unsetRCTErrorHandlers()
+        }
+    }
+
+    private func setRCTErrorHandlers() {
+        errorRecoveryQueue.async {
+            self.rctContentHasAppeared = false
+        }
+        registerObservers()
+
+        if previousFatalErrorHandler != nil || previousFatalExceptionHandler != nil {
+            return
+        }
+
+        previousFatalErrorHandler = RCTGetFatalHandler()
+        previousFatalExceptionHandler = RCTGetFatalExceptionHandler()
+
+        RCTSetFatalHandler { [weak self] error in
+            self?.handle(error: error! as NSError)
+        }
+        RCTSetFatalExceptionHandler { [weak self] exception in
+            self?.handle(exception: exception!)
+        }
+    }
+
+    private func unsetRCTErrorHandlers() {
+        RCTSetFatalHandler(previousFatalErrorHandler)
+        RCTSetFatalExceptionHandler(previousFatalExceptionHandler)
+        previousFatalErrorHandler = nil
+        previousFatalExceptionHandler = nil
+    }
+
+    // MARK: - Error Persisting
+
+    public static func consumeErrorLog() -> String? {
+        let errorLogFile = self.errorLogFile()
+        guard let data = try? Data(contentsOf: errorLogFile) else {
+            return nil
+        }
+
+        do {
+            try FileManager.default.removeItem(at: errorLogFile)
+        } catch {
+            pulseLog("Could not delete error log: \(error.localizedDescription)")
+        }
+
+        return String(data: data, encoding: .utf8)
+    }
+
+    public static func writeErrorOrExceptionToLog(_ errorOrException: Any, dispatchQueue: DispatchQueue = DispatchQueue.global()) {
+        dispatchQueue.async {
+            var serializedError: String
+            if let errorOrException = errorOrException as? NSError {
+                serializedError = "Fatal error: \(serialize(error: errorOrException))"
+            } else if let errorOrException = errorOrException as? NSException {
+                serializedError = "Fatal exception: \(serialize(exception: errorOrException))"
+            } else {
+                return
+            }
+
+            pulseLog("ErrorRecovery: \(serializedError)")
+            let data = serializedError.data(using: .utf8)!
+            let errorLogFile = PulseErrorRecovery.errorLogFile()
+
+            if FileManager.default.fileExists(atPath: errorLogFile.path) {
+                if let fileHandle = FileHandle(forWritingAtPath: errorLogFile.path) {
+                    fileHandle.seekToEndOfFile()
+                    fileHandle.write(data)
+                    fileHandle.closeFile()
+                }
+            } else {
+                do {
+                    try data.write(to: errorLogFile, options: .atomic)
+                } catch {
+                    pulseLog("Could not write to error log: \(error.localizedDescription)")
+                }
+            }
+        }
+    }
+
+    private static func serialize(exception: NSException) -> String {
+        return String(
+            format: "Time: %f\nName: %@\nReason: %@\n\n",
+            Date().timeIntervalSince1970 * 1000,
+            exception.name.rawValue,
+            exception.reason ?? ""
+        )
+    }
+
+    private static func serialize(error: NSError) -> String {
+        var serialization = String(
+            format: "Time: %f\nDomain: %@\nCode: %li\nDescription: %@",
+            Date().timeIntervalSince1970 * 1000,
+            error.domain,
+            error.code,
+            error.localizedDescription
+        )
+
+        if let localizedFailureReason = error.localizedFailureReason {
+            serialization = serialization.appendingFormat("\nFailure Reason: %@", localizedFailureReason)
+        }
+        if let underlyingError = error.userInfo[NSUnderlyingErrorKey] as? NSError {
+            serialization = serialization.appendingFormat("\n\nUnderlying Error:\n%@", serialize(error: underlyingError))
+        }
+        serialization += "\n\n"
+        return serialization
+    }
+
+    private static func errorLogFile() -> URL {
+        let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        return documentsDirectory.appendingPathComponent("pulse").appendingPathComponent(errorLogFileName)
+    }
+}