@logbrew/react-native 0.1.11 → 0.1.13

package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryEngineQueue.swift

@@ -0,0 +1,343 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+extension DeliveryEngine {
+    func enqueue(_ event: Event) throws {
+        let eventBytes = try encodeEvent(event).count
+        let singleRequestBytes = try encodeBatch([event]).count
+        var shouldSchedule = false
+        var admissionError: SdkError?
+        var durableRecordName: String?
+
+        storageLock.lock()
+        defer { storageLock.unlock() }
+        stateLock.lock()
+        if closed || state == .shuttingDown || state == .closed {
+            admissionError = SdkError(code: "shutdown_error", message: "client is already shut down")
+        } else if state == .paused, pauseReason == .storage {
+            admissionError = SdkError(
+                code: "storage_corrupt",
+                message: "durable delivery data requires explicit recovery",
+            )
+        } else if singleRequestBytes > Self.maxRequestBytes {
+            droppedEvents += 1
+            lastOutcome = .dropped
+            admissionError = SdkError(code: "event_too_large", message: "event exceeds the delivery request byte limit")
+        } else if queue.count >= Self.maxQueuedEvents || queuedBytes > Self.maxQueuedBytes - eventBytes {
+            droppedEvents += 1
+            lastOutcome = .dropped
+            admissionError = SdkError(code: "queue_full", message: "delivery queue capacity exceeded")
+        } else {
+            let store = durableStore
+            stateLock.unlock()
+            do {
+                durableRecordName = try store?.append(event, encodedBytes: eventBytes)
+            } catch {
+                recordStorageFailure()
+                throw storageError(error)
+            }
+            stateLock.lock()
+            queue.append(
+                QueuedEvent(
+                    event: event,
+                    encodedBytes: eventBytes,
+                    durableRecordName: durableRecordName,
+                ),
+            )
+            queuedBytes += eventBytes
+            shouldSchedule = scheduleCaptureLocked()
+        }
+        stateLock.unlock()
+
+        if shouldSchedule {
+            scheduleTimerUpdate()
+        }
+        if let admissionError {
+            throw admissionError
+        }
+    }
+
+    func flushAll(transport: any Transport) throws -> TransportResponse {
+        var totalAttempts = 0
+        var statusCode = 204
+
+        while let prefix = try freezePrefix() {
+            let response = try deliver(prefix, transport: transport)
+            totalAttempts += response.attempts
+            statusCode = response.statusCode
+        }
+
+        return TransportResponse(statusCode: statusCode, attempts: totalAttempts)
+    }
+
+    func flushThroughEvent(
+        _ eventID: String,
+        transport: any Transport,
+    ) throws -> Bool {
+        guard withStateLock({ queue.contains { $0.event.id == eventID } }) else {
+            return false
+        }
+        while let prefix = try freezePrefix() {
+            let containsEvent = prefix.eventIDs.contains(eventID)
+            _ = try deliver(prefix, transport: transport)
+            if containsEvent {
+                return true
+            }
+        }
+        return false
+    }
+
+    private func deliver(
+        _ prefix: FrozenPrefix,
+        transport: any Transport,
+    ) throws -> TransportResponse {
+        var totalAttempts = 0
+        for attemptIndex in 0 ... maxRetries {
+            let result = attempt(transport: transport, prefix: prefix)
+            totalAttempts += result.attempts
+            recordManualAttempts(result.attempts)
+            switch result {
+            case let .accepted(status, _):
+                try acknowledge(prefix)
+                return TransportResponse(statusCode: status, attempts: totalAttempts)
+            case .retryable where attemptIndex < maxRetries:
+                continue
+            case let .retryable(_, error):
+                recordManualFailure(outcome: .retryableFailure, pauseReason: .retryExhausted)
+                throw error
+            case let .terminal(reason, _, error):
+                recordManualFailure(outcome: .terminalFailure, pauseReason: reason)
+                throw error
+            }
+        }
+        throw SdkError(code: "transport_error", message: "exhausted retries")
+    }
+
+    func freezePrefix() throws -> FrozenPrefix? {
+        storageLock.lock()
+        defer { storageLock.unlock() }
+
+        stateLock.lock()
+        if let frozenPrefix {
+            inFlight = true
+            stateLock.unlock()
+            return frozenPrefix
+        }
+        guard !queue.isEmpty else {
+            stateLock.unlock()
+            return nil
+        }
+        let queueSnapshot = queue
+        let store = durableStore
+        stateLock.unlock()
+
+        let prefix = try makePrefix(queueSnapshot: queueSnapshot, store: store)
+        stateLock.lock()
+        frozenPrefix = prefix
+        inFlight = true
+        stateLock.unlock()
+        return prefix
+    }
+
+    private func makePrefix(
+        queueSnapshot: [QueuedEvent],
+        store: DurableDeliveryStore?,
+    ) throws -> FrozenPrefix {
+        var selected: [Event] = []
+        var body = Data()
+        for queuedEvent in queueSnapshot.prefix(Self.maxRequestEvents) {
+            let candidate = selected + [queuedEvent.event]
+            let candidateBody = try encodeBatch(candidate)
+            if candidateBody.count > Self.maxRequestBytes {
+                break
+            }
+            selected = candidate
+            body = candidateBody
+        }
+        guard !selected.isEmpty else {
+            throw SdkError(code: "event_too_large", message: "event exceeds the delivery request byte limit")
+        }
+        let selectedQueue = Array(queueSnapshot.prefix(selected.count))
+        let prefixBytes = selectedQueue.reduce(0) { $0 + $1.encodedBytes }
+        let recordNames = selectedQueue.compactMap(\.durableRecordName)
+        if let store {
+            guard recordNames.count == selected.count else {
+                recordStorageFailure()
+                throw storageError(DurableStoreFailure.corrupt)
+            }
+            do {
+                try store.persistPrefix(body: body, eventRecordNames: recordNames, encodedBytes: prefixBytes)
+            } catch {
+                recordStorageFailure()
+                throw storageError(error)
+            }
+        }
+        return FrozenPrefix(
+            count: selected.count,
+            bytes: prefixBytes,
+            body: body,
+            eventIDs: selected.map(\.id),
+            durableRecordNames: recordNames,
+        )
+    }
+
+    func acknowledge(_ prefix: FrozenPrefix) throws {
+        do {
+            try acknowledgeDurableFiles(prefix)
+        } catch {
+            recordStorageFailure()
+            throw error
+        }
+        stateLock.lock()
+        acknowledgeLocked(prefix)
+        acceptedEvents += prefix.count
+        consecutiveFailures = 0
+        lastOutcome = .accepted
+        stateLock.unlock()
+    }
+
+    func acknowledgeDurableFiles(_ prefix: FrozenPrefix) throws {
+        storageLock.lock()
+        defer { storageLock.unlock() }
+        let store = withStateLock { durableStore }
+        guard let store else {
+            return
+        }
+        do {
+            try store.acknowledge(body: prefix.body, eventRecordNames: prefix.durableRecordNames)
+        } catch {
+            throw storageError(error)
+        }
+    }
+
+    func acknowledgeLocked(_ prefix: FrozenPrefix) {
+        guard frozenPrefix?.body == prefix.body, queue.count >= prefix.count else {
+            return
+        }
+        queue.removeFirst(prefix.count)
+        queuedBytes -= prefix.bytes
+        frozenPrefix = nil
+        inFlight = false
+        retryAttempt = 0
+    }
+
+    func attempt(transport: any Transport, prefix: FrozenPrefix) -> AttemptResult {
+        do {
+            let response = try transport.send(apiKey: apiKey, body: prefix.body)
+            return classify(response)
+        } catch let transportError as TransportError {
+            let error = SdkError(code: transportError.code, message: transportError.message)
+            if transportError.retryable {
+                return .retryable(attempts: 1, error: error)
+            }
+            return .terminal(reason: .nonRetryable, attempts: 1, error: error)
+        } catch {
+            return .terminal(
+                reason: .nonRetryable,
+                attempts: 1,
+                error: SdkError(code: "transport_error", message: "unexpected transport response"),
+            )
+        }
+    }
+
+    private func classify(_ response: TransportResponse) -> AttemptResult {
+        guard response.attempts > 0 else {
+            return .terminal(
+                reason: .nonRetryable,
+                attempts: 1,
+                error: SdkError(code: "transport_error", message: "unexpected transport response"),
+            )
+        }
+        let attempts = max(1, response.attempts)
+        if (200 ..< 300).contains(response.statusCode) {
+            return .accepted(statusCode: response.statusCode, attempts: attempts)
+        }
+        let error = transportError(statusCode: response.statusCode)
+        if response.statusCode == 408 || response.statusCode >= 500 {
+            return .retryable(attempts: attempts, error: error)
+        }
+        return .terminal(reason: pauseReason(for: response.statusCode), attempts: attempts, error: error)
+    }
+
+    private func transportError(statusCode: Int) -> SdkError {
+        if statusCode == 401 {
+            return SdkError(code: "unauthenticated", message: "transport rejected the API key")
+        }
+        return SdkError(code: "transport_error", message: "unexpected transport status \(statusCode)")
+    }
+
+    private func pauseReason(for statusCode: Int) -> DeliveryPauseReason {
+        switch statusCode {
+        case 401, 403:
+            .authentication
+        case 429:
+            .quota
+        case 400, 404, 409, 413, 422:
+            .validation
+        default:
+            .nonRetryable
+        }
+    }
+
+    func recordManualFailure(outcome: DeliveryOutcome, pauseReason reason: DeliveryPauseReason) {
+        stateLock.lock()
+        inFlight = false
+        consecutiveFailures += 1
+        lastOutcome = outcome
+        if automaticTransport != nil, state != .shuttingDown, state != .closed {
+            state = .paused
+            pauseReason = reason
+            nextWakeNanoseconds = nil
+        }
+        stateLock.unlock()
+    }
+
+    private func recordManualAttempts(_ attempts: Int) {
+        stateLock.lock()
+        deliveryAttempts += attempts
+        stateLock.unlock()
+    }
+
+    func encodeEvent(_ event: Event) throws -> Data {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+        return try encoder.encode(event)
+    }
+
+    func encodeBatch(_ events: [Event]) throws -> Data {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        return try encoder.encode(EventBatch(sdk: sdk, events: events))
+    }
+
+    func withStateLock<T>(_ operation: () -> T) -> T {
+        stateLock.lock()
+        defer { stateLock.unlock() }
+        return operation()
+    }
+
+    func recordStorageFailure() {
+        stateLock.lock()
+        inFlight = false
+        state = .paused
+        pauseReason = .storage
+        lastOutcome = .terminalFailure
+        consecutiveFailures += 1
+        nextWakeNanoseconds = nil
+        stateLock.unlock()
+    }
+
+    func storageError(_ error: Error) -> SdkError {
+        if let failure = error as? DurableStoreFailure, failure == .corrupt {
+            return SdkError(code: "storage_corrupt", message: "durable delivery data requires explicit recovery")
+        }
+        if let failure = error as? DurableStoreFailure, failure == .capacity {
+            return SdkError(code: "queue_full", message: "durable delivery capacity exceeded")
+        }
+        if let failure = error as? DurableStoreFailure, failure == .owned {
+            return SdkError(code: "storage_error", message: "durable delivery storage is already in use")
+        }
+        return SdkError(code: "storage_error", message: "durable delivery storage is unavailable")
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryLifecycle.swift

@@ -0,0 +1,70 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public enum DeliveryState: String, Codable, Sendable {
+    case manual
+    case running
+    case retrying
+    case paused
+    case shuttingDown = "shutting_down"
+    case closed
+}
+
+public enum DeliveryOutcome: String, Codable, Sendable {
+    case none
+    case accepted
+    case retryableFailure = "retryable_failure"
+    case terminalFailure = "terminal_failure"
+    case dropped
+}
+
+public enum DeliveryPauseReason: String, Codable, Sendable {
+    case none
+    case authentication
+    case quota
+    case validation
+    case nonRetryable = "non_retryable"
+    case retryExhausted = "retry_exhausted"
+    case storage
+}
+
+public struct DurableDeliveryOptions: Equatable, Sendable {
+    public let directory: URL
+
+    public init(directory: URL) {
+        self.directory = directory
+    }
+}
+
+public struct AutomaticDeliveryOptions: Equatable, Sendable {
+    public let interval: TimeInterval
+    public let threshold: Int
+    public let retryBaseDelay: TimeInterval
+    public let maxRetryDelay: TimeInterval
+
+    public init(
+        interval: TimeInterval = 5,
+        threshold: Int = 100,
+        retryBaseDelay: TimeInterval = 0.25,
+        maxRetryDelay: TimeInterval = 30,
+    ) {
+        self.interval = interval
+        self.threshold = threshold
+        self.retryBaseDelay = retryBaseDelay
+        self.maxRetryDelay = maxRetryDelay
+    }
+}
+
+public struct DeliveryHealth: Codable, Equatable, Sendable {
+    public let state: DeliveryState
+    public let queuedEvents: Int
+    public let queuedBytes: Int
+    public let inFlight: Bool
+    public let acceptedEvents: Int
+    public let droppedEvents: Int
+    public let deliveryAttempts: Int
+    public let consecutiveFailures: Int
+    public let lastOutcome: DeliveryOutcome
+    public let pauseReason: DeliveryPauseReason
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/DurableDeliveryStore.swift

@@ -0,0 +1,258 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+enum DurableStoreFailure: Equatable, Error {
+    case capacity
+    case corrupt
+    case invalidLocation
+    case inputOutput
+    case owned
+}
+
+final class DurableDeliveryStore: @unchecked Sendable {
+    static let directoryName = "logbrew-delivery-v1"
+
+    struct RecoveredEvent {
+        let event: Event
+        let encodedBytes: Int
+        let recordName: String
+    }
+
+    struct RecoveredPrefix {
+        let body: Data
+        let eventRecordNames: [String]
+        let encodedBytes: Int
+    }
+
+    struct Recovery {
+        let events: [RecoveredEvent]
+        let prefix: RecoveredPrefix?
+    }
+
+    struct EventRecord: Codable {
+        let version: Int
+        let sequence: UInt64
+        let sdk: SDKInfo
+        let encodedBytes: Int
+        let checksum: String
+        let event: Event
+    }
+
+    struct PrefixRecord: Codable {
+        let version: Int
+        let sdk: SDKInfo
+        let eventRecordNames: [String]
+        let encodedBytes: Int
+        let body: Data
+    }
+
+    static let version = 1
+    static let prefixName = "frozen-prefix.json"
+    static let lockName = ".lock"
+    static let maxEventRecordBytes = DeliveryEngine.maxRequestBytes * 2
+    static let maxPrefixRecordBytes = DeliveryEngine.maxRequestBytes * 2
+
+    private let fileManager: FileManager
+    private let directory: URL
+    private let sdk: SDKInfo
+    private let lockHandle: FileHandle
+    private var recoveredEvents: [RecoveredEvent]
+    private var recoveredPrefix: RecoveredPrefix?
+    private var nextSequence: UInt64
+    private var failed = false
+
+    init(parent: URL, sdk: SDKInfo, fileManager: FileManager = .default) throws {
+        self.fileManager = fileManager
+        self.sdk = sdk
+        directory = parent.appendingPathComponent(Self.directoryName, isDirectory: true)
+
+        try Self.validateParent(parent, fileManager: fileManager)
+        try Self.prepareOwnedDirectory(directory, fileManager: fileManager)
+        lockHandle = try Self.acquireLock(in: directory, fileManager: fileManager)
+
+        do {
+            let recovery = try Self.loadRecovery(from: directory, sdk: sdk, fileManager: fileManager)
+            recoveredEvents = recovery.events
+            recoveredPrefix = recovery.prefix
+            if let last = recovery.events.last {
+                let lastSequence = try Self.sequence(from: last)
+                guard lastSequence < UInt64.max else {
+                    throw DurableStoreFailure.corrupt
+                }
+                nextSequence = lastSequence + 1
+            } else {
+                nextSequence = 1
+            }
+        } catch {
+            Self.releaseLock(lockHandle)
+            throw error
+        }
+    }
+
+    deinit {
+        Self.releaseLock(lockHandle)
+    }
+
+    func recovery() -> Recovery {
+        Recovery(events: recoveredEvents, prefix: recoveredPrefix)
+    }
+
+    func append(_ event: Event, encodedBytes: Int) throws -> String {
+        try requireHealthy()
+        guard recoveredEvents.count < DeliveryEngine.maxQueuedEvents,
+              recoveredEvents.reduce(0, { $0 + $1.encodedBytes }) <= DeliveryEngine.maxQueuedBytes - encodedBytes
+        else {
+            throw DurableStoreFailure.capacity
+        }
+        guard nextSequence < UInt64.max else {
+            throw DurableStoreFailure.corrupt
+        }
+        let name = Self.eventName(sequence: nextSequence)
+        let eventData = try Self.encodeEvent(event)
+        guard eventData.count == encodedBytes else {
+            throw DurableStoreFailure.corrupt
+        }
+        let record = EventRecord(
+            version: Self.version,
+            sequence: nextSequence,
+            sdk: sdk,
+            encodedBytes: encodedBytes,
+            checksum: Self.checksum(eventData),
+            event: event,
+        )
+        let data = try Self.encode(record)
+        guard data.count <= Self.maxEventRecordBytes else {
+            throw DurableStoreFailure.capacity
+        }
+        do {
+            try write(data, named: name)
+        } catch {
+            failed = true
+            throw error
+        }
+        recoveredEvents.append(RecoveredEvent(event: event, encodedBytes: encodedBytes, recordName: name))
+        nextSequence += 1
+        return name
+    }
+
+    func appendExisting(_ events: [(event: Event, encodedBytes: Int)]) throws -> [String] {
+        guard recoveredEvents.isEmpty, recoveredPrefix == nil else {
+            throw DurableStoreFailure.owned
+        }
+        var names: [String] = []
+        do {
+            for item in events {
+                try names.append(append(item.event, encodedBytes: item.encodedBytes))
+            }
+            return names
+        } catch {
+            for name in names {
+                try? fileManager.removeItem(at: directory.appendingPathComponent(name, isDirectory: false))
+            }
+            recoveredEvents.removeAll()
+            recoveredPrefix = nil
+            nextSequence = 1
+            throw error
+        }
+    }
+
+    func persistPrefix(body: Data, eventRecordNames: [String], encodedBytes: Int) throws {
+        try requireHealthy()
+        guard !eventRecordNames.isEmpty,
+              eventRecordNames.count <= DeliveryEngine.maxRequestEvents,
+              body.count <= DeliveryEngine.maxRequestBytes,
+              recoveredEvents.prefix(eventRecordNames.count).map(\.recordName) == eventRecordNames
+        else {
+            throw DurableStoreFailure.corrupt
+        }
+        if let recoveredPrefix {
+            guard recoveredPrefix.body == body,
+                  recoveredPrefix.eventRecordNames == eventRecordNames,
+                  recoveredPrefix.encodedBytes == encodedBytes
+            else {
+                throw DurableStoreFailure.corrupt
+            }
+            return
+        }
+        let record = PrefixRecord(
+            version: Self.version,
+            sdk: sdk,
+            eventRecordNames: eventRecordNames,
+            encodedBytes: encodedBytes,
+            body: body,
+        )
+        let data = try Self.encode(record)
+        guard data.count <= Self.maxPrefixRecordBytes else {
+            throw DurableStoreFailure.capacity
+        }
+        do {
+            try write(data, named: Self.prefixName)
+        } catch {
+            failed = true
+            throw error
+        }
+        recoveredPrefix = RecoveredPrefix(
+            body: body,
+            eventRecordNames: eventRecordNames,
+            encodedBytes: encodedBytes,
+        )
+    }
+
+    func acknowledge(body: Data, eventRecordNames: [String]) throws {
+        try requireHealthy()
+        guard let prefix = recoveredPrefix,
+              prefix.body == body,
+              prefix.eventRecordNames == eventRecordNames,
+              recoveredEvents.prefix(eventRecordNames.count).map(\.recordName) == eventRecordNames
+        else {
+            throw DurableStoreFailure.corrupt
+        }
+        do {
+            try fileManager.removeItem(at: directory.appendingPathComponent(Self.prefixName, isDirectory: false))
+            for name in eventRecordNames {
+                try fileManager.removeItem(at: directory.appendingPathComponent(name, isDirectory: false))
+            }
+        } catch {
+            failed = true
+            throw DurableStoreFailure.inputOutput
+        }
+        recoveredEvents.removeFirst(eventRecordNames.count)
+        recoveredPrefix = nil
+    }
+
+    static func purge(parent: URL, fileManager: FileManager = .default) throws {
+        try validateParent(parent, fileManager: fileManager)
+        let directory = parent.appendingPathComponent(directoryName, isDirectory: true)
+        guard fileManager.fileExists(atPath: directory.path) else {
+            return
+        }
+        try validateDirectory(directory, fileManager: fileManager)
+        let handle = try acquireLock(in: directory, fileManager: fileManager)
+        defer { releaseLock(handle) }
+        do {
+            try fileManager.removeItem(at: directory)
+        } catch {
+            throw DurableStoreFailure.inputOutput
+        }
+    }
+
+    private func requireHealthy() throws {
+        if failed {
+            throw DurableStoreFailure.corrupt
+        }
+    }
+
+    private func write(_ data: Data, named name: String) throws {
+        guard Self.isOwnedName(name) else {
+            throw DurableStoreFailure.corrupt
+        }
+        let destination = directory.appendingPathComponent(name, isDirectory: false)
+        do {
+            try data.write(to: destination, options: .atomic)
+            try Self.hardenOwnedFile(destination, fileManager: fileManager)
+        } catch {
+            throw DurableStoreFailure.inputOutput
+        }
+    }
+}