@logbrew/react-native 0.1.10 → 0.1.12

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/CrashEngine.swift

@@ -0,0 +1,125 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+@preconcurrency import KSCrash
+
+enum CrashMonitor: Equatable, Hashable {
+    case machException
+    case signal
+    case cppException
+    case objectiveCException
+}
+
+struct CrashEngineConfiguration: Equatable {
+    let storageDirectory: URL
+    let maxStoredReports: Int
+    let monitors: Set<CrashMonitor>
+    let includesMemory: Bool
+    let includesQueueNames: Bool
+    let includesConsoleLog: Bool
+    let artifactIdentity: NativeArtifactIdentityValue?
+    let deletionIsExplicit: Bool
+}
+
+protocol CrashEngineDriving: AnyObject {
+    func install(configuration: CrashEngineConfiguration) throws -> any CrashReportStoring
+}
+
+protocol CrashReportStoring: AnyObject {
+    var reportIDs: [Int64] { get }
+    func report(for id: Int64) -> [String: Any]?
+    func deleteReport(with id: Int64)
+    func deleteAllReports()
+}
+
+final class ProcessCrashCaptureOwnership: @unchecked Sendable {
+    static let shared = ProcessCrashCaptureOwnership()
+
+    private let lock = NSLock()
+    private weak var owner: AnyObject?
+    private var claimed = false
+
+    func claim(_ candidate: AnyObject) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        if let owner {
+            guard owner === candidate else {
+                throw NativeCrashError(.ownershipConflict)
+            }
+            return
+        }
+        guard !claimed else {
+            throw NativeCrashError(.ownershipConflict)
+        }
+        owner = candidate
+        claimed = true
+    }
+}
+
+final class KSCrashEngineDriver: CrashEngineDriving {
+    func install(configuration: CrashEngineConfiguration) throws -> any CrashReportStoring {
+        let storeConfiguration = CrashReportStoreConfiguration()
+        storeConfiguration.appName = "logbrew-native-crash"
+        storeConfiguration.maxReportCount = configuration.maxStoredReports
+        storeConfiguration.reportCleanupPolicy = configuration.deletionIsExplicit ? .never : .always
+
+        let engineConfiguration = KSCrashConfiguration()
+        engineConfiguration.installPath = configuration.storageDirectory.path
+        engineConfiguration.reportStoreConfiguration = storeConfiguration
+        var monitors: MonitorType = []
+        if configuration.monitors.contains(.machException) {
+            monitors.insert(.machException)
+        }
+        if configuration.monitors.contains(.signal) {
+            monitors.insert(.signal)
+        }
+        if configuration.monitors.contains(.cppException) {
+            monitors.insert(.cppException)
+        }
+        if configuration.monitors.contains(.objectiveCException) {
+            monitors.insert(.nsException)
+        }
+        engineConfiguration.monitors = monitors
+        engineConfiguration.userInfoJSON = configuration.artifactIdentity?.crashUserInfoJSON
+        engineConfiguration.deadlockWatchdogInterval = 0
+        engineConfiguration.enableQueueNameSearch = configuration.includesQueueNames
+        engineConfiguration.enableMemoryIntrospection = configuration.includesMemory
+        engineConfiguration.addConsoleLogToReport = configuration.includesConsoleLog
+        engineConfiguration.printPreviousLogOnStartup = false
+        engineConfiguration.enableSigTermMonitoring = false
+
+        do {
+            try KSCrash.shared.install(with: engineConfiguration)
+        } catch {
+            throw NativeCrashError(.engineInstallFailed)
+        }
+        guard let reportStore = KSCrash.shared.reportStore else {
+            throw NativeCrashError(.engineInstallFailed)
+        }
+        return KSCrashReportStoreAdapter(store: reportStore)
+    }
+}
+
+private final class KSCrashReportStoreAdapter: CrashReportStoring {
+    private let store: CrashReportStore
+
+    init(store: CrashReportStore) {
+        self.store = store
+    }
+
+    var reportIDs: [Int64] {
+        store.reportIDs.map(\.int64Value)
+    }
+
+    func report(for id: Int64) -> [String: Any]? {
+        store.report(for: id)?.value
+    }
+
+    func deleteReport(with id: Int64) {
+        store.deleteReport(with: id)
+    }
+
+    func deleteAllReports() {
+        store.deleteAllReports()
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/CrashReportSanitizer.swift

@@ -0,0 +1,139 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import CryptoKit
+import Foundation
+
+struct CrashReportSanitizer {
+    let maxReplayBytes: Int
+    let ownerNonce: UUID
+
+    func makeRecord(reportID: Int64, rawReport: [String: Any]) throws -> NativeCrashRecord {
+        let data = try canonicalData(rawReport)
+        guard let report = rawReport["report"] as? [String: Any],
+              let rawID = report["id"] as? String,
+              let uuid = UUID(uuidString: rawID),
+              let rawTimestamp = report["timestamp"] as? String,
+              let timestamp = NativeCrashTimestamp(rawTimestamp)
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+
+        let crash = rawReport["crash"] as? [String: Any]
+        let error = crash?["error"] as? [String: Any]
+        let nativeStackFrames = NativeStackFrameSanitizer().frames(from: rawReport)
+        let artifactIdentity = try NativeArtifactIdentityValue.persistedIdentity(in: rawReport)
+        return NativeCrashRecord(
+            eventID: uuid.uuidString.lowercased(),
+            timestamp: timestamp.normalized,
+            mechanism: mechanism(error?["type"] as? String),
+            nativeStackFrames: nativeStackFrames,
+            artifactIdentity: artifactIdentity,
+            hangState: nil,
+            hangDurationMs: nil,
+            source: .engine(reportID: reportID),
+            digest: Data(SHA256.hash(data: data)),
+            ownerNonce: ownerNonce,
+        )
+    }
+
+    func digest(_ rawReport: [String: Any]) throws -> Data {
+        try Data(SHA256.hash(data: canonicalData(rawReport)))
+    }
+
+    private func canonicalData(_ rawReport: [String: Any]) throws -> Data {
+        guard JSONSerialization.isValidJSONObject(rawReport) else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        do {
+            let data = try JSONSerialization.data(withJSONObject: rawReport, options: [.sortedKeys])
+            guard data.count <= maxReplayBytes else {
+                throw NativeCrashError(.reportCorrupt)
+            }
+            return data
+        } catch let error as NativeCrashError {
+            throw error
+        } catch {
+            throw NativeCrashError(.reportCorrupt)
+        }
+    }
+
+    private func mechanism(_ rawValue: String?) -> NativeCrashMechanism {
+        switch rawValue {
+        case "signal": .signal
+        case "mach": .machException
+        case "cpp_exception": .cppException
+        case "nsexception": .objectiveCException
+        case "memory_termination": .memoryTermination
+        case "deadlock": .deadlock
+        default: .unknown
+        }
+    }
+}
+
+struct NativeCrashTimestamp: Comparable {
+    let normalized: String
+    private let wholeSecond: String
+    private let fractionalNanoseconds: String
+
+    init?(_ raw: String) {
+        guard raw.utf8.count <= 64,
+              !raw.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains),
+              let components = Self.components(in: raw)
+        else {
+            return nil
+        }
+
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime]
+        guard let date = formatter.date(from: components.wholeSecond) else {
+            return nil
+        }
+        wholeSecond = formatter.string(from: date)
+        fractionalNanoseconds = components.fractional
+            .padding(toLength: 9, withPad: "0", startingAt: 0)
+        if components.fractional.isEmpty {
+            normalized = wholeSecond
+        } else {
+            normalized = "\(wholeSecond.dropLast()).\(components.fractional)Z"
+        }
+    }
+
+    static func < (lhs: NativeCrashTimestamp, rhs: NativeCrashTimestamp) -> Bool {
+        if lhs.wholeSecond != rhs.wholeSecond {
+            return lhs.wholeSecond < rhs.wholeSecond
+        }
+        return lhs.fractionalNanoseconds < rhs.fractionalNanoseconds
+    }
+
+    static func == (lhs: NativeCrashTimestamp, rhs: NativeCrashTimestamp) -> Bool {
+        lhs.wholeSecond == rhs.wholeSecond
+            && lhs.fractionalNanoseconds == rhs.fractionalNanoseconds
+    }
+
+    private static func components(in timestamp: String) -> (wholeSecond: String, fractional: String)? {
+        guard let timeStart = timestamp.firstIndex(of: "T") else {
+            return nil
+        }
+        guard let separator = timestamp[timeStart...].firstIndex(of: ".") else {
+            return (timestamp, "")
+        }
+        let fractionalStart = timestamp.index(after: separator)
+        let suffix = timestamp[fractionalStart...]
+        let digits = suffix.prefix {
+            $0 >= "0" && $0 <= "9"
+        }
+        guard (1 ... 9).contains(digits.count),
+              let timezoneStart = timestamp.index(
+                  fractionalStart,
+                  offsetBy: digits.count,
+                  limitedBy: timestamp.endIndex,
+              )
+        else {
+            return nil
+        }
+        return (
+            String(timestamp[..<separator] + timestamp[timezoneStart...]),
+            String(digits),
+        )
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/CrashStorageDirectory.swift

@@ -0,0 +1,124 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Darwin
+import Foundation
+
+enum CrashStorageDirectory {
+    static func normalized(_ url: URL) -> URL {
+        let parent = url.deletingLastPathComponent().resolvingSymlinksInPath().standardizedFileURL
+        return parent.appendingPathComponent(url.lastPathComponent, isDirectory: true).standardizedFileURL
+    }
+
+    static func prepare(_ url: URL) throws -> CrashStorageLease {
+        let path = url.path
+        try ensurePrivateDirectory(at: url, path: path)
+        try protectDirectory(at: url, path: path)
+        return try openLease(path: path)
+    }
+
+    private static func ensurePrivateDirectory(at url: URL, path: String) throws {
+        var info = stat()
+        if lstat(path, &info) == 0 {
+            guard info.st_mode & S_IFMT == S_IFDIR,
+                  info.st_mode & S_IFMT != S_IFLNK
+            else {
+                throw NativeCrashError(.storageUnsupported)
+            }
+        } else if errno == ENOENT {
+            do {
+                try FileManager.default.createDirectory(
+                    at: url,
+                    withIntermediateDirectories: false,
+                    attributes: [.posixPermissions: NSNumber(value: 0o700)],
+                )
+            } catch {
+                throw NativeCrashError(.storageUnsupported)
+            }
+        } else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+    }
+
+    private static func protectDirectory(at url: URL, path: String) throws {
+        do {
+            var attributes: [FileAttributeKey: Any] = [.posixPermissions: NSNumber(value: 0o700)]
+            #if os(iOS) || os(tvOS) || os(watchOS)
+                attributes[.protectionKey] = FileProtectionType.completeUntilFirstUserAuthentication
+            #endif
+            try FileManager.default.setAttributes(attributes, ofItemAtPath: path)
+            var values = URLResourceValues()
+            values.isExcludedFromBackup = true
+            var mutableURL = url
+            try mutableURL.setResourceValues(values)
+        } catch {
+            throw NativeCrashError(.storageUnsupported)
+        }
+    }
+
+    private static func openLease(path: String) throws -> CrashStorageLease {
+        let descriptor = open(path, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC)
+        guard descriptor >= 0 else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+        var opened = stat()
+        var info = stat()
+        guard fchmod(descriptor, S_IRWXU) == 0,
+              fstat(descriptor, &opened) == 0,
+              lstat(path, &info) == 0,
+              opened.st_mode & S_IFMT == S_IFDIR,
+              opened.st_mode & 0o077 == 0,
+              opened.st_dev == info.st_dev,
+              opened.st_ino == info.st_ino
+        else {
+            close(descriptor)
+            throw NativeCrashError(.storageUnsupported)
+        }
+        return CrashStorageLease(
+            descriptor: descriptor,
+            path: path,
+            device: opened.st_dev,
+            inode: opened.st_ino,
+        )
+    }
+}
+
+final class CrashStorageLease: @unchecked Sendable {
+    private let descriptor: Int32
+    private let path: String
+    private let device: dev_t
+    private let inode: ino_t
+
+    init(descriptor: Int32, path: String, device: dev_t, inode: ino_t) {
+        self.descriptor = descriptor
+        self.path = path
+        self.device = device
+        self.inode = inode
+    }
+
+    deinit {
+        close(descriptor)
+    }
+
+    func verify() throws {
+        var opened = stat()
+        var current = stat()
+        guard fstat(descriptor, &opened) == 0,
+              lstat(path, &current) == 0,
+              opened.st_mode & S_IFMT == S_IFDIR,
+              opened.st_mode & 0o077 == 0,
+              opened.st_dev == device,
+              opened.st_ino == inode,
+              current.st_dev == device,
+              current.st_ino == inode
+        else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+    }
+
+    func synchronize() throws {
+        try verify()
+        guard fsync(descriptor) == 0 else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeArtifactIdentity.swift

@@ -0,0 +1,137 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+@objc(LBRNAppleNativeArtifactIdentity)
+@objcMembers
+public final class NativeArtifactIdentity: NSObject, @unchecked Sendable {
+    public let projectId: String
+    @nonobjc public let release: String
+    public let environment: String
+    public let service: String
+
+    public init(
+        projectId: String,
+        release: String,
+        environment: String,
+        service: String,
+    ) throws {
+        guard UUID(uuidString: projectId)?.uuidString.lowercased() == projectId,
+              Self.isExactContext(release),
+              Self.isExactContext(environment),
+              Self.isExactContext(service)
+        else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        self.projectId = projectId
+        self.release = release
+        self.environment = environment
+        self.service = service
+        super.init()
+    }
+
+    override public func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? NativeArtifactIdentity else {
+            return false
+        }
+        return projectId == other.projectId
+            && release == other.release
+            && environment == other.environment
+            && service == other.service
+    }
+
+    override public var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(projectId)
+        hasher.combine(release)
+        hasher.combine(environment)
+        hasher.combine(service)
+        return hasher.finalize()
+    }
+
+    override public var description: String {
+        "NativeArtifactIdentity(configured: true)"
+    }
+
+    private static func isExactContext(_ value: String) -> Bool {
+        guard (1 ... 256).contains(value.utf8.count),
+              value == value.trimmingCharacters(in: .whitespacesAndNewlines),
+              !value.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains)
+        else {
+            return false
+        }
+        return true
+    }
+}
+
+struct NativeArtifactIdentityValue: Codable, Equatable {
+    private static let reportKey = "logbrew_native_artifact_identity"
+    private static let reportFields = [
+        "environment",
+        "project_id",
+        "release",
+        "service",
+        "version",
+    ]
+
+    let projectId: String
+    let release: String
+    let environment: String
+    let service: String
+
+    init(_ identity: NativeArtifactIdentity) {
+        projectId = identity.projectId
+        release = identity.release
+        environment = identity.environment
+        service = identity.service
+    }
+
+    func validatedIdentity() throws -> NativeArtifactIdentity {
+        try NativeArtifactIdentity(
+            projectId: projectId,
+            release: release,
+            environment: environment,
+            service: service,
+        )
+    }
+
+    var crashUserInfoJSON: [String: Any] {
+        [
+            Self.reportKey: [
+                "version": 1,
+                "project_id": projectId,
+                "release": release,
+                "environment": environment,
+                "service": service,
+            ],
+        ]
+    }
+
+    static func persistedIdentity(in rawReport: [String: Any]) throws -> NativeArtifactIdentity? {
+        guard let user = rawReport["user"] as? [String: Any],
+              let persisted = user[reportKey]
+        else {
+            return nil
+        }
+        guard let values = persisted as? [String: Any],
+              values.keys.sorted() == reportFields,
+              values["version"] as? Int == 1,
+              let projectId = values["project_id"] as? String,
+              let release = values["release"] as? String,
+              let environment = values["environment"] as? String,
+              let service = values["service"] as? String
+        else {
+            throw NativeCrashError(.reportCorrupt)
+        }
+        do {
+            return try NativeArtifactIdentity(
+                projectId: projectId,
+                release: release,
+                environment: environment,
+                service: service,
+            )
+        } catch {
+            throw NativeCrashError(.reportCorrupt)
+        }
+    }
+}