@logbrew/react-native 0.1.10 → 0.1.12

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashReplay.swift

@@ -0,0 +1,317 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+extension NativeCrashCapture {
+    func beginReplay() throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        guard store != nil, lifecycle != .stopped else {
+            throw NativeCrashError(.notInstalled)
+        }
+        guard !replaying else {
+            throw NativeCrashError(.replayBusy)
+        }
+        replaying = true
+        lifecycle = .replaying
+    }
+
+    func performReplay(_ handler: (NativeCrashRecord) -> Bool) throws -> NativeCrashReplayResult {
+        var attempted = 0
+        var accepted = 0
+        var discardedDuringReplay = 0
+        replayLoop: while true {
+            switch try nextReplayItem() {
+            case .none:
+                break replayLoop
+            case .discarded:
+                discardedDuringReplay += 1
+            case let .record(record):
+                attempted += 1
+                guard handler(record) else {
+                    recordRetained()
+                    break replayLoop
+                }
+                try acknowledge(record)
+                accepted += 1
+            }
+        }
+
+        return try NativeCrashReplayResult(
+            attempted: attempted,
+            acknowledged: accepted,
+            discarded: discardedDuringReplay,
+            pending: finishReplay(),
+        )
+    }
+
+    func nextReplayItem() throws -> NativeCrashReplayItem {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let store else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try verifyStorageLocked()
+        let reportIDs = try validatedReportIDs(in: store)
+        let hangItem = try nextHangReplayItem()
+        let engineItem = try nextEngineReplayItem(
+            reportIDs: reportIDs,
+            store: store,
+        )
+        if hangItem?.isDiscarded == true || engineItem?.isDiscarded == true {
+            return .discarded
+        }
+        return oldestRecord(in: [hangItem, engineItem])
+    }
+
+    func acknowledge(_ record: NativeCrashRecord) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        guard record.ownerNonce == ownerNonce, let store else {
+            throw NativeCrashError(.reportChanged)
+        }
+        try verifyStorageLocked()
+        switch record.source {
+        case let .engine(reportID):
+            try acknowledgeEngineRecord(record, reportID: reportID, store: store)
+        case let .hang(eventID):
+            try acknowledgeHangRecord(record, eventID: eventID)
+        }
+        acknowledged += 1
+        lastOutcome = .acknowledged
+    }
+
+    func pendingReportsLocked() throws -> [NativeCrashRecord] {
+        guard let store else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try verifyStorageLocked()
+        let reportIDs = try validatedReportIDs(in: store)
+
+        var records: [NativeCrashRecord] = []
+        if let incident = try hangStore?.read() {
+            try records.append(incident.makeRecord(ownerNonce: ownerNonce))
+        }
+        try records.append(contentsOf: reportIDs.map { reportID in
+            guard let rawReport = store.report(for: reportID) else {
+                throw NativeCrashError(.reportChanged)
+            }
+            return try sanitizer.makeRecord(reportID: reportID, rawReport: rawReport)
+        })
+        try verifyReportIDs(reportIDs, in: store)
+        return records.sorted(by: NativeCrashRecord.occursBefore)
+    }
+
+    func pendingCountLocked() throws -> Int {
+        guard let store else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try verifyStorageLocked()
+        let reportIDs = try validatedReportIDs(in: store)
+        return try reportIDs.count + ((hangStore?.read()) == nil ? 0 : 1)
+    }
+
+    func failReplay() {
+        lock.lock()
+        replaying = false
+        lifecycle = .installed
+        lastOutcome = .failed
+        lock.unlock()
+    }
+}
+
+private extension NativeCrashCapture {
+    func nextHangReplayItem() throws -> NativeCrashReplayItem? {
+        guard let hangStore else {
+            return nil
+        }
+        do {
+            guard let incident = try hangStore.read() else {
+                return nil
+            }
+            return try .record(incident.makeRecord(ownerNonce: ownerNonce))
+        } catch let error as NativeCrashError where error.code == .reportCorrupt {
+            try hangStore.purge()
+            recordDiscardedLocked()
+            return .discarded
+        }
+    }
+
+    func nextEngineReplayItem(
+        reportIDs: [Int64],
+        store: any CrashReportStoring,
+    ) throws -> NativeCrashReplayItem? {
+        var records: [NativeCrashRecord] = []
+        for reportID in reportIDs {
+            let item = try engineReplayItem(
+                reportID: reportID,
+                expectedReportIDs: reportIDs,
+                store: store,
+            )
+            switch item {
+            case .none:
+                continue
+            case .discarded:
+                return .discarded
+            case let .record(record):
+                records.append(record)
+            }
+        }
+        return records.min(by: NativeCrashRecord.occursBefore).map(NativeCrashReplayItem.record)
+    }
+
+    func oldestRecord(in items: [NativeCrashReplayItem?]) -> NativeCrashReplayItem {
+        let records = items.compactMap { item -> NativeCrashRecord? in
+            guard case let .record(record) = item else {
+                return nil
+            }
+            return record
+        }
+        return records.min(by: NativeCrashRecord.occursBefore).map(NativeCrashReplayItem.record)
+            ?? .none
+    }
+
+    func engineReplayItem(
+        reportID: Int64,
+        expectedReportIDs: [Int64],
+        store: any CrashReportStoring,
+    ) throws -> NativeCrashReplayItem {
+        guard let rawReport = store.report(for: reportID) else {
+            throw NativeCrashError(.reportChanged)
+        }
+        do {
+            let record = try sanitizer.makeRecord(reportID: reportID, rawReport: rawReport)
+            try verifyReportIDs(expectedReportIDs, in: store)
+            return .record(record)
+        } catch let error as NativeCrashError where error.code == .reportCorrupt {
+            try verifyReportIDs(expectedReportIDs, in: store)
+            store.deleteReport(with: reportID)
+            guard !store.reportIDs.contains(reportID) else {
+                throw NativeCrashError(.reportDeletionFailed)
+            }
+            recordDiscardedLocked()
+            return .discarded
+        }
+    }
+
+    func validatedReportIDs(in store: any CrashReportStoring) throws -> [Int64] {
+        let reportIDs = store.reportIDs.sorted()
+        guard reportIDs.count <= configuration.maxStoredReports,
+              Set(reportIDs).count == reportIDs.count,
+              reportIDs.allSatisfy({ $0 > 0 })
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        return reportIDs
+    }
+
+    func verifyReportIDs(
+        _ expectedReportIDs: [Int64],
+        in store: any CrashReportStoring,
+    ) throws {
+        guard store.reportIDs.sorted() == expectedReportIDs else {
+            throw NativeCrashError(.reportChanged)
+        }
+    }
+
+    func acknowledgeEngineRecord(
+        _ record: NativeCrashRecord,
+        reportID: Int64,
+        store: any CrashReportStoring,
+    ) throws {
+        guard store.reportIDs.contains(reportID),
+              let rawReport = store.report(for: reportID),
+              try sanitizer.digest(rawReport) == record.digest
+        else {
+            throw NativeCrashError(.reportChanged)
+        }
+        store.deleteReport(with: reportID)
+        guard !store.reportIDs.contains(reportID) else {
+            throw NativeCrashError(.reportDeletionFailed)
+        }
+    }
+
+    func acknowledgeHangRecord(
+        _ record: NativeCrashRecord,
+        eventID: String,
+    ) throws {
+        guard let hangStore,
+              let incident = try hangStore.read(),
+              incident.eventID == eventID,
+              try incident.digest() == record.digest
+        else {
+            throw NativeCrashError(.reportChanged)
+        }
+        try hangStore.delete(eventID: eventID)
+    }
+
+    func recordDiscardedLocked() {
+        if discarded < Int.max {
+            discarded += 1
+        }
+        lastOutcome = .discarded
+    }
+
+    func recordRetained() {
+        lock.lock()
+        lastOutcome = .retained
+        lock.unlock()
+    }
+
+    func finishReplay() throws -> Int {
+        lock.lock()
+        defer { lock.unlock() }
+        let pending = try pendingCountLocked()
+        replaying = false
+        lifecycle = .installed
+        return pending
+    }
+
+    var sanitizer: CrashReportSanitizer {
+        CrashReportSanitizer(
+            maxReplayBytes: configuration.maxReplayBytes,
+            ownerNonce: ownerNonce,
+        )
+    }
+}
+
+enum NativeCrashReplayItem {
+    case none
+    case discarded
+    case record(NativeCrashRecord)
+
+    var isDiscarded: Bool {
+        if case .discarded = self {
+            return true
+        }
+        return false
+    }
+}
+
+private extension NativeCrashRecord {
+    static func occursBefore(_ lhs: NativeCrashRecord, _ rhs: NativeCrashRecord) -> Bool {
+        let lhsTimestamp = NativeCrashTimestamp(lhs.timestamp)
+        let rhsTimestamp = NativeCrashTimestamp(rhs.timestamp)
+        guard let lhsTimestamp, let rhsTimestamp else {
+            return lhs.source.occursBefore(rhs.source)
+        }
+        if lhsTimestamp != rhsTimestamp {
+            return lhsTimestamp < rhsTimestamp
+        }
+        return lhs.source.occursBefore(rhs.source)
+    }
+}
+
+private extension NativeCrashRecordSource {
+    func occursBefore(_ other: NativeCrashRecordSource) -> Bool {
+        switch (self, other) {
+        case let (.engine(lhsReportID), .engine(rhsReportID)):
+            lhsReportID < rhsReportID
+        case (.engine, .hang):
+            true
+        case (.hang, .engine), (.hang, .hang):
+            false
+        }
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeHangIncidentStore.swift

@@ -0,0 +1,321 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import CryptoKit
+import Darwin
+import Foundation
+
+enum NativeHangIncidentState: String, Codable {
+    case ongoing
+    case recovered
+}
+
+enum NativeHangDuration {
+    static let maxMilliseconds = 24 * 60 * 60 * 1000.0
+
+    static func validated(_ milliseconds: Double) throws -> Double {
+        guard milliseconds.isFinite,
+              milliseconds >= 0,
+              milliseconds <= maxMilliseconds
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        return milliseconds
+    }
+
+    static func milliseconds(
+        from monotonicStart: TimeInterval,
+        through monotonicEnd: TimeInterval,
+    ) -> Double? {
+        guard monotonicStart.isFinite,
+              monotonicEnd.isFinite,
+              monotonicEnd >= monotonicStart
+        else {
+            return nil
+        }
+        return try? validated((monotonicEnd - monotonicStart) * 1000)
+    }
+}
+
+struct NativeHangIncident: Codable, Equatable {
+    private let version: Int
+    let eventID: String
+    let timestamp: String
+    var state: NativeHangIncidentState
+    let artifactIdentity: NativeArtifactIdentityValue
+    let nativeStackFrames: [NativeStackFrame]
+    var durationMs: Double?
+
+    init(
+        eventID: String,
+        timestamp: String,
+        state: NativeHangIncidentState,
+        identity: NativeArtifactIdentity,
+        nativeStackFrames: [NativeStackFrame],
+        durationMs: Double? = nil,
+    ) {
+        version = 1
+        self.eventID = eventID
+        self.timestamp = timestamp
+        self.state = state
+        artifactIdentity = NativeArtifactIdentityValue(identity)
+        self.nativeStackFrames = nativeStackFrames
+        self.durationMs = durationMs
+    }
+
+    func validated() throws -> NativeHangIncident {
+        guard version == 1,
+              UUID(uuidString: eventID)?.uuidString.lowercased() == eventID,
+              normalizedTimestamp(timestamp) == timestamp,
+              (1 ... 32).contains(nativeStackFrames.count),
+              nativeStackFrames.allSatisfy(validFrame)
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        do {
+            _ = try artifactIdentity.validatedIdentity()
+            if let durationMs {
+                _ = try NativeHangDuration.validated(durationMs)
+            }
+        } catch {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        return self
+    }
+
+    func digest() throws -> Data {
+        try Data(SHA256.hash(data: encoded()))
+    }
+
+    func makeRecord(ownerNonce: UUID) throws -> NativeCrashRecord {
+        try NativeCrashRecord(
+            eventID: eventID,
+            timestamp: timestamp,
+            mechanism: .deadlock,
+            nativeStackFrames: nativeStackFrames,
+            artifactIdentity: artifactIdentity.validatedIdentity(),
+            hangState: state,
+            hangDurationMs: durationMs,
+            source: .hang(eventID: eventID),
+            digest: digest(),
+            ownerNonce: ownerNonce,
+        )
+    }
+
+    func encoded() throws -> Data {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+        let data = try encoder.encode(self)
+        guard data.count <= NativeHangIncidentFileStore.maxBytes else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        return data
+    }
+
+    private func validFrame(_ frame: NativeStackFrame) -> Bool {
+        UUID(uuidString: frame.imageUuid)?.uuidString.lowercased() == frame.imageUuid
+            && frame.instructionOffset.utf8.count == 16
+            && frame.instructionOffset.utf8.allSatisfy {
+                ($0 >= 48 && $0 <= 57) || ($0 >= 97 && $0 <= 102)
+            }
+    }
+
+    private func normalizedTimestamp(_ value: String) -> String? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        guard let date = formatter.date(from: value) else {
+            return nil
+        }
+        return formatter.string(from: date)
+    }
+}
+
+protocol HangIncidentStoring: AnyObject, Sendable {
+    func read() throws -> NativeHangIncident?
+    func write(_ incident: NativeHangIncident) throws
+    func markRecovered(eventID: String, durationMs: Double) throws
+    func delete(eventID: String) throws
+    func purge() throws
+}
+
+final class NativeHangIncidentFileStore: HangIncidentStoring, @unchecked Sendable {
+    static let recordName = "hang-v1.record"
+    static let maxBytes = 16 * 1024
+
+    private let directory: URL
+    private let recordURL: URL
+    private let temporaryURL: URL
+    private let lease: CrashStorageLease
+    private let lock = NSLock()
+
+    init(directory: URL) throws {
+        self.directory = CrashStorageDirectory.normalized(directory)
+        lease = try CrashStorageDirectory.prepare(self.directory)
+        recordURL = self.directory.appendingPathComponent(Self.recordName, isDirectory: false)
+        temporaryURL = self.directory.appendingPathComponent("\(Self.recordName).tmp", isDirectory: false)
+        try removeStaleTemporary()
+    }
+
+    func read() throws -> NativeHangIncident? {
+        lock.lock()
+        defer { lock.unlock() }
+        return try readLocked()
+    }
+
+    func write(_ incident: NativeHangIncident) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        guard try readLocked() == nil else {
+            throw NativeCrashError(.reportChanged)
+        }
+        try writeLocked(incident.validated())
+    }
+
+    func markRecovered(eventID: String, durationMs: Double) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        guard var incident = try readLocked(), incident.eventID == eventID else {
+            throw NativeCrashError(.reportChanged)
+        }
+        let recoveredDuration = try NativeHangDuration.validated(durationMs)
+        guard incident.durationMs.map({ recoveredDuration >= $0 }) ?? true else {
+            throw NativeCrashError(.reportChanged)
+        }
+        incident.state = .recovered
+        incident.durationMs = recoveredDuration
+        try writeLocked(incident.validated())
+    }
+
+    func delete(eventID: String) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let incident = try readLocked(), incident.eventID == eventID else {
+            throw NativeCrashError(.reportChanged)
+        }
+        try lease.verify()
+        guard unlink(recordURL.path) == 0 else {
+            throw NativeCrashError(.reportDeletionFailed)
+        }
+        try lease.synchronize()
+        guard try readLocked() == nil else {
+            throw NativeCrashError(.reportDeletionFailed)
+        }
+    }
+
+    func purge() throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try lease.verify()
+        if unlink(recordURL.path) != 0, errno != ENOENT {
+            throw NativeCrashError(.reportDeletionFailed)
+        }
+        try lease.synchronize()
+    }
+
+    private func readLocked() throws -> NativeHangIncident? {
+        try lease.verify()
+        let descriptor = open(recordURL.path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC)
+        if descriptor < 0 {
+            if errno == ENOENT {
+                return nil
+            }
+            throw NativeCrashError(.storageUnsupported)
+        }
+        defer { close(descriptor) }
+
+        var information = stat()
+        guard fstat(descriptor, &information) == 0,
+              information.st_mode & S_IFMT == S_IFREG,
+              information.st_mode & 0o077 == 0,
+              information.st_size > 0,
+              information.st_size <= Self.maxBytes
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        var data = Data(count: Int(information.st_size))
+        let count = data.withUnsafeMutableBytes { buffer -> Int in
+            guard let base = buffer.baseAddress else {
+                return -1
+            }
+            var consumed = 0
+            while consumed < buffer.count {
+                let result = Darwin.read(descriptor, base.advanced(by: consumed), buffer.count - consumed)
+                if result <= 0 {
+                    return -1
+                }
+                consumed += result
+            }
+            return consumed
+        }
+        guard count == data.count else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        do {
+            return try JSONDecoder().decode(NativeHangIncident.self, from: data).validated()
+        } catch let error as NativeCrashError {
+            throw error
+        } catch {
+            throw NativeCrashError(.reportCorrupt)
+        }
+    }
+
+    private func writeLocked(_ incident: NativeHangIncident) throws {
+        try lease.verify()
+        let data = try incident.encoded()
+        try removeStaleTemporary()
+        let descriptor = open(
+            temporaryURL.path,
+            O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC,
+            S_IRUSR | S_IWUSR,
+        )
+        guard descriptor >= 0 else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+
+        var succeeded = false
+        defer {
+            close(descriptor)
+            if !succeeded {
+                unlink(temporaryURL.path)
+            }
+        }
+        let written = data.withUnsafeBytes { buffer -> Bool in
+            guard let base = buffer.baseAddress else {
+                return false
+            }
+            var consumed = 0
+            while consumed < buffer.count {
+                let result = Darwin.write(descriptor, base.advanced(by: consumed), buffer.count - consumed)
+                if result <= 0 {
+                    return false
+                }
+                consumed += result
+            }
+            return true
+        }
+        guard written,
+              fsync(descriptor) == 0,
+              rename(temporaryURL.path, recordURL.path) == 0
+        else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+        try lease.synchronize()
+        succeeded = true
+    }
+
+    private func removeStaleTemporary() throws {
+        var information = stat()
+        if lstat(temporaryURL.path, &information) != 0 {
+            if errno == ENOENT {
+                return
+            }
+            throw NativeCrashError(.storageUnsupported)
+        }
+        guard information.st_mode & S_IFMT == S_IFREG,
+              information.st_mode & 0o077 == 0,
+              unlink(temporaryURL.path) == 0
+        else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+        try lease.synchronize()
+    }
+}