@logbrew/react-native 0.1.11 → 0.1.13

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeHangWatchdog.swift

@@ -0,0 +1,386 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+final class OrderedHangDiagnosticDelivery: HangDiagnosticDelivering, @unchecked Sendable {
+    private let queue = DispatchQueue(label: "co.logbrew.native-hang-diagnostics")
+    private let handler: @Sendable (NativeHangDiagnostic) -> Void
+
+    init(_ handler: @escaping @Sendable (NativeHangDiagnostic) -> Void) {
+        self.handler = handler
+    }
+
+    func enqueue(_ diagnostic: NativeHangDiagnostic) {
+        queue.async { [handler] in
+            handler(diagnostic)
+        }
+    }
+}
+
+final class HangWatchdogController: @unchecked Sendable {
+    private let threshold: TimeInterval
+    private let identity: NativeArtifactIdentity
+    private let store: any HangIncidentStoring
+    private let stackCapture: any MainThreadStackCapturing
+    private let safetyPolicy: any HangSafetyChecking
+    private let clock: any HangWatchdogClock
+    private let mainPinger: any MainThreadPinging
+    private let diagnosticDelivery: any HangDiagnosticDelivering
+    private let lock = NSLock()
+
+    private var active = false
+    private var running = false
+    private var heartbeat: HangHeartbeatState = .idle
+
+    init(
+        threshold: TimeInterval,
+        identity: NativeArtifactIdentity,
+        store: any HangIncidentStoring,
+        stackCapture: any MainThreadStackCapturing,
+        safetyPolicy: any HangSafetyChecking,
+        clock: any HangWatchdogClock,
+        mainPinger: any MainThreadPinging,
+        diagnosticDelivery: any HangDiagnosticDelivering,
+    ) {
+        self.threshold = threshold
+        self.identity = identity
+        self.store = store
+        self.stackCapture = stackCapture
+        self.safetyPolicy = safetyPolicy
+        self.clock = clock
+        self.mainPinger = mainPinger
+        self.diagnosticDelivery = diagnosticDelivery
+    }
+
+    func start(active: Bool) {
+        lock.lock()
+        guard !running else {
+            lock.unlock()
+            return
+        }
+        running = true
+        self.active = active
+        heartbeat = .idle
+        let shouldPing = active
+        lock.unlock()
+        if shouldPing {
+            beginHeartbeat()
+        }
+    }
+
+    func setActive(_ active: Bool) {
+        if !active {
+            lock.lock()
+            guard running else {
+                lock.unlock()
+                return
+            }
+            self.active = false
+            let captured = heartbeat.captured
+            heartbeat = .idle
+            lock.unlock()
+            markRecovered(captured)
+            return
+        }
+
+        lock.lock()
+        guard running else {
+            lock.unlock()
+            return
+        }
+        self.active = active
+        let shouldPing = heartbeat == .idle
+        lock.unlock()
+        if shouldPing {
+            beginHeartbeat()
+        }
+    }
+
+    func poll() {
+        guard let sentAt = waitingHeartbeatForPoll() else {
+            return
+        }
+        let elapsed = clock.monotonicNow() - sentAt
+        guard elapsed >= threshold else {
+            return
+        }
+        if let suppression = suppressionCode(elapsed: elapsed) {
+            suppress(suppression, sentAt: sentAt)
+            return
+        }
+        guard let durationMs = NativeHangDuration.milliseconds(
+            from: sentAt,
+            through: sentAt + elapsed,
+        ) else {
+            suppress(.storageFailed, sentAt: sentAt)
+            return
+        }
+
+        let frames = stackCapture.capture()
+        guard !frames.isEmpty else {
+            suppress(.stackUnavailable, sentAt: sentAt)
+            return
+        }
+        captureIncident(
+            frames: frames,
+            sentAt: sentAt,
+            durationMs: durationMs,
+        )
+    }
+
+    func stop() {
+        lock.lock()
+        let captured = heartbeat.captured
+        running = false
+        active = false
+        heartbeat = .idle
+        lock.unlock()
+        markRecovered(captured)
+    }
+
+    private func suppressionCode(elapsed: TimeInterval) -> NativeHangDiagnosticCode? {
+        if elapsed > threshold * 1.5 {
+            return .skippedSchedulerStall
+        }
+        if safetyPolicy.isDebuggerAttached() {
+            return .skippedDebugger
+        }
+        if safetyPolicy.isThermallyRestricted() {
+            return .skippedThermal
+        }
+        do {
+            guard try store.read() == nil else {
+                return .pendingRetained
+            }
+        } catch {
+            return .storageFailed
+        }
+        return nil
+    }
+
+    private func waitingHeartbeatForPoll() -> TimeInterval? {
+        lock.lock()
+        guard running, active else {
+            lock.unlock()
+            return nil
+        }
+        guard case let .waiting(sentAt) = heartbeat else {
+            let shouldBegin = heartbeat == .idle
+            lock.unlock()
+            if shouldBegin {
+                beginHeartbeat()
+            }
+            return nil
+        }
+        lock.unlock()
+        return sentAt
+    }
+
+    private func captureIncident(
+        frames: [NativeStackFrame],
+        sentAt: TimeInterval,
+        durationMs: Double,
+    ) {
+        let eventID = UUID().uuidString.lowercased()
+        let incident = NativeHangIncident(
+            eventID: eventID,
+            timestamp: clock.timestamp(),
+            state: .ongoing,
+            identity: identity,
+            nativeStackFrames: frames,
+            durationMs: durationMs,
+        )
+        do {
+            lock.lock()
+            guard running, active, heartbeat == .waiting(sentAt: sentAt) else {
+                lock.unlock()
+                return
+            }
+            try store.write(incident)
+            heartbeat = .captured(eventID: eventID, sentAt: sentAt)
+            diagnosticDelivery.enqueue(NativeHangDiagnostic(.captured))
+            lock.unlock()
+        } catch {
+            let persisted = try? store.read()
+            heartbeat = persisted == incident
+                ? .captured(eventID: eventID, sentAt: sentAt)
+                : .suppressed
+            diagnosticDelivery.enqueue(NativeHangDiagnostic(.storageFailed))
+            lock.unlock()
+        }
+    }
+
+    private func beginHeartbeat() {
+        let sentAt = clock.monotonicNow()
+        lock.lock()
+        guard running, active, heartbeat == .idle else {
+            lock.unlock()
+            return
+        }
+        heartbeat = .waiting(sentAt: sentAt)
+        lock.unlock()
+        mainPinger.ping { [weak self] in
+            self?.mainDidRespond()
+        }
+    }
+
+    private func mainDidRespond() {
+        lock.lock()
+        let captured = heartbeat.captured
+        heartbeat = .idle
+        lock.unlock()
+        markRecovered(captured)
+    }
+
+    private func markRecovered(
+        _ captured: (eventID: String, sentAt: TimeInterval)?,
+    ) {
+        guard let captured else {
+            return
+        }
+        guard let durationMs = NativeHangDuration.milliseconds(
+            from: captured.sentAt,
+            through: clock.monotonicNow(),
+        ) else {
+            emit(.storageFailed)
+            return
+        }
+        do {
+            try store.markRecovered(
+                eventID: captured.eventID,
+                durationMs: durationMs,
+            )
+            emit(.recovered)
+        } catch {
+            emit(.storageFailed)
+        }
+    }
+
+    private func suppress(_ code: NativeHangDiagnosticCode, sentAt: TimeInterval) {
+        lock.lock()
+        guard heartbeat == .waiting(sentAt: sentAt) else {
+            lock.unlock()
+            return
+        }
+        heartbeat = .suppressed
+        diagnosticDelivery.enqueue(NativeHangDiagnostic(code))
+        lock.unlock()
+    }
+
+    private func emit(_ code: NativeHangDiagnosticCode) {
+        diagnosticDelivery.enqueue(NativeHangDiagnostic(code))
+    }
+}
+
+extension HangWatchdogController: HangWatchdogControlling {}
+
+private enum HangHeartbeatState: Equatable {
+    case idle
+    case waiting(sentAt: TimeInterval)
+    case captured(eventID: String, sentAt: TimeInterval)
+    case suppressed
+
+    var captured: (eventID: String, sentAt: TimeInterval)? {
+        guard case let .captured(eventID, sentAt) = self else {
+            return nil
+        }
+        return (eventID, sentAt)
+    }
+}
+
+private enum HangTimerLifecycleState {
+    case prepared
+    case active
+    case stopped
+}
+
+final class NativeHangWatchdogRuntime: @unchecked Sendable {
+    private let controller: any HangWatchdogControlling
+    private let timer: any HangTimerControlling
+    private let lifecycle: any HangLifecycleObserving
+    private let lock = NSLock()
+    private var timerState: HangTimerLifecycleState = .prepared
+
+    init(
+        configuration: NativeHangWatchdogConfiguration,
+        identity: NativeArtifactIdentity,
+        store: any HangIncidentStoring,
+    ) throws {
+        guard Thread.isMainThread else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        let stackCapture = try NativeMainThreadStackCapture()
+        let lifecycle = try NativeHangLifecycleObserver()
+        let diagnosticDelivery = OrderedHangDiagnosticDelivery(
+            configuration.diagnosticsHandler ?? { _ in },
+        )
+        let controller = HangWatchdogController(
+            threshold: configuration.threshold,
+            identity: identity,
+            store: store,
+            stackCapture: stackCapture,
+            safetyPolicy: NativeHangSafetyPolicy(),
+            clock: SystemHangWatchdogClock(),
+            mainPinger: DispatchMainThreadPinger(),
+            diagnosticDelivery: diagnosticDelivery,
+        )
+        let timer = DispatchHangTimer(
+            interval: configuration.threshold / 5,
+            controller: controller,
+        )
+        self.controller = controller
+        self.timer = timer
+        self.lifecycle = lifecycle
+        lifecycle.onActiveChange = { [weak controller] active in
+            controller?.setActive(active)
+        }
+    }
+
+    init(
+        controller: any HangWatchdogControlling,
+        timer: any HangTimerControlling,
+        lifecycle: any HangLifecycleObserving,
+    ) {
+        self.controller = controller
+        self.timer = timer
+        self.lifecycle = lifecycle
+        lifecycle.onActiveChange = { [weak controller] active in
+            controller?.setActive(active)
+        }
+    }
+
+    deinit {
+        stop()
+    }
+
+    func start() {
+        lock.lock()
+        guard timerState == .prepared else {
+            lock.unlock()
+            return
+        }
+        controller.start(active: lifecycle.isActive)
+        lifecycle.start()
+        timer.activate()
+        timerState = .active
+        lock.unlock()
+    }
+
+    func stop() {
+        lock.lock()
+        switch timerState {
+        case .prepared:
+            timer.activate()
+            timer.cancel()
+        case .active:
+            timer.cancel()
+        case .stopped:
+            lock.unlock()
+            return
+        }
+        timerState = .stopped
+        lock.unlock()
+        lifecycle.stop()
+        controller.stop()
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeHangWatchdogContracts.swift

@@ -0,0 +1,84 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public enum NativeHangDiagnosticCode: String, Sendable {
+    case skippedDebugger = "hang_skipped_debugger"
+    case skippedThermal = "hang_skipped_thermal"
+    case skippedSchedulerStall = "hang_skipped_scheduler_stall"
+    case stackUnavailable = "hang_stack_unavailable"
+    case storageFailed = "hang_storage_failed"
+    case pendingRetained = "hang_pending_retained"
+    case captured = "hang_captured"
+    case recovered = "hang_recovered"
+}
+
+public struct NativeHangDiagnostic: Sendable, CustomStringConvertible {
+    public let code: NativeHangDiagnosticCode
+
+    init(_ code: NativeHangDiagnosticCode) {
+        self.code = code
+    }
+
+    public var description: String {
+        "NativeHangDiagnostic(code: \(code.rawValue))"
+    }
+}
+
+public struct NativeHangWatchdogConfiguration: @unchecked Sendable {
+    public let threshold: TimeInterval
+    public let diagnosticsHandler: (@Sendable (NativeHangDiagnostic) -> Void)?
+
+    public init(
+        threshold: TimeInterval = 2,
+        diagnosticsHandler: (@Sendable (NativeHangDiagnostic) -> Void)? = nil,
+    ) throws {
+        guard threshold.isFinite, (1 ... 30).contains(threshold) else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        self.threshold = threshold
+        self.diagnosticsHandler = diagnosticsHandler
+    }
+}
+
+protocol HangWatchdogClock: AnyObject, Sendable {
+    func monotonicNow() -> TimeInterval
+    func timestamp() -> String
+}
+
+protocol HangSafetyChecking: AnyObject, Sendable {
+    func isDebuggerAttached() -> Bool
+    func isThermallyRestricted() -> Bool
+}
+
+protocol MainThreadStackCapturing: AnyObject, Sendable {
+    func capture() -> [NativeStackFrame]
+}
+
+protocol MainThreadPinging: AnyObject, Sendable {
+    func ping(_ response: @escaping @Sendable () -> Void)
+}
+
+protocol HangDiagnosticDelivering: AnyObject, Sendable {
+    func enqueue(_ diagnostic: NativeHangDiagnostic)
+}
+
+protocol HangWatchdogControlling: AnyObject, Sendable {
+    func start(active: Bool)
+    func setActive(_ active: Bool)
+    func poll()
+    func stop()
+}
+
+protocol HangTimerControlling: AnyObject, Sendable {
+    func activate()
+    func cancel()
+}
+
+protocol HangLifecycleObserving: AnyObject, Sendable {
+    var onActiveChange: (@Sendable (Bool) -> Void)? { get set }
+    var isActive: Bool { get }
+
+    func start()
+    func stop()
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeHangWatchdogSystem.swift

@@ -0,0 +1,139 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Darwin
+import Foundation
+
+#if canImport(UIKit)
+    import UIKit
+#endif
+
+final class DispatchHangTimer: HangTimerControlling, @unchecked Sendable {
+    private let source: DispatchSourceTimer
+
+    init(interval: TimeInterval, controller: any HangWatchdogControlling) {
+        source = DispatchSource.makeTimerSource(
+            queue: DispatchQueue(label: "co.logbrew.native-hang-watchdog", qos: .utility),
+        )
+        source.schedule(
+            deadline: .now() + interval,
+            repeating: interval,
+            leeway: .milliseconds(20),
+        )
+        source.setEventHandler { [weak controller] in
+            controller?.poll()
+        }
+    }
+
+    func activate() {
+        source.activate()
+    }
+
+    func cancel() {
+        source.cancel()
+    }
+}
+
+final class SystemHangWatchdogClock: HangWatchdogClock, @unchecked Sendable {
+    func monotonicNow() -> TimeInterval {
+        ProcessInfo.processInfo.systemUptime
+    }
+
+    func timestamp() -> String {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.string(from: Date())
+    }
+}
+
+final class DispatchMainThreadPinger: MainThreadPinging, @unchecked Sendable {
+    func ping(_ response: @escaping @Sendable () -> Void) {
+        DispatchQueue.main.async(execute: response)
+    }
+}
+
+final class NativeHangSafetyPolicy: HangSafetyChecking, @unchecked Sendable {
+    func isDebuggerAttached() -> Bool {
+        var information = kinfo_proc()
+        var size = MemoryLayout<kinfo_proc>.stride
+        var mib = [CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()]
+        guard sysctl(&mib, u_int(mib.count), &information, &size, nil, 0) == 0 else {
+            return true
+        }
+        return information.kp_proc.p_flag & P_TRACED != 0
+    }
+
+    func isThermallyRestricted() -> Bool {
+        switch ProcessInfo.processInfo.thermalState {
+        case .serious, .critical:
+            true
+        default:
+            false
+        }
+    }
+}
+
+final class NativeHangLifecycleObserver: HangLifecycleObserving, @unchecked Sendable {
+    var onActiveChange: (@Sendable (Bool) -> Void)?
+    private let lock = NSLock()
+    private var observers: [NSObjectProtocol] = []
+    private var active = false
+
+    var isActive: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return active
+    }
+
+    init() throws {
+        #if !canImport(UIKit)
+            throw NativeCrashError(.invalidConfiguration)
+        #else
+            active = MainActor.assumeIsolated {
+                UIApplication.shared.applicationState == .active
+            }
+        #endif
+    }
+
+    func start() {
+        #if canImport(UIKit)
+            let center = NotificationCenter.default
+            observers = [
+                center.addObserver(
+                    forName: UIApplication.didBecomeActiveNotification,
+                    object: nil,
+                    queue: .main,
+                ) { [weak self] _ in
+                    self?.updateActive(true)
+                },
+                center.addObserver(
+                    forName: UIApplication.willResignActiveNotification,
+                    object: nil,
+                    queue: .main,
+                ) { [weak self] _ in
+                    self?.updateActive(false)
+                },
+                center.addObserver(
+                    forName: UIApplication.didEnterBackgroundNotification,
+                    object: nil,
+                    queue: .main,
+                ) { [weak self] _ in
+                    self?.updateActive(false)
+                },
+            ]
+        #endif
+    }
+
+    func stop() {
+        let center = NotificationCenter.default
+        observers.forEach(center.removeObserver)
+        observers.removeAll()
+    }
+
+    private func updateActive(_ active: Bool) {
+        lock.lock()
+        self.active = active
+        let handler = onActiveChange
+        lock.unlock()
+        handler?(active)
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeMainThreadStackCapture.swift

@@ -0,0 +1,84 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Darwin
+import Foundation
+@preconcurrency import KSCrash
+
+final class NativeMainThreadStackCapture: MainThreadStackCapturing, @unchecked Sendable {
+    private static let maxFrames = 32
+    private static let cpuTypeArm64: Int32 = 0x0100_000C
+    private static let cpuTypeX8664: Int32 = 0x0100_0007
+    private static let cpuSubtypeMask: UInt32 = 0x00FF_FFFF
+    private let mainThread: pthread_t
+
+    init() throws {
+        guard Thread.isMainThread else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        mainThread = pthread_self()
+    }
+
+    func capture() -> [NativeStackFrame] {
+        #if os(watchOS)
+            return []
+        #else
+            var addresses = [UInt](repeating: 0, count: Self.maxFrames)
+            let count = captureBacktrace(
+                thread: mainThread,
+                addresses: &addresses,
+                count: Int32(Self.maxFrames),
+            )
+            guard count > 0 else {
+                return []
+            }
+            return addresses.prefix(Int(count)).compactMap(frame)
+        #endif
+    }
+
+    private func frame(for address: UInt) -> NativeStackFrame? {
+        var information = SymbolInformation()
+        guard symbolicate(address: address, result: &information),
+              let uuidBytes = information.imageUUID,
+              let architecture = architecture(
+                  cpuType: information.imageCpuType,
+                  cpuSubtype: information.imageCpuSubType,
+              ),
+              information.callInstruction >= information.imageAddress
+        else {
+            return nil
+        }
+        let imageEnd = information.imageAddress.addingReportingOverflow(UInt(information.imageSize))
+        guard !imageEnd.overflow, information.callInstruction < imageEnd.partialValue else {
+            return nil
+        }
+        let bytes = UnsafeBufferPointer(start: uuidBytes, count: 16)
+        let uuid = UUID(uuid: (
+            bytes[0], bytes[1], bytes[2], bytes[3],
+            bytes[4], bytes[5], bytes[6], bytes[7],
+            bytes[8], bytes[9], bytes[10], bytes[11],
+            bytes[12], bytes[13], bytes[14], bytes[15],
+        )).uuidString.lowercased()
+        return NativeStackFrame(
+            imageUuid: uuid,
+            architecture: architecture,
+            instructionOffset: String(
+                format: "%016llx",
+                UInt64(information.callInstruction - information.imageAddress),
+            ),
+        )
+    }
+
+    private func architecture(cpuType: Int32, cpuSubtype: Int32) -> NativeStackArchitecture? {
+        let subtype = UInt32(bitPattern: cpuSubtype) & Self.cpuSubtypeMask
+        return switch (cpuType, subtype) {
+        case (Self.cpuTypeArm64, 0), (Self.cpuTypeArm64, 1):
+            .arm64
+        case (Self.cpuTypeArm64, 2):
+            .arm64e
+        case (Self.cpuTypeX8664, 3):
+            .x8664
+        default:
+            nil
+        }
+    }
+}