@logbrew/react-native 0.1.11 → 0.1.12

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCapture.swift

@@ -0,0 +1,229 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Darwin
+import Foundation
+
+@objc(LBRNAppleNativeCrashCapture)
+@objcMembers
+public final class NativeCrashCapture: NSObject, @unchecked Sendable {
+    let configuration: NativeCrashConfiguration
+    let driver: any CrashEngineDriving
+    let ownership: ProcessCrashCaptureOwnership
+    let processIDProvider: @Sendable () -> Int32
+    let ownerProcessID: Int32
+    let ownerNonce = UUID()
+    let lock = NSLock()
+
+    var store: (any CrashReportStoring)?
+    var hangStore: (any HangIncidentStoring)?
+    var hangRuntime: NativeHangWatchdogRuntime?
+    var storageLease: CrashStorageLease?
+    var lifecycle: NativeCrashLifecycleState = .idle
+    var lastOutcome: NativeCrashOutcome = .none
+    var acknowledged = 0
+    var discarded = 0
+    var replaying = false
+
+    public init(configuration: NativeCrashConfiguration) {
+        let processIDProvider: @Sendable () -> Int32 = { getpid() }
+        self.configuration = configuration
+        driver = KSCrashEngineDriver()
+        ownership = .shared
+        self.processIDProvider = processIDProvider
+        ownerProcessID = processIDProvider()
+        super.init()
+    }
+
+    init(
+        configuration: NativeCrashConfiguration,
+        driver: any CrashEngineDriving,
+        ownership: ProcessCrashCaptureOwnership,
+        processIDProvider: @escaping @Sendable () -> Int32 = { getpid() },
+    ) {
+        self.configuration = configuration
+        self.driver = driver
+        self.ownership = ownership
+        self.processIDProvider = processIDProvider
+        ownerProcessID = processIDProvider()
+        super.init()
+    }
+
+    public func install() throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+
+        if store != nil, lifecycle != .stopped {
+            try verifyStorageLocked()
+            return
+        }
+        if lifecycle == .stopped {
+            throw NativeCrashError(.notInstalled)
+        }
+        if lifecycle == .failed {
+            throw NativeCrashError(.engineInstallFailed)
+        }
+
+        do {
+            let storageLease = try CrashStorageDirectory.prepare(configuration.storageDirectory)
+            let preparedHang = try prepareHangWatchdog()
+            try ownership.claim(self)
+            try storageLease.verify()
+            self.storageLease = storageLease
+            let installedStore = try driver.install(
+                configuration: CrashEngineConfiguration(
+                    storageDirectory: configuration.storageDirectory,
+                    maxStoredReports: configuration.maxStoredReports,
+                    monitors: [.machException, .signal, .cppException, .objectiveCException],
+                    includesMemory: false,
+                    includesQueueNames: false,
+                    includesConsoleLog: false,
+                    artifactIdentity: configuration.artifactIdentity.map(NativeArtifactIdentityValue.init),
+                    deletionIsExplicit: true,
+                ),
+            )
+            try storageLease.verify()
+            store = installedStore
+            hangStore = preparedHang?.store
+            hangRuntime = preparedHang?.runtime
+            preparedHang?.runtime.start()
+            lifecycle = .installed
+        } catch let error as NativeCrashError {
+            lifecycle = .failed
+            lastOutcome = .failed
+            throw error
+        } catch {
+            lifecycle = .failed
+            lastOutcome = .failed
+            throw NativeCrashError(.engineInstallFailed)
+        }
+    }
+
+    public func pendingReports() throws -> [NativeCrashRecord] {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        return try pendingReportsLocked()
+    }
+
+    @objc(replayPendingReportsWithHandler:error:)
+    public func replayPendingReports(
+        _ handler: (NativeCrashRecord) -> Bool,
+    ) throws -> NativeCrashReplayResult {
+        try beginReplay()
+        do {
+            return try performReplay(handler)
+        } catch {
+            failReplay()
+            throw error
+        }
+    }
+
+    /// Replays stored reports through the existing delivery engine and acknowledges only accepted reports.
+    @nonobjc
+    public func replayPendingReports(
+        in client: LogBrewClient,
+        transport: any Transport,
+    ) throws -> NativeCrashReplayResult {
+        try replayPendingReports { record in
+            do {
+                try record.enqueue(in: client)
+                return try client.flushEvent(
+                    record.eventID,
+                    transport: transport,
+                )
+            } catch {
+                return false
+            }
+        }
+    }
+
+    /// Stops replay through this adapter without claiming to uninstall the process-lifetime crash handler.
+    public func stopReplay() throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        guard store != nil else {
+            throw NativeCrashError(.notInstalled)
+        }
+        guard !replaying else {
+            throw NativeCrashError(.replayBusy)
+        }
+        hangRuntime?.stop()
+        lifecycle = .stopped
+    }
+
+    public func purge() throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        guard let store else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try verifyStorageLocked()
+        guard !replaying else {
+            throw NativeCrashError(.replayBusy)
+        }
+
+        store.deleteAllReports()
+        guard store.reportIDs.isEmpty else {
+            lastOutcome = .failed
+            throw NativeCrashError(.reportDeletionFailed)
+        }
+        try hangStore?.purge()
+        lastOutcome = .purged
+    }
+
+    public func status() throws -> NativeCrashStatus {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        let pending = store == nil ? 0 : try pendingCountLocked()
+        return NativeCrashStatus(
+            lifecycle: lifecycle,
+            pending: pending,
+            acknowledged: acknowledged,
+            discarded: discarded,
+            lastOutcome: lastOutcome,
+        )
+    }
+}
+
+extension NativeCrashCapture {
+    func verifyStorageLocked() throws {
+        guard let storageLease else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try storageLease.verify()
+    }
+
+    func verifyProcessLocked() throws {
+        guard processIDProvider() == ownerProcessID else {
+            throw NativeCrashError(.processChanged)
+        }
+    }
+}
+
+private extension NativeCrashCapture {
+    func prepareHangWatchdog() throws -> PreparedHangWatchdog? {
+        guard let watchdog = configuration.hangWatchdog,
+              let identity = configuration.artifactIdentity
+        else {
+            return nil
+        }
+        let directory = configuration.storageDirectory
+            .appendingPathComponent("hang-watchdog-v1", isDirectory: true)
+        let store = try NativeHangIncidentFileStore(directory: directory)
+        let runtime = try NativeHangWatchdogRuntime(
+            configuration: watchdog,
+            identity: identity,
+            store: store,
+        )
+        return PreparedHangWatchdog(store: store, runtime: runtime)
+    }
+}
+
+private struct PreparedHangWatchdog {
+    let store: any HangIncidentStoring
+    let runtime: NativeHangWatchdogRuntime
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashPublic.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
+
+@objc(LBRNAppleNativeCrashMechanism)
+public enum NativeCrashMechanism: Int, Sendable {
+    case signal
+    case machException
+    case cppException
+    case objectiveCException
+    case memoryTermination
+    case deadlock
+    case unknown
+
+    public var name: String {
+        switch self {
+        case .signal:
+            "signal"
+        case .machException:
+            "mach"
+        case .cppException:
+            "cpp_exception"
+        case .objectiveCException:
+            "nsexception"
+        case .memoryTermination:
+            "memory_termination"
+        case .deadlock:
+            "deadlock"
+        case .unknown:
+            "unknown"
+        }
+    }
+}
+
+@objc(LBRNAppleNativeCrashLifecycleState)
+public enum NativeCrashLifecycleState: Int, Sendable {
+    case idle
+    case installed
+    case replaying
+    case failed
+    case stopped
+}
+
+@objc(LBRNAppleNativeCrashOutcome)
+public enum NativeCrashOutcome: Int, Sendable {
+    case none
+    case acknowledged
+    case retained
+    case purged
+    case failed
+    case discarded
+}
+
+public enum NativeCrashErrorCode: String, Sendable {
+    case invalidConfiguration = "crash_invalid_configuration"
+    case storageUnsupported = "crash_storage_unsupported"
+    case ownershipConflict = "crash_capture_owned"
+    case notInstalled = "crash_capture_not_installed"
+    case engineInstallFailed = "crash_engine_install_failed"
+    case replayBusy = "crash_replay_busy"
+    case reportCorrupt = "crash_report_corrupt"
+    case reportChanged = "crash_report_changed"
+    case reportDeletionFailed = "crash_report_delete_failed"
+    case processChanged = "crash_process_changed"
+}
+
+public struct NativeCrashError: Error, CustomNSError, LocalizedError, Sendable {
+    public let code: NativeCrashErrorCode
+
+    init(_ code: NativeCrashErrorCode) {
+        self.code = code
+    }
+
+    public static var errorDomain: String {
+        "co.logbrew.native-crash"
+    }
+
+    public var errorCode: Int {
+        switch code {
+        case .invalidConfiguration: 1
+        case .storageUnsupported: 2
+        case .ownershipConflict: 3
+        case .notInstalled: 4
+        case .engineInstallFailed: 5
+        case .replayBusy: 6
+        case .reportCorrupt: 7
+        case .reportChanged: 8
+        case .reportDeletionFailed: 9
+        case .processChanged: 10
+        }
+    }
+
+    public var errorDescription: String? {
+        code.rawValue
+    }
+
+    public var errorUserInfo: [String: Any] {
+        [NSLocalizedDescriptionKey: code.rawValue]
+    }
+}
+
+@objc(LBRNAppleNativeCrashConfiguration)
+@objcMembers
+public final class NativeCrashConfiguration: NSObject, @unchecked Sendable {
+    public let storageDirectory: URL
+    public let maxStoredReports: Int
+    public let maxReplayBytes: Int
+    public let artifactIdentity: NativeArtifactIdentity?
+    @nonobjc public let hangWatchdog: NativeHangWatchdogConfiguration?
+
+    public convenience init(
+        storageDirectory: URL,
+        maxStoredReports: Int = 5,
+        maxReplayBytes: Int = 4 * 1024 * 1024,
+    ) throws {
+        try self.init(
+            storageDirectory: storageDirectory,
+            maxStoredReports: maxStoredReports,
+            maxReplayBytes: maxReplayBytes,
+            artifactIdentity: nil,
+            hangWatchdog: nil,
+        )
+    }
+
+    @nonobjc
+    public init(
+        storageDirectory: URL,
+        maxStoredReports: Int = 5,
+        maxReplayBytes: Int = 4 * 1024 * 1024,
+        artifactIdentity: NativeArtifactIdentity?,
+        hangWatchdog: NativeHangWatchdogConfiguration?,
+    ) throws {
+        guard storageDirectory.isFileURL,
+              !storageDirectory.path.isEmpty,
+              storageDirectory.path != "/",
+              (1 ... 32).contains(maxStoredReports),
+              (1024 ... 16 * 1024 * 1024).contains(maxReplayBytes),
+              hangWatchdog == nil || artifactIdentity != nil
+        else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+
+        let normalizedDirectory = CrashStorageDirectory.normalized(storageDirectory)
+        guard normalizedDirectory.path != "/",
+              !["", ".", ".."].contains(storageDirectory.lastPathComponent)
+        else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        self.storageDirectory = normalizedDirectory
+        self.maxStoredReports = maxStoredReports
+        self.maxReplayBytes = maxReplayBytes
+        self.artifactIdentity = artifactIdentity
+        self.hangWatchdog = hangWatchdog
+    }
+}
+
+@objc(LBRNAppleNativeCrashRecord)
+@objcMembers
+public final class NativeCrashRecord: NSObject, @unchecked Sendable {
+    public let eventID: String
+    public let timestamp: String
+    public let mechanism: NativeCrashMechanism
+
+    private let nativeStackFrames: [NativeStackFrame]?
+    private let artifactIdentity: NativeArtifactIdentity?
+    private let hangState: NativeHangIncidentState?
+    private let hangDurationMs: Double?
+    let source: NativeCrashRecordSource
+    let digest: Data
+    let ownerNonce: UUID
+
+    init(
+        eventID: String,
+        timestamp: String,
+        mechanism: NativeCrashMechanism,
+        nativeStackFrames: [NativeStackFrame]?,
+        artifactIdentity: NativeArtifactIdentity?,
+        hangState: NativeHangIncidentState?,
+        hangDurationMs: Double? = nil,
+        source: NativeCrashRecordSource,
+        digest: Data,
+        ownerNonce: UUID,
+    ) {
+        self.eventID = eventID
+        self.timestamp = timestamp
+        self.mechanism = mechanism
+        self.nativeStackFrames = nativeStackFrames
+        self.artifactIdentity = artifactIdentity
+        self.hangState = hangState
+        self.hangDurationMs = hangDurationMs
+        self.source = source
+        self.digest = digest
+        self.ownerNonce = ownerNonce
+    }
+
+    @nonobjc
+    public func enqueue(in client: LogBrewClient) throws {
+        let existing = try existingEvent(in: client)
+        if existing == .matching {
+            return
+        }
+        if existing == .collision {
+            throw NativeCrashError(.reportChanged)
+        }
+
+        try client.issueDetached(
+            eventID,
+            timestamp: timestamp,
+            attributes: issueAttributes,
+        )
+    }
+
+    override public var description: String {
+        "NativeCrashRecord(mechanism: \(mechanism.name), configuredIdentity: \(artifactIdentity != nil))"
+    }
+
+    private var issueAttributes: IssueAttributes {
+        var metadata: Metadata = [
+            "crash.mechanism": .string(mechanism.name),
+            "crash.replayed": .bool(true),
+        ]
+        if let artifactIdentity {
+            metadata["projectId"] = .string(artifactIdentity.projectId)
+            metadata["release"] = .string(artifactIdentity.release)
+            metadata["environment"] = .string(artifactIdentity.environment)
+            metadata["service"] = .string(artifactIdentity.service)
+        }
+        if let hangState {
+            metadata["crash.handled"] = .bool(hangState == .recovered)
+        }
+        if let hangDurationMs {
+            metadata["durationMs"] = .double(hangDurationMs)
+        }
+        return IssueAttributes(
+            title: hangState == nil ? "Native application crash" : "Native application hang",
+            level: hangState == .recovered ? .error : .fatal,
+            exception: IssueException(
+                type: hangState == nil ? "AppleNativeCrash" : "AppleNativeHang",
+                mechanism: IssueExceptionMechanism(
+                    type: mechanism.name,
+                    handled: hangState == .recovered,
+                ),
+            ),
+            metadata: metadata,
+            nativeStackFrames: nativeStackFrames,
+        )
+    }
+
+    private func existingEvent(in client: LogBrewClient) throws -> ExistingEvent {
+        guard let data = try client.previewJSON().data(using: .utf8),
+              let payload = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let events = payload["events"] as? [[String: Any]]
+        else {
+            throw NativeCrashError(.reportChanged)
+        }
+        guard let event = events.first(where: { $0["id"] as? String == eventID }) else {
+            return .absent
+        }
+        guard event["type"] as? String == "issue",
+              event["timestamp"] as? String == timestamp,
+              let attributes = event["attributes"] as? [String: Any],
+              attributes["title"] as? String == issueAttributes.title,
+              attributes["level"] as? String == issueAttributes.level.canonicalValue,
+              attributes["message"] == nil,
+              exceptionMatches(attributes["exception"]),
+              attributes["stackFrames"] == nil,
+              attributes["breadcrumbs"] == nil,
+              attributes["breadcrumbsTruncated"] == nil,
+              attributes["context"] == nil,
+              let metadata = attributes["metadata"] as? [String: Any],
+              metadata as NSDictionary == expectedMetadata,
+              nativeStackFramesMatch(attributes["nativeStackFrames"])
+        else {
+            return .collision
+        }
+        return .matching
+    }
+
+    private var expectedMetadata: NSDictionary {
+        var metadata: [String: Any] = [
+            "crash.mechanism": mechanism.name,
+            "crash.replayed": true,
+        ]
+        if let artifactIdentity {
+            metadata["projectId"] = artifactIdentity.projectId
+            metadata["release"] = artifactIdentity.release
+            metadata["environment"] = artifactIdentity.environment
+            metadata["service"] = artifactIdentity.service
+        }
+        if let hangState {
+            metadata["crash.handled"] = hangState == .recovered
+        }
+        if let hangDurationMs {
+            metadata["durationMs"] = hangDurationMs
+        }
+        return metadata as NSDictionary
+    }
+
+    private var expectedException: NSDictionary {
+        [
+            "type": hangState == nil ? "AppleNativeCrash" : "AppleNativeHang",
+            "mechanism": [
+                "type": mechanism.name,
+                "handled": hangState == .recovered,
+            ],
+        ] as NSDictionary
+    }
+
+    private func exceptionMatches(_ value: Any?) -> Bool {
+        guard let value else {
+            // Preserve exact retry identity for an event queued by an older SDK before typed exceptions existed.
+            return true
+        }
+        guard let exception = value as? [String: Any] else {
+            return false
+        }
+        return exception as NSDictionary == expectedException
+    }
+
+    private func nativeStackFramesMatch(_ value: Any?) -> Bool {
+        guard let nativeStackFrames else {
+            return value == nil
+        }
+        guard let frames = value as? [[String: Any]], frames.count == nativeStackFrames.count else {
+            return false
+        }
+        return zip(frames, nativeStackFrames).allSatisfy { frame, expected in
+            frame as NSDictionary == [
+                "imageUuid": expected.imageUuid,
+                "architecture": expected.architecture.rawValue,
+                "instructionOffset": expected.instructionOffset,
+            ] as NSDictionary
+        }
+    }
+}
+
+enum NativeCrashRecordSource: Equatable {
+    case engine(reportID: Int64)
+    case hang(eventID: String)
+}
+
+private enum ExistingEvent {
+    case absent
+    case matching
+    case collision
+}
+
+@objc(LBRNAppleNativeCrashReplayResult)
+@objcMembers
+public final class NativeCrashReplayResult: NSObject, @unchecked Sendable {
+    public let attempted: Int
+    public let acknowledged: Int
+    public let discarded: Int
+    public let pending: Int
+
+    init(attempted: Int, acknowledged: Int, discarded: Int, pending: Int) {
+        self.attempted = attempted
+        self.acknowledged = acknowledged
+        self.discarded = discarded
+        self.pending = pending
+    }
+}
+
+@objc(LBRNAppleNativeCrashStatus)
+@objcMembers
+public final class NativeCrashStatus: NSObject, @unchecked Sendable {
+    public let lifecycle: NativeCrashLifecycleState
+    public let pending: Int
+    public let acknowledged: Int
+    public let discarded: Int
+    public let lastOutcome: NativeCrashOutcome
+
+    init(
+        lifecycle: NativeCrashLifecycleState,
+        pending: Int,
+        acknowledged: Int,
+        discarded: Int,
+        lastOutcome: NativeCrashOutcome,
+    ) {
+        self.lifecycle = lifecycle
+        self.pending = pending
+        self.acknowledged = acknowledged
+        self.discarded = discarded
+        self.lastOutcome = lastOutcome
+    }
+}