@logbrew/react-native 0.1.10 → 0.1.12

package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift

@@ -0,0 +1,293 @@
+import Foundation
+
+@objc(LBRNAppleNativeDiagnostics)
+public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
+    private static let shared = LBRNAppleNativeDiagnostics()
+    private static let sdkVersion = "0.1.12"
+
+    private let lock = NSLock()
+    private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")
+    private var capture: NativeCrashCapture?
+    private var client: LogBrewClient?
+    private var transport: HTTPTransport?
+    private var installedConfiguration: InstalledConfiguration?
+
+    @objc(installWithConfiguration:)
+    public static func install(with configuration: NSDictionary) -> NSDictionary {
+        if Thread.isMainThread {
+            return shared.installOnMainThread(configuration)
+        }
+        var result: NSDictionary = ["status": "native_diagnostics_failed"]
+        DispatchQueue.main.sync {
+            result = shared.installOnMainThread(configuration)
+        }
+        return result
+    }
+
+    @objc(replayWithCompletion:)
+    public static func replay(withCompletion completion: @escaping (NSDictionary) -> Void) {
+        shared.replayQueue.async {
+            let result = shared.replayPendingReports()
+            DispatchQueue.main.async {
+                completion(result)
+            }
+        }
+    }
+
+    @objc(status)
+    public static func status() -> NSDictionary {
+        shared.currentStatus()
+    }
+
+    private func installOnMainThread(_ rawConfiguration: NSDictionary) -> NSDictionary {
+        guard let configuration = InstalledConfiguration(rawConfiguration) else {
+            return failure("native_diagnostics_invalid_configuration")
+        }
+
+        lock.lock()
+        defer { lock.unlock() }
+
+        if let installedConfiguration {
+            guard installedConfiguration == configuration else {
+                return failure("native_diagnostics_already_installed")
+            }
+            return captureStatus(status: "already_installed")
+        }
+
+        do {
+            let storageDirectory = try Self.prepareStorageDirectory(
+                projectId: configuration.projectId,
+            )
+            let identity = try NativeArtifactIdentity(
+                projectId: configuration.projectId,
+                release: configuration.release,
+                environment: configuration.environment,
+                service: configuration.service,
+            )
+            let watchdog = try configuration.hangThresholdSeconds.map {
+                try NativeHangWatchdogConfiguration(threshold: $0)
+            }
+            let nativeConfiguration = try NativeCrashConfiguration(
+                storageDirectory: storageDirectory,
+                artifactIdentity: identity,
+                hangWatchdog: watchdog,
+            )
+            let capture = NativeCrashCapture(configuration: nativeConfiguration)
+            let client = try LogBrewClient.create(
+                apiKey: configuration.apiKey,
+                sdkName: "logbrew-react-native-apple",
+                sdkVersion: Self.sdkVersion,
+            )
+            let transport = try HTTPTransport(endpoint: configuration.endpoint)
+
+            try capture.install()
+            self.capture = capture
+            self.client = client
+            self.transport = transport
+            installedConfiguration = configuration
+            return captureStatus(status: "installed")
+        } catch let error as NativeCrashError {
+            return failure(error.code.rawValue)
+        } catch {
+            return failure("native_diagnostics_failed")
+        }
+    }
+
+    private func replayPendingReports() -> NSDictionary {
+        lock.lock()
+        guard let capture, let client, let transport else {
+            lock.unlock()
+            return failure("native_diagnostics_not_installed")
+        }
+        lock.unlock()
+
+        do {
+            let result = try capture.replayPendingReports(in: client, transport: transport)
+            return [
+                "acknowledged": result.acknowledged,
+                "attempted": result.attempted,
+                "discarded": result.discarded,
+                "pending": result.pending,
+                "status": "replayed",
+            ]
+        } catch let error as NativeCrashError {
+            return failure(error.code.rawValue)
+        } catch {
+            return failure("native_diagnostics_failed")
+        }
+    }
+
+    private func currentStatus() -> NSDictionary {
+        lock.lock()
+        defer { lock.unlock() }
+        guard capture != nil else {
+            return [
+                "acknowledged": 0,
+                "discarded": 0,
+                "lifecycle": "idle",
+                "pending": 0,
+                "status": "not_installed",
+            ]
+        }
+        return captureStatus(status: "ready")
+    }
+
+    private func captureStatus(status: String) -> NSDictionary {
+        guard let capture else {
+            return failure("native_diagnostics_not_installed")
+        }
+        do {
+            let value = try capture.status()
+            return [
+                "acknowledged": value.acknowledged,
+                "discarded": value.discarded,
+                "lifecycle": value.lifecycle.logBrewName,
+                "pending": value.pending,
+                "status": status,
+            ]
+        } catch let error as NativeCrashError {
+            return failure(error.code.rawValue)
+        } catch {
+            return failure("native_diagnostics_failed")
+        }
+    }
+
+    private func failure(_ code: String) -> NSDictionary {
+        ["code": code, "status": "error"]
+    }
+
+    private static func prepareStorageDirectory(projectId: String) throws -> URL {
+        let fileManager = FileManager.default
+        guard let applicationSupport = fileManager.urls(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask,
+        ).first else {
+            throw NativeCrashError(.storageUnsupported)
+        }
+        do {
+            try fileManager.createDirectory(
+                at: applicationSupport,
+                withIntermediateDirectories: true,
+                attributes: nil,
+            )
+        } catch {
+            throw NativeCrashError(.storageUnsupported)
+        }
+        return applicationSupport.appendingPathComponent(
+            "LogBrewAppleDiagnostics-\(projectId)",
+            isDirectory: true,
+        )
+    }
+}
+
+private struct InstalledConfiguration: Equatable {
+    private static let allowedKeys = Set([
+        "apiKey",
+        "endpoint",
+        "environment",
+        "fatalHandlerOwnership",
+        "hangThresholdSeconds",
+        "projectId",
+        "release",
+        "service",
+    ])
+
+    let apiKey: String
+    let endpoint: URL
+    let environment: String
+    let hangThresholdSeconds: TimeInterval?
+    let projectId: String
+    let release: String
+    let service: String
+
+    init?(_ values: NSDictionary) {
+        let keys = Set(values.allKeys.compactMap { $0 as? String })
+        guard keys.count == values.count,
+              keys.isSubset(of: Self.allowedKeys),
+              values["fatalHandlerOwnership"] as? String == "logbrew",
+              let apiKey = Self.exactString(values["apiKey"], maxBytes: 4096),
+              let projectId = Self.exactString(values["projectId"], maxBytes: 64),
+              let release = Self.exactString(values["release"]),
+              let environment = Self.exactString(values["environment"]),
+              let service = Self.exactString(values["service"])
+        else {
+            return nil
+        }
+
+        let endpoint: URL
+        if let endpointValue = values["endpoint"] {
+            guard let parsedEndpoint = Self.exactDeliveryEndpoint(endpointValue)
+            else {
+                return nil
+            }
+            endpoint = parsedEndpoint
+        } else {
+            endpoint = HTTPTransport.defaultEndpoint
+        }
+
+        let hangThresholdSeconds: TimeInterval?
+        if let thresholdValue = values["hangThresholdSeconds"] {
+            guard let number = thresholdValue as? NSNumber,
+                  CFGetTypeID(number) != CFBooleanGetTypeID(),
+                  number.doubleValue.isFinite,
+                  (1 ... 30).contains(number.doubleValue)
+            else {
+                return nil
+            }
+            hangThresholdSeconds = number.doubleValue
+        } else {
+            hangThresholdSeconds = nil
+        }
+
+        self.apiKey = apiKey
+        self.endpoint = endpoint
+        self.environment = environment
+        self.hangThresholdSeconds = hangThresholdSeconds
+        self.projectId = projectId
+        self.release = release
+        self.service = service
+    }
+
+    private static func exactString(_ value: Any?, maxBytes: Int = 256) -> String? {
+        guard let value = value as? String,
+              (1 ... maxBytes).contains(value.utf8.count),
+              value == value.trimmingCharacters(in: .whitespacesAndNewlines),
+              !value.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains)
+        else {
+            return nil
+        }
+        return value
+    }
+
+    private static func exactDeliveryEndpoint(_ value: Any?) -> URL? {
+        guard let endpoint = exactString(value, maxBytes: 2_048),
+              let components = URLComponents(string: endpoint),
+              components.scheme == "https",
+              components.host?.isEmpty == false,
+              components.path.starts(with: "/"),
+              components.user == nil,
+              components.password == nil,
+              components.query == nil,
+              components.fragment == nil,
+              let url = components.url,
+              url.absoluteString == endpoint,
+              url.standardized.absoluteString == endpoint
+        else {
+            return nil
+        }
+        return url
+    }
+}
+
+private extension NativeCrashLifecycleState {
+    var logBrewName: String {
+        switch self {
+        case .idle: "idle"
+        case .installed: "installed"
+        case .replaying: "replaying"
+        case .failed: "failed"
+        case .stopped: "stopped"
+        @unknown default: "unknown"
+        }
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/AutomaticTelemetryContext.swift

@@ -0,0 +1,72 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+func automaticTelemetryContext() -> TelemetryContext {
+    let operatingSystem = ProcessInfo.processInfo.operatingSystemVersion
+    let version = "\(operatingSystem.majorVersion).\(operatingSystem.minorVersion).\(operatingSystem.patchVersion)"
+    let application = automaticApplicationContext()
+    let architecture = automaticArchitecture()
+    return TelemetryContext(
+        resource: TelemetryResource(
+            runtime: TelemetryNamedVersion(name: "swift"),
+            operatingSystem: TelemetryOperatingSystem(name: automaticOperatingSystemName(), version: version),
+            device: architecture.map { TelemetryDevice(architecture: $0) },
+            application: application,
+        ),
+    )
+}
+
+private func automaticOperatingSystemName() -> String {
+    #if os(iOS)
+        "iOS"
+    #elseif os(macOS)
+        "macOS"
+    #elseif os(tvOS)
+        "tvOS"
+    #elseif os(watchOS)
+        "watchOS"
+    #elseif os(visionOS)
+        "visionOS"
+    #else
+        "unknown"
+    #endif
+}
+
+private func automaticArchitecture() -> String? {
+    #if arch(arm64)
+        "arm64"
+    #elseif arch(x86_64)
+        "x86_64"
+    #elseif arch(arm)
+        "arm"
+    #elseif arch(i386)
+        "i386"
+    #else
+        nil
+    #endif
+}
+
+private func automaticApplicationContext() -> TelemetryApplication? {
+    let bundle = Bundle.main
+    let name = automaticBundleValue(bundle, keys: ["CFBundleDisplayName", "CFBundleName"])
+    let version = automaticBundleValue(bundle, keys: ["CFBundleShortVersionString"])
+    let build = automaticBundleValue(bundle, keys: ["CFBundleVersion"])
+    guard name != nil || version != nil || build != nil else {
+        return nil
+    }
+    return TelemetryApplication(name: name, version: version, build: build)
+}
+
+private func automaticBundleValue(_ bundle: Bundle, keys: [String]) -> String? {
+    for key in keys {
+        guard let candidate = bundle.object(forInfoDictionaryKey: key) as? String else {
+            continue
+        }
+        let normalized = candidate.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !normalized.isEmpty, normalized.count <= 256, !containsForbiddenControl(normalized) {
+            return normalized
+        }
+    }
+    return nil
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryEngine.swift

@@ -0,0 +1,270 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+final class DeliveryEngine: @unchecked Sendable {
+    static let maxQueuedEvents = 1000
+    static let maxQueuedBytes = 4 * 1024 * 1024
+    static let maxRequestEvents = 100
+    static let maxRequestBytes = 256 * 1024
+    static let maxScheduleDelay: TimeInterval = 24 * 60 * 60
+
+    struct QueuedEvent {
+        let event: Event
+        let encodedBytes: Int
+        let durableRecordName: String?
+    }
+
+    struct FrozenPrefix {
+        let count: Int
+        let bytes: Int
+        let body: Data
+        let eventIDs: [String]
+        let durableRecordNames: [String]
+    }
+
+    enum AttemptResult {
+        case accepted(statusCode: Int, attempts: Int)
+        case retryable(attempts: Int, error: SdkError)
+        case terminal(reason: DeliveryPauseReason, attempts: Int, error: SdkError)
+
+        var attempts: Int {
+            switch self {
+            case let .accepted(_, attempts), let .retryable(attempts, _), let .terminal(_, attempts, _):
+                attempts
+            }
+        }
+    }
+
+    let apiKey: String
+    let sdk: SDKInfo
+    let maxRetries: Int
+    let stateLock = NSLock()
+    let flushLock = NSLock()
+    let storageLock = NSLock()
+    var queue: [QueuedEvent] = []
+    var queuedBytes = 0
+    var frozenPrefix: FrozenPrefix?
+    var durableStore: DurableDeliveryStore?
+    var durableParent: URL?
+    var closed = false
+
+    var state: DeliveryState = .manual
+    var lastOutcome: DeliveryOutcome = .none
+    var pauseReason: DeliveryPauseReason = .none
+    var inFlight = false
+    var acceptedEvents = 0
+    var droppedEvents = 0
+    var deliveryAttempts = 0
+    var consecutiveFailures = 0
+
+    var automaticTransport: (any Transport)?
+    var automaticOptions: AutomaticDeliveryOptions?
+    var schedulerQueue: DispatchQueue?
+    var schedulerTimer: DispatchSourceTimer?
+    var nextWakeNanoseconds: UInt64?
+    var generation: UInt64 = 0
+    var retryAttempt = 0
+    let schedulerKey = DispatchSpecificKey<UInt8>()
+
+    init(apiKey: String, sdk: SDKInfo, maxRetries: Int) {
+        self.apiKey = apiKey
+        self.sdk = sdk
+        self.maxRetries = max(0, maxRetries)
+    }
+
+    deinit {
+        schedulerTimer?.setEventHandler {}
+        schedulerTimer?.cancel()
+    }
+
+    func pendingEvents() -> Int {
+        withStateLock { queue.count }
+    }
+
+    func previewJSON() throws -> String {
+        let events = withStateLock { queue.map(\.event) }
+        let data = try encodeBatch(events)
+        guard let json = String(data: data, encoding: .utf8) else {
+            throw SdkError(code: "encoding_error", message: "event batch was not valid UTF-8")
+        }
+        return json
+    }
+
+    func health() -> DeliveryHealth {
+        withStateLock {
+            DeliveryHealth(
+                state: state,
+                queuedEvents: queue.count,
+                queuedBytes: queuedBytes,
+                inFlight: inFlight,
+                acceptedEvents: acceptedEvents,
+                droppedEvents: droppedEvents,
+                deliveryAttempts: deliveryAttempts,
+                consecutiveFailures: consecutiveFailures,
+                lastOutcome: lastOutcome,
+                pauseReason: pauseReason,
+            )
+        }
+    }
+
+    func startAutomaticDelivery(transport: any Transport, options: AutomaticDeliveryOptions) throws {
+        try validate(options)
+
+        storageLock.lock()
+        stateLock.lock()
+        if closed || state == .closed || state == .shuttingDown {
+            stateLock.unlock()
+            storageLock.unlock()
+            throw SdkError(code: "shutdown_error", message: "client is already shut down")
+        }
+        if automaticTransport != nil {
+            stateLock.unlock()
+            storageLock.unlock()
+            throw SdkError(code: "configuration_error", message: "automatic delivery is already running")
+        }
+        if state == .paused, pauseReason == .storage {
+            stateLock.unlock()
+            storageLock.unlock()
+            throw SdkError(code: "storage_corrupt", message: "durable delivery data requires explicit recovery")
+        }
+        generation &+= 1
+        let ownerGeneration = generation
+        let scheduler = DispatchQueue(label: "co.logbrew.swift.delivery", qos: .utility)
+        scheduler.setSpecific(key: schedulerKey, value: 1)
+        let timer = DispatchSource.makeTimerSource(queue: scheduler)
+        timer.setEventHandler { [weak self] in
+            self?.timerFired(generation: ownerGeneration)
+        }
+        automaticTransport = transport
+        automaticOptions = options
+        schedulerQueue = scheduler
+        schedulerTimer = timer
+        state = .running
+        pauseReason = .none
+        retryAttempt = 0
+        let shouldSchedule = scheduleLiveQueueLocked()
+        stateLock.unlock()
+        storageLock.unlock()
+
+        timer.resume()
+        if shouldSchedule {
+            scheduleTimerUpdate()
+        }
+    }
+
+    func recoverAutomaticDelivery() throws {
+        stateLock.lock()
+        guard automaticTransport != nil, automaticOptions != nil else {
+            stateLock.unlock()
+            throw SdkError(code: "configuration_error", message: "automatic delivery is not running")
+        }
+        guard state == .paused else {
+            stateLock.unlock()
+            return
+        }
+        if pauseReason == .storage {
+            stateLock.unlock()
+            throw SdkError(code: "storage_corrupt", message: "durable delivery data requires explicit recovery")
+        }
+        state = .running
+        pauseReason = .none
+        retryAttempt = 0
+        consecutiveFailures = 0
+        nextWakeNanoseconds = nil
+        let shouldSchedule = scheduleLiveQueueLocked()
+        stateLock.unlock()
+        if shouldSchedule {
+            scheduleTimerUpdate()
+        }
+    }
+
+    func stopAutomaticDelivery() {
+        let timer: DispatchSourceTimer?
+        let scheduler: DispatchQueue?
+        storageLock.lock()
+        stateLock.lock()
+        generation &+= 1
+        timer = schedulerTimer
+        scheduler = schedulerQueue
+        schedulerTimer = nil
+        schedulerQueue = nil
+        nextWakeNanoseconds = nil
+        automaticTransport = nil
+        automaticOptions = nil
+        retryAttempt = 0
+        pauseReason = .none
+        if !closed, state != .shuttingDown {
+            state = .manual
+        }
+        stateLock.unlock()
+        storageLock.unlock()
+
+        timer?.setEventHandler {}
+        timer?.cancel()
+        if DispatchQueue.getSpecific(key: schedulerKey) == nil {
+            scheduler?.sync {}
+            flushLock.lock()
+            flushLock.unlock()
+        }
+    }
+
+    func flush(transport: any Transport) throws -> TransportResponse {
+        try withManualDelivery {
+            try flushAll(transport: transport)
+        }
+    }
+
+    func flushEvent(_ eventID: String, transport: any Transport) throws -> Bool {
+        try withManualDelivery {
+            try flushThroughEvent(eventID, transport: transport)
+        }
+    }
+
+    private func withManualDelivery<Result>(
+        _ operation: () throws -> Result,
+    ) throws -> Result {
+        try prepareManualOperation()
+        flushLock.lock()
+        defer {
+            flushLock.unlock()
+            rescheduleAfterManualOperation()
+        }
+        return try operation()
+    }
+
+    func flushOwnedTransport() throws -> TransportResponse {
+        let transport = try ownedTransport()
+        return try flush(transport: transport)
+    }
+
+    func shutdown(transport: any Transport) throws -> TransportResponse {
+        let priorAutomatic = try beginShutdown()
+        flushLock.lock()
+        do {
+            let response = try flushAll(transport: transport)
+            stateLock.lock()
+            closed = true
+            state = .closed
+            inFlight = false
+            stateLock.unlock()
+            flushLock.unlock()
+            finishStopping(timer: priorAutomatic.timer, scheduler: priorAutomatic.scheduler)
+            return response
+        } catch {
+            stateLock.lock()
+            state = pauseReason == .storage ? .paused : .manual
+            closed = false
+            inFlight = false
+            stateLock.unlock()
+            flushLock.unlock()
+            finishStopping(timer: priorAutomatic.timer, scheduler: priorAutomatic.scheduler)
+            throw error
+        }
+    }
+
+    func shutdownOwnedTransport() throws -> TransportResponse {
+        let transport = try ownedTransport()
+        return try shutdown(transport: transport)
+    }
+}