@logbrew/react-native 0.1.11 → 0.1.13

package/ios/GeneratedAppleDiagnostics/LogBrew/URLSessionTrace.swift

@@ -0,0 +1,277 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+#if canImport(FoundationNetworking)
+    import FoundationNetworking
+#endif
+
+public struct LogBrewURLSessionSpan {
+    public let request: URLRequest
+    public let traceContext: LogBrewTraceContext
+    public let method: String
+    public let routeTemplate: String
+
+    public init(
+        request: URLRequest,
+        traceContext: LogBrewTraceContext,
+        method: String,
+        routeTemplate: String,
+    ) {
+        self.request = request
+        self.traceContext = traceContext
+        self.method = method
+        self.routeTemplate = routeTemplate
+    }
+}
+
+public struct LogBrewURLSessionTimings: Equatable, Sendable {
+    private let values: Metadata
+
+    public init(
+        fetchMs: Double? = nil,
+        redirectMs: Double? = nil,
+        nameLookupMs: Double? = nil,
+        connectMs: Double? = nil,
+        tlsMs: Double? = nil,
+        sendMs: Double? = nil,
+        waitMs: Double? = nil,
+        receiveMs: Double? = nil,
+        requestBodyBytes: Int64? = nil,
+        responseBodyBytes: Int64? = nil,
+    ) throws {
+        var metadata: Metadata = [:]
+        try Self.addDuration(fetchMs, key: "requestFetchMs", into: &metadata)
+        try Self.addDuration(redirectMs, key: "requestRedirectMs", into: &metadata)
+        try Self.addDuration(nameLookupMs, key: "requestNameLookupMs", into: &metadata)
+        try Self.addDuration(connectMs, key: "requestConnectMs", into: &metadata)
+        try Self.addDuration(tlsMs, key: "requestTlsMs", into: &metadata)
+        try Self.addDuration(sendMs, key: "requestSendMs", into: &metadata)
+        try Self.addDuration(waitMs, key: "requestWaitMs", into: &metadata)
+        try Self.addDuration(receiveMs, key: "requestReceiveMs", into: &metadata)
+        try Self.addByteCount(requestBodyBytes, key: "requestBodyBytes", into: &metadata)
+        try Self.addByteCount(responseBodyBytes, key: "responseBodyBytes", into: &metadata)
+        values = metadata
+    }
+
+    public init(taskMetrics: URLSessionTaskMetrics) throws {
+        var metadata: Metadata = [:]
+        try Self.addDuration(taskMetrics.taskInterval, key: "requestFetchMs", into: &metadata)
+
+        let networkTransactions = taskMetrics.transactionMetrics.filter { $0.resourceFetchType != .localCache }
+        let mainTransaction = networkTransactions.last
+        try Self.addRedirectTimings(networkTransactions.dropLast(), into: &metadata)
+        if let mainTransaction {
+            try Self.addMainTransactionTimings(mainTransaction, into: &metadata)
+        }
+
+        values = metadata
+    }
+
+    var metadata: Metadata {
+        values
+    }
+
+    private static func addRedirectTimings(
+        _ transactions: ArraySlice<URLSessionTaskTransactionMetrics>,
+        into metadata: inout Metadata,
+    ) throws {
+        let redirectStarts = transactions.compactMap(\.fetchStartDate)
+        let redirectEnds = transactions.compactMap(\.responseEndDate)
+        if let firstRedirectStart = redirectStarts.first, let lastRedirectEnd = redirectEnds.last {
+            try addDuration(firstRedirectStart, lastRedirectEnd, key: "requestRedirectMs", into: &metadata)
+        }
+    }
+
+    private static func addMainTransactionTimings(
+        _ transaction: URLSessionTaskTransactionMetrics,
+        into metadata: inout Metadata,
+    ) throws {
+        try addDuration(
+            transaction.domainLookupStartDate,
+            transaction.domainLookupEndDate,
+            key: "requestNameLookupMs",
+            into: &metadata,
+        )
+        try addDuration(
+            transaction.connectStartDate,
+            transaction.connectEndDate,
+            key: "requestConnectMs",
+            into: &metadata,
+        )
+        try addDuration(
+            transaction.secureConnectionStartDate,
+            transaction.secureConnectionEndDate,
+            key: "requestTlsMs",
+            into: &metadata,
+        )
+        try addDuration(
+            transaction.requestStartDate,
+            transaction.requestEndDate,
+            key: "requestSendMs",
+            into: &metadata,
+        )
+        try addDuration(
+            transaction.requestEndDate ?? transaction.requestStartDate,
+            transaction.responseStartDate,
+            key: "requestWaitMs",
+            into: &metadata,
+        )
+        try addDuration(
+            transaction.responseStartDate,
+            transaction.responseEndDate,
+            key: "requestReceiveMs",
+            into: &metadata,
+        )
+        try addByteCount(
+            transaction.countOfRequestBodyBytesSent,
+            key: "requestBodyBytes",
+            into: &metadata,
+        )
+        try addByteCount(
+            transaction.countOfResponseBodyBytesReceived,
+            key: "responseBodyBytes",
+            into: &metadata,
+        )
+    }
+
+    private static func addDuration(_ value: Double?, key: String, into metadata: inout Metadata) throws {
+        guard let value else {
+            return
+        }
+        guard value >= 0, value.isFinite else {
+            throw SdkError(
+                code: "validation_error",
+                message: "URLSession timing values must be non-negative and finite",
+            )
+        }
+        metadata[key] = .double(value)
+    }
+
+    private static func addDuration(_ interval: DateInterval, key: String, into metadata: inout Metadata) throws {
+        try addDuration(interval.duration * 1000, key: key, into: &metadata)
+    }
+
+    private static func addDuration(_ start: Date?, _ end: Date?, key: String, into metadata: inout Metadata) throws {
+        guard let start, let end else {
+            return
+        }
+        try addDuration(end.timeIntervalSince(start) * 1000, key: key, into: &metadata)
+    }
+
+    private static func addByteCount(_ value: Int64?, key: String, into metadata: inout Metadata) throws {
+        guard let value else {
+            return
+        }
+        guard value >= 0, value <= Int64(Int.max) else {
+            throw SdkError(code: "validation_error", message: "URLSession byte counts must be non-negative")
+        }
+        metadata[key] = .int(Int(value))
+    }
+}
+
+public extension LogBrewTrace {
+    static func startURLSessionSpan(
+        for request: URLRequest,
+        routeTemplate: String? = nil,
+        context: LogBrewTraceContext? = current,
+    ) throws -> LogBrewURLSessionSpan {
+        let method = try normalizedNetworkMethod(request.httpMethod ?? "GET")
+        let route = try routeTemplateFromURLRequest(request, routeTemplate: routeTemplate)
+        let spanContext = context.map(LogBrewTraceContext.child(of:)) ?? LogBrewTraceContext.fallbackRoot()
+
+        var tracedRequest = request
+        tracedRequest.setValue(spanContext.traceparent, forHTTPHeaderField: "traceparent")
+
+        return LogBrewURLSessionSpan(
+            request: tracedRequest,
+            traceContext: spanContext,
+            method: method,
+            routeTemplate: route,
+        )
+    }
+}
+
+public extension LogBrewClient {
+    func captureURLSessionSpan(
+        _ id: String,
+        timestamp: String,
+        span: LogBrewURLSessionSpan,
+        statusCode: Int? = nil,
+        durationMs: Double? = nil,
+        error: Error? = nil,
+        metadata: Metadata? = nil,
+        timings: LogBrewURLSessionTimings? = nil,
+    ) throws {
+        let checkedStatusCode = try validatedStatusCode(statusCode)
+        let checkedDurationMs = try validatedDurationMs(durationMs)
+        var spanMetadata: Metadata = [:]
+        try copyMetadata(metadata, into: &spanMetadata)
+        for key in urlSessionGeneratedMetadataKeys {
+            spanMetadata.removeValue(forKey: key)
+        }
+        spanMetadata["source"] = .string("swift.urlsession")
+        spanMetadata["method"] = .string(span.method)
+        spanMetadata["routeTemplate"] = .string(span.routeTemplate)
+        if let checkedStatusCode {
+            spanMetadata["statusCode"] = .int(checkedStatusCode)
+        }
+        if let error {
+            spanMetadata["errorType"] = .string(String(describing: type(of: error)))
+        }
+        for (key, value) in timings?.metadata ?? [:] {
+            spanMetadata[key] = value
+        }
+
+        try self.span(
+            id,
+            timestamp: timestamp,
+            attributes: SpanAttributes(
+                name: "\(span.method) \(span.routeTemplate)",
+                traceId: span.traceContext.traceId,
+                spanId: span.traceContext.spanId,
+                parentSpanId: span.traceContext.parentSpanId,
+                status: urlSessionSpanStatus(statusCode: checkedStatusCode, error: error),
+                durationMs: checkedDurationMs,
+                metadata: LogBrewTrace.mergeTraceMetadata(spanMetadata, context: span.traceContext),
+            ),
+        )
+    }
+}
+
+private let urlSessionGeneratedMetadataKeys: Set<String> = [
+    "source",
+    "method",
+    "routeTemplate",
+    "statusCode",
+    "errorType",
+    "requestFetchMs",
+    "requestRedirectMs",
+    "requestNameLookupMs",
+    "requestConnectMs",
+    "requestTlsMs",
+    "requestSendMs",
+    "requestWaitMs",
+    "requestReceiveMs",
+    "requestBodyBytes",
+    "responseBodyBytes",
+]
+
+private func routeTemplateFromURLRequest(_ request: URLRequest, routeTemplate: String?) throws -> String {
+    if let routeTemplate {
+        return try normalizedRouteTemplate(routeTemplate)
+    }
+    guard let url = request.url else {
+        throw SdkError(code: "validation_error", message: "URLSession request URL is required")
+    }
+    return try normalizedRouteTemplate(url.absoluteString)
+}
+
+private func urlSessionSpanStatus(statusCode: Int?, error: Error?) -> SpanStatus {
+    if error != nil {
+        return .error
+    }
+    guard let statusCode else {
+        return .ok
+    }
+    return statusCode >= 400 ? .error : .ok
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/URLSessionTracer.swift

@@ -0,0 +1,151 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+#if canImport(FoundationNetworking)
+    import FoundationNetworking
+#endif
+
+public final class LogBrewURLSessionTracer: @unchecked Sendable {
+    private let client: LogBrewClient
+    private let dataLoader: @Sendable (URLRequest) async throws -> (Data, URLResponse)
+    private let timestampProvider: @Sendable () -> String
+    private let nowMsProvider: @Sendable () -> Double
+    private let onCaptureError: (@Sendable (any Error) -> Void)?
+    private let eventIDPrefix: String
+    private let lock = NSLock()
+    private var nextEventSequence = 1
+
+    public convenience init(
+        client: LogBrewClient,
+        session: URLSession = .shared,
+        eventIDPrefix: String = "evt_urlsession",
+        timestampProvider: (@Sendable () -> String)? = nil,
+        nowMsProvider: (@Sendable () -> Double)? = nil,
+        onCaptureError: (@Sendable (any Error) -> Void)? = nil,
+    ) throws {
+        let loader = LogBrewURLSessionDataLoader(session: session)
+        try self.init(
+            client: client,
+            eventIDPrefix: eventIDPrefix,
+            timestampProvider: timestampProvider,
+            nowMsProvider: nowMsProvider,
+            onCaptureError: onCaptureError,
+            dataLoader: { request in
+                try await loader.data(for: request)
+            },
+        )
+    }
+
+    init(
+        client: LogBrewClient,
+        eventIDPrefix: String = "evt_urlsession",
+        timestampProvider: (@Sendable () -> String)? = nil,
+        nowMsProvider: (@Sendable () -> Double)? = nil,
+        onCaptureError: (@Sendable (any Error) -> Void)? = nil,
+        dataLoader: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse),
+    ) throws {
+        let normalizedPrefix = eventIDPrefix.trimmingCharacters(in: .whitespacesAndNewlines)
+        try requireNonEmpty("URLSession tracer eventIDPrefix", normalizedPrefix)
+        self.client = client
+        self.eventIDPrefix = normalizedPrefix
+        self.timestampProvider = timestampProvider ?? Self.defaultTimestamp
+        self.nowMsProvider = nowMsProvider ?? Self.defaultNowMs
+        self.onCaptureError = onCaptureError
+        self.dataLoader = dataLoader
+    }
+
+    @discardableResult
+    public func data(
+        for request: URLRequest,
+        routeTemplate: String? = nil,
+        eventID: String? = nil,
+        metadata: Metadata? = nil,
+    ) async throws -> (Data, URLResponse) {
+        let span = try LogBrewTrace.startURLSessionSpan(for: request, routeTemplate: routeTemplate)
+        let startedAtMs = nowMsProvider()
+
+        do {
+            let (data, response) = try await dataLoader(span.request)
+            captureSpan(URLSessionTraceCapture(
+                eventID: eventID,
+                span: span,
+                response: response,
+                durationMs: durationSince(startedAtMs),
+                error: nil,
+                metadata: metadata,
+            ))
+            return (data, response)
+        } catch {
+            captureSpan(URLSessionTraceCapture(
+                eventID: eventID,
+                span: span,
+                response: nil,
+                durationMs: durationSince(startedAtMs),
+                error: error,
+                metadata: metadata,
+            ))
+            throw error
+        }
+    }
+
+    private func captureSpan(_ capture: URLSessionTraceCapture) {
+        do {
+            try client.captureURLSessionSpan(
+                capture.eventID ?? nextEventID(),
+                timestamp: timestampProvider(),
+                span: capture.span,
+                statusCode: (capture.response as? HTTPURLResponse)?.statusCode,
+                durationMs: capture.durationMs,
+                error: capture.error,
+                metadata: capture.metadata,
+            )
+        } catch {
+            onCaptureError?(error)
+        }
+    }
+
+    private func durationSince(_ startedAtMs: Double) -> Double {
+        let endedAtMs = nowMsProvider()
+        guard startedAtMs.isFinite, endedAtMs.isFinite else {
+            return 0
+        }
+        return max(0, endedAtMs - startedAtMs)
+    }
+
+    private func nextEventID() -> String {
+        lock.lock()
+        defer {
+            lock.unlock()
+        }
+        let eventID = "\(eventIDPrefix)_\(nextEventSequence)"
+        nextEventSequence += 1
+        return eventID
+    }
+
+    private static func defaultTimestamp() -> String {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return formatter.string(from: Date())
+    }
+
+    private static func defaultNowMs() -> Double {
+        ProcessInfo.processInfo.systemUptime * 1000
+    }
+}
+
+private struct URLSessionTraceCapture {
+    let eventID: String?
+    let span: LogBrewURLSessionSpan
+    let response: URLResponse?
+    let durationMs: Double
+    let error: (any Error)?
+    let metadata: Metadata?
+}
+
+private struct LogBrewURLSessionDataLoader: @unchecked Sendable {
+    let session: URLSession
+
+    func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await session.data(for: request)
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/Validation.swift

@@ -0,0 +1,165 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+func validateRelease(_ attributes: ReleaseAttributes) throws -> ReleaseAttributes {
+    try requireNonEmpty("release version", attributes.version)
+    if let commit = attributes.commit {
+        try requireNonEmpty("release commit", commit)
+    }
+    try validateMetadata(attributes.metadata, label: "release metadata")
+    return try ReleaseAttributes(
+        version: attributes.version,
+        commit: attributes.commit,
+        notes: attributes.notes,
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func validateEnvironment(_ attributes: EnvironmentAttributes) throws -> EnvironmentAttributes {
+    try requireNonEmpty("environment name", attributes.name)
+    try validateMetadata(attributes.metadata, label: "environment metadata")
+    return try EnvironmentAttributes(
+        name: attributes.name,
+        region: attributes.region,
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func validateIssue(_ attributes: IssueAttributes) throws -> IssueAttributes {
+    try requireNonEmpty("issue title", attributes.title)
+    if let frames = attributes.nativeStackFrames {
+        guard (1 ... 32).contains(frames.count), frames.allSatisfy(isValidNativeStackFrame) else {
+            throw SdkError(code: "validation_error", message: "issue nativeStackFrames must be canonical")
+        }
+    }
+    return try normalizeIssueAttributes(attributes)
+}
+
+private func isValidNativeStackFrame(_ frame: NativeStackFrame) -> Bool {
+    UUID(uuidString: frame.imageUuid)?.uuidString.lowercased() == frame.imageUuid
+        && frame.instructionOffset.count == 16
+        && frame.instructionOffset.allSatisfy { ("0" ... "9").contains($0) || ("a" ... "f").contains($0) }
+}
+
+func validateLog(_ attributes: LogAttributes) throws -> LogAttributes {
+    try requireNonEmpty("log message", attributes.message)
+    try validateMetadata(attributes.metadata, label: "log metadata")
+    return try LogAttributes(
+        message: attributes.message,
+        level: attributes.level,
+        logger: attributes.logger,
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func validateSpan(_ attributes: SpanAttributes) throws -> SpanAttributes {
+    try requireNonEmpty("span name", attributes.name)
+    try requireNonEmpty("span traceId", attributes.traceId)
+    try requireNonEmpty("span spanId", attributes.spanId)
+    if let parentSpanId = attributes.parentSpanId {
+        try requireNonEmpty("span parentSpanId", parentSpanId)
+    }
+    if let durationMs = attributes.durationMs, durationMs < 0 {
+        throw SdkError(code: "validation_error", message: "span durationMs must be non-negative")
+    }
+    try validateMetadata(attributes.metadata, label: "span metadata")
+    return try SpanAttributes(
+        name: attributes.name,
+        traceId: attributes.traceId,
+        spanId: attributes.spanId,
+        parentSpanId: attributes.parentSpanId,
+        status: attributes.status,
+        durationMs: attributes.durationMs,
+        events: validateSpanEvents(attributes.events),
+        links: validateSpanLinks(attributes.links),
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func validateAction(_ attributes: ActionAttributes) throws -> ActionAttributes {
+    try requireNonEmpty("action name", attributes.name)
+    try validateMetadata(attributes.metadata, label: "action metadata")
+    return try ActionAttributes(
+        name: attributes.name,
+        status: attributes.status,
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func validateMetric(_ attributes: MetricAttributes) throws -> MetricAttributes {
+    try requireNonEmpty("metric name", attributes.name)
+    try requireNonEmpty("metric unit", attributes.unit)
+    guard attributes.value.isFinite else {
+        throw SdkError(code: "validation_error", message: "metric value must be finite")
+    }
+    switch attributes.kind {
+    case .counter, .histogram:
+        if attributes.value < 0 {
+            throw SdkError(
+                code: "validation_error",
+                message: "\(attributes.kind.rawValue) metric value must be non-negative",
+            )
+        }
+        guard attributes.temporality == .delta || attributes.temporality == .cumulative else {
+            throw SdkError(
+                code: "validation_error",
+                message: "\(attributes.kind.rawValue) metric temporality must be cumulative or delta",
+            )
+        }
+    case .gauge:
+        guard attributes.temporality == .instant else {
+            throw SdkError(
+                code: "validation_error",
+                message: "gauge metric temporality must be instant",
+            )
+        }
+    }
+    try validateMetadata(attributes.metadata, label: "metric metadata")
+    return try MetricAttributes(
+        name: attributes.name,
+        kind: attributes.kind,
+        value: attributes.value,
+        unit: attributes.unit,
+        temporality: attributes.temporality,
+        metadata: attributes.metadata,
+        context: attributes.context.map { try validateTelemetryContext($0) },
+    )
+}
+
+func requireNonEmpty(_ label: String, _ value: String) throws {
+    if value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+        throw SdkError(code: "validation_error", message: "\(label) must be non-empty")
+    }
+}
+
+func requireTimestamp(_ timestamp: String) throws {
+    try requireNonEmpty("timestamp", timestamp)
+    let timePart = timestamp.split(separator: "T", maxSplits: 1).dropFirst().first
+    let hasZuluSuffix = timestamp.hasSuffix("Z")
+    let hasPositiveOffset = timePart?.contains("+") == true
+    let hasNegativeOffset = timePart?.dropFirst().contains("-") == true
+    let hasTimeZone = hasZuluSuffix || hasPositiveOffset || hasNegativeOffset
+    guard hasTimeZone else {
+        throw SdkError(
+            code: "validation_error",
+            message: "timestamp must include a timezone offset: \(timestamp)",
+        )
+    }
+
+    let formatter = ISO8601DateFormatter()
+    formatter.formatOptions = [.withInternetDateTime]
+    if formatter.date(from: timestamp) != nil {
+        return
+    }
+
+    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    if formatter.date(from: timestamp) == nil {
+        throw SdkError(code: "validation_error", message: "invalid timestamp: \(timestamp)")
+    }
+}