@logbrew/react-native 0.1.11 → 0.1.12

package/ios/GeneratedAppleDiagnostics/LogBrew/LogBrewClient.swift

@@ -0,0 +1,358 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public final class LogBrewClient: @unchecked Sendable {
+    private let engine: DeliveryEngine
+    private let baseContext: TelemetryContext?
+    private let breadcrumbStore = IssueBreadcrumbStore()
+
+    public static func create(
+        apiKey: String,
+        sdkName: String,
+        sdkVersion: String,
+        maxRetries: Int = 2,
+        context: TelemetryContext? = nil,
+        includeAutomaticContext: Bool = true,
+    ) throws -> LogBrewClient {
+        try LogBrewClient(
+            config: ClientConfig(
+                apiKey: apiKey,
+                sdkName: sdkName,
+                sdkVersion: sdkVersion,
+                maxRetries: maxRetries,
+                context: context,
+                includeAutomaticContext: includeAutomaticContext,
+            ),
+        )
+    }
+
+    public init(config: ClientConfig) throws {
+        try requireNonEmpty("api_key", config.apiKey)
+        try requireNonEmpty("sdk_name", config.sdkName)
+        try requireNonEmpty("sdk_version", config.sdkVersion)
+        baseContext = try mergeTelemetryContexts(
+            config.includeAutomaticContext ? automaticTelemetryContext() : nil,
+            config.context,
+        )
+        engine = DeliveryEngine(
+            apiKey: config.apiKey,
+            sdk: SDKInfo(name: config.sdkName, language: "swift", version: config.sdkVersion),
+            maxRetries: config.maxRetries,
+        )
+    }
+
+    public func pendingEvents() -> Int {
+        engine.pendingEvents()
+    }
+
+    public func previewJSON() throws -> String {
+        try engine.previewJSON()
+    }
+
+    public func release(_ id: String, timestamp: String, attributes: ReleaseAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        try pushEvent(.release(validateRelease(attributes.withContext(context))), id: id, timestamp: timestamp)
+    }
+
+    public func environment(_ id: String, timestamp: String, attributes: EnvironmentAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        try pushEvent(.environment(validateEnvironment(attributes.withContext(context))), id: id, timestamp: timestamp)
+    }
+
+    public func issue(_ id: String, timestamp: String, attributes: IssueAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        let attributes = issueAttributes(attributes, adding: breadcrumbStore.snapshot())
+            .withContext(context)
+            .withCorrelationMetadata()
+        try pushEvent(.issue(validateIssue(attributes)), id: id, timestamp: timestamp)
+    }
+
+    @_spi(CrashReplay)
+    public func issueDetached(_ id: String, timestamp: String, attributes: IssueAttributes) throws {
+        try pushEvent(.issue(validateIssue(attributes)), id: id, timestamp: timestamp)
+    }
+
+    public func log(_ id: String, timestamp: String, attributes: LogAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        try pushEvent(
+            .log(validateLog(attributes.withContext(context).withCorrelationMetadata())),
+            id: id,
+            timestamp: timestamp,
+        )
+    }
+
+    public func span(_ id: String, timestamp: String, attributes: SpanAttributes) throws {
+        let inherited = try resolvedContext(event: attributes.context)
+        let sampled = inherited?.trace.flatMap { trace in
+            trace.traceId.caseInsensitiveCompare(attributes.traceId) == .orderedSame ? trace.sampled : nil
+        }
+        let spanTrace = telemetryTraceContext(
+            traceId: attributes.traceId,
+            spanId: attributes.spanId,
+            parentSpanId: attributes.parentSpanId,
+            sampled: sampled,
+        )
+        let context = try mergeTelemetryContexts(
+            contextWithoutTrace(inherited),
+            spanTrace.map { TelemetryContext(trace: $0) },
+        )
+        try pushEvent(.span(validateSpan(attributes.withContext(context))), id: id, timestamp: timestamp)
+    }
+
+    public func action(_ id: String, timestamp: String, attributes: ActionAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        try pushEvent(
+            .action(validateAction(attributes.withContext(context).withCorrelationMetadata())),
+            id: id,
+            timestamp: timestamp,
+        )
+    }
+
+    public func metric(_ id: String, timestamp: String, attributes: MetricAttributes) throws {
+        let context = try resolvedContext(event: attributes.context)
+        try pushEvent(
+            .metric(validateMetric(attributes.withContext(context).withCorrelationMetadata())),
+            id: id,
+            timestamp: timestamp,
+        )
+    }
+
+    /// Retain one validated breadcrumb for subsequent issues, evicting the oldest after 64 entries.
+    public func addBreadcrumb(_ breadcrumb: IssueBreadcrumb) throws {
+        try breadcrumbStore.add(breadcrumb)
+    }
+
+    /// Clear the client-owned breadcrumb history without changing already queued issues.
+    public func clearBreadcrumbs() {
+        breadcrumbStore.clear()
+    }
+
+    public func flush(transport: any Transport) throws -> TransportResponse {
+        try engine.flush(transport: transport)
+    }
+
+    @_spi(CrashReplay)
+    public func flushEvent(
+        _ eventID: String,
+        transport: any Transport,
+    ) throws -> Bool {
+        try requireNonEmpty("event id", eventID)
+        return try engine.flushEvent(eventID, transport: transport)
+    }
+
+    public func shutdown(transport: any Transport) throws -> TransportResponse {
+        try engine.shutdown(transport: transport)
+    }
+
+    public func startAutomaticDelivery(
+        transport: any Transport,
+        options: AutomaticDeliveryOptions = AutomaticDeliveryOptions(),
+    ) throws {
+        try engine.startAutomaticDelivery(transport: transport, options: options)
+    }
+
+    public func recoverAutomaticDelivery() throws {
+        try engine.recoverAutomaticDelivery()
+    }
+
+    public func stopAutomaticDelivery() {
+        engine.stopAutomaticDelivery()
+    }
+
+    public func deliveryHealth() -> DeliveryHealth {
+        engine.health()
+    }
+
+    public func enableDurableDelivery(options: DurableDeliveryOptions) throws {
+        try engine.enableDurableDelivery(options: options)
+    }
+
+    public func purgeDurableDelivery() throws {
+        try engine.purgeDurableDelivery()
+    }
+
+    public func flush() throws -> TransportResponse {
+        try engine.flushOwnedTransport()
+    }
+
+    public func shutdown() throws -> TransportResponse {
+        try engine.shutdownOwnedTransport()
+    }
+
+    private func pushEvent(_ attributes: EventAttributes, id: String, timestamp: String) throws {
+        try requireNonEmpty("event id", id)
+        try requireTimestamp(timestamp)
+        try engine.enqueue(Event(type: attributes.eventType, timestamp: timestamp, id: id, attributes: attributes))
+    }
+
+    private func resolvedContext(event: TelemetryContext?) throws -> TelemetryContext? {
+        var context = try mergeTelemetryContexts(baseContext, LogBrewTelemetry.current)
+        if let activeTrace = LogBrewTrace.current {
+            context = try mergeTelemetryContexts(
+                context,
+                TelemetryContext(trace: telemetryTraceContext(activeTrace)),
+            )
+        }
+        return try mergeTelemetryContexts(context, event)
+    }
+}
+
+private extension IssueAttributes {
+    func withContext(_ context: TelemetryContext?) -> IssueAttributes {
+        IssueAttributes(
+            title: title,
+            level: level,
+            message: message,
+            exception: exception,
+            stackFrames: stackFrames,
+            breadcrumbs: breadcrumbs,
+            breadcrumbsTruncated: breadcrumbsTruncated,
+            metadata: metadata,
+            context: context,
+            nativeStackFrames: nativeStackFrames,
+        )
+    }
+
+    func withCorrelationMetadata() -> IssueAttributes {
+        IssueAttributes(
+            title: title,
+            level: level,
+            message: message,
+            exception: exception,
+            stackFrames: stackFrames,
+            breadcrumbs: breadcrumbs,
+            breadcrumbsTruncated: breadcrumbsTruncated,
+            metadata: correlationMetadata(metadata, context: context),
+            context: context,
+            nativeStackFrames: nativeStackFrames,
+        )
+    }
+}
+
+private extension LogAttributes {
+    func withContext(_ context: TelemetryContext?) -> LogAttributes {
+        LogAttributes(
+            message: message,
+            level: level,
+            logger: logger,
+            metadata: metadata,
+            context: context,
+        )
+    }
+
+    func withCorrelationMetadata() -> LogAttributes {
+        LogAttributes(
+            message: message,
+            level: level,
+            logger: logger,
+            metadata: correlationMetadata(metadata, context: context),
+            context: context,
+        )
+    }
+}
+
+private extension ActionAttributes {
+    func withContext(_ context: TelemetryContext?) -> ActionAttributes {
+        ActionAttributes(name: name, status: status, metadata: metadata, context: context)
+    }
+
+    func withCorrelationMetadata() -> ActionAttributes {
+        ActionAttributes(
+            name: name,
+            status: status,
+            metadata: correlationMetadata(metadata, context: context),
+            context: context,
+        )
+    }
+}
+
+private extension MetricAttributes {
+    func withContext(_ context: TelemetryContext?) -> MetricAttributes {
+        MetricAttributes(
+            name: name,
+            kind: kind,
+            value: value,
+            unit: unit,
+            temporality: temporality,
+            metadata: metadata,
+            context: context,
+        )
+    }
+
+    func withCorrelationMetadata() -> MetricAttributes {
+        MetricAttributes(
+            name: name,
+            kind: kind,
+            value: value,
+            unit: unit,
+            temporality: temporality,
+            metadata: correlationMetadata(metadata, context: context),
+            context: context,
+        )
+    }
+}
+
+private extension ReleaseAttributes {
+    func withContext(_ context: TelemetryContext?) -> ReleaseAttributes {
+        ReleaseAttributes(version: version, commit: commit, notes: notes, metadata: metadata, context: context)
+    }
+}
+
+private extension EnvironmentAttributes {
+    func withContext(_ context: TelemetryContext?) -> EnvironmentAttributes {
+        EnvironmentAttributes(name: name, region: region, metadata: metadata, context: context)
+    }
+}
+
+private extension SpanAttributes {
+    func withContext(_ context: TelemetryContext?) -> SpanAttributes {
+        SpanAttributes(
+            name: name,
+            traceId: traceId,
+            spanId: spanId,
+            parentSpanId: parentSpanId,
+            status: status,
+            durationMs: durationMs,
+            events: events,
+            links: links,
+            metadata: metadata,
+            context: context,
+        )
+    }
+}
+
+private func correlationMetadata(_ metadata: Metadata?, context: TelemetryContext?) -> Metadata? {
+    guard let trace = context?.trace else {
+        return metadata
+    }
+    var output = metadata ?? [:]
+    output["traceId"] = .string(trace.traceId)
+    if let spanId = trace.spanId {
+        output["spanId"] = .string(spanId)
+    }
+    if let parentSpanId = trace.parentSpanId {
+        output["parentSpanId"] = .string(parentSpanId)
+    }
+    if let sampled = trace.sampled {
+        output["traceSampled"] = .bool(sampled)
+    }
+    if let active = LogBrewTrace.current, active.traceId == trace.traceId, active.spanId == trace.spanId {
+        output["traceFlags"] = .string(active.traceFlags)
+    }
+    return output
+}
+
+private func contextWithoutTrace(_ context: TelemetryContext?) -> TelemetryContext? {
+    guard let context,
+          context.resource != nil || context.session != nil || context.subject != nil || context.tags != nil
+    else {
+        return nil
+    }
+    return TelemetryContext(
+        resource: context.resource,
+        session: context.session,
+        subject: context.subject,
+        tags: context.tags,
+    )
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/LogBrewLogger.swift

@@ -0,0 +1,262 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public enum LogBrewLoggerLevel: String, Sendable {
+    case trace
+    case debug
+    case info
+    case notice
+    case warning
+    case error
+    case fault
+    case critical
+
+    var logBrewLevel: LogLevel {
+        switch self {
+        case .trace, .debug:
+            .info
+        case .info, .notice:
+            .info
+        case .warning:
+            .warning
+        case .error, .fault:
+            .error
+        case .critical:
+            .critical
+        }
+    }
+}
+
+public final class LogBrewLogger {
+    private let client: LogBrewClient
+    private let loggerName: String
+    private let subsystem: String?
+    private let category: String?
+    private let eventIDPrefix: String
+    private let baseMetadata: Metadata
+    private let transport: (any Transport)?
+    private let flushOnLog: Bool
+    private let timestampProvider: () -> String
+    private let onError: ((any Error) -> Void)?
+    private let lock = NSLock()
+    private var nextEventNumber = 0
+
+    public init(
+        client: LogBrewClient,
+        loggerName: String? = nil,
+        subsystem: String? = nil,
+        category: String? = nil,
+        eventIDPrefix: String = "swift_log",
+        metadata: Metadata? = nil,
+        transport: (any Transport)? = nil,
+        flushOnLog: Bool = false,
+        timestampProvider: (() -> String)? = nil,
+        onError: ((any Error) -> Void)? = nil,
+    ) throws {
+        if let loggerName {
+            try requireNonEmpty("logger name", loggerName)
+        }
+        if let subsystem {
+            try requireNonEmpty("logger subsystem", subsystem)
+        }
+        if let category {
+            try requireNonEmpty("logger category", category)
+        }
+        try requireNonEmpty("event id prefix", eventIDPrefix)
+
+        self.client = client
+        self.loggerName = loggerName ?? category ?? subsystem ?? "swift-logger"
+        self.subsystem = subsystem
+        self.category = category
+        self.eventIDPrefix = eventIDPrefix
+        baseMetadata = metadata ?? [:]
+        self.transport = transport
+        self.flushOnLog = flushOnLog
+        self.timestampProvider = timestampProvider ?? Self.defaultTimestamp
+        self.onError = onError
+    }
+
+    public func log(
+        _ level: LogBrewLoggerLevel,
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+        error: (any Error)? = nil,
+    ) {
+        capture(
+            level,
+            message(),
+            call: LogBrewLoggerCall(id: id, timestamp: timestamp, metadata: metadata, error: error),
+        )
+    }
+
+    public func trace(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        log(.trace, message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func debug(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        log(.debug, message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func info(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        log(.info, message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func notice(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        log(.notice, message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func warning(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        log(.warning, message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func warn(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        warning(message(), id: id, timestamp: timestamp, metadata: metadata)
+    }
+
+    public func error(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+        error: (any Error)? = nil,
+    ) {
+        log(.error, message(), id: id, timestamp: timestamp, metadata: metadata, error: error)
+    }
+
+    public func fault(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+        error: (any Error)? = nil,
+    ) {
+        log(.fault, message(), id: id, timestamp: timestamp, metadata: metadata, error: error)
+    }
+
+    public func critical(
+        _ message: @autoclosure () -> String,
+        id: String? = nil,
+        timestamp: String? = nil,
+        metadata: Metadata? = nil,
+        error: (any Error)? = nil,
+    ) {
+        log(.critical, message(), id: id, timestamp: timestamp, metadata: metadata, error: error)
+    }
+
+    public func flush() {
+        guard let transport, client.pendingEvents() > 0 else {
+            return
+        }
+
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+
+        do {
+            _ = try client.flush(transport: transport)
+        } catch {
+            onError?(error)
+        }
+    }
+
+    private func capture(_ level: LogBrewLoggerLevel, _ message: String, call: LogBrewLoggerCall) {
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+
+        do {
+            try client.log(
+                call.id ?? nextEventID(),
+                timestamp: call.timestamp ?? timestampProvider(),
+                attributes: LogAttributes(
+                    message: message,
+                    level: level.logBrewLevel,
+                    logger: loggerName,
+                    metadata: logMetadata(level: level, metadata: call.metadata, error: call.error),
+                ),
+            )
+            if flushOnLog, let transport {
+                _ = try client.flush(transport: transport)
+            }
+        } catch {
+            onError?(error)
+        }
+    }
+
+    private func nextEventID() -> String {
+        nextEventNumber += 1
+        return "\(eventIDPrefix)_\(nextEventNumber)"
+    }
+
+    private func logMetadata(
+        level: LogBrewLoggerLevel,
+        metadata: Metadata?,
+        error: (any Error)?,
+    ) -> Metadata {
+        var merged = baseMetadata
+        metadata?.forEach { key, value in
+            merged[key] = value
+        }
+        merged["source"] = "swift"
+        merged["swiftLogLevel"] = .string(level.rawValue)
+        if let subsystem {
+            merged["swiftSubsystem"] = .string(subsystem)
+        }
+        if let category {
+            merged["swiftCategory"] = .string(category)
+        }
+        if let error {
+            merged["swiftErrorType"] = .string(String(reflecting: type(of: error)))
+            merged["swiftErrorDescription"] = .string(error.localizedDescription)
+        }
+        return merged
+    }
+
+    private static func defaultTimestamp() -> String {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter.string(from: Date())
+    }
+}
+
+private struct LogBrewLoggerCall {
+    let id: String?
+    let timestamp: String?
+    let metadata: Metadata?
+    let error: (any Error)?
+}