@logbrew/react-native 0.1.23 → 0.1.25

package/android-native-diagnostics.js

@@ -0,0 +1,176 @@
+import { SdkError } from "@logbrew/sdk";
+import { NativeModules, Platform, TurboModuleRegistry } from "react-native";
+
+const INSTALL_KEYS = new Set([
+  "anrThresholdMs",
+  "clientKey",
+  "environment",
+  "fatalHandlerOwnership",
+  "projectId",
+  "release",
+  "service"
+]);
+const RECEIPT_KEYS = new Set(["pending", "status"]);
+
+export function installLogBrewAndroidNativeDiagnostics(configuration = {}) {
+  requireAndroid();
+  return receipt(
+    "install",
+    call("installAndroidDiagnostics", normalizeConfiguration(configuration)),
+    new Set(["already_installed", "installed"])
+  );
+}
+
+export function getLogBrewAndroidNativeDiagnosticsStatus() {
+  requireAndroid();
+  return receipt(
+    "status",
+    call("androidDiagnosticsStatus"),
+    new Set(["not_installed", "ready"])
+  );
+}
+
+export function uninstallLogBrewAndroidNativeDiagnostics() {
+  requireAndroid();
+  return receipt(
+    "uninstall",
+    call("uninstallAndroidDiagnostics"),
+    new Set(["not_installed", "uninstalled"])
+  );
+}
+
+function normalizeConfiguration(value) {
+  if (!isObject(value)) {
+    throw configurationError("configuration must be an object");
+  }
+  for (const key of Object.keys(value)) {
+    if (!INSTALL_KEYS.has(key)) {
+      throw configurationError("configuration contains an unsupported key");
+    }
+  }
+  if (value.fatalHandlerOwnership !== "logbrew") {
+    throw configurationError(
+      "fatalHandlerOwnership must be logbrew after removing every other Android fatal handler"
+    );
+  }
+  const projectId = exactText(value.projectId, 64, "projectId");
+  if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u.test(projectId)) {
+    throw configurationError("projectId must be a lowercase UUID");
+  }
+  const threshold = value.anrThresholdMs ?? 5000;
+  if (!Number.isSafeInteger(threshold) || threshold < 2000 || threshold > 60000) {
+    throw configurationError("anrThresholdMs must be an integer from 2000 through 60000");
+  }
+  return {
+    anrThresholdMs: threshold,
+    clientKey: exactText(value.clientKey, 4096, "clientKey"),
+    environment: exactText(value.environment, 128, "environment"),
+    fatalHandlerOwnership: "logbrew",
+    projectId,
+    release: exactText(value.release, 256, "release"),
+    service: exactScope(value.service, "service")
+  };
+}
+
+function exactScope(value, name) {
+  const text = exactText(value, 128, name);
+  if (!/^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/u.test(text)
+    || text.includes("..")
+    || text.includes("//")) {
+    throw configurationError(`${name} must be a bounded deployment identifier`);
+  }
+  return text;
+}
+
+function exactText(value, maximumBytes, name) {
+  if (typeof value !== "string"
+    || value.length === 0
+    || value.trim() !== value
+    || controlCharacter(value)
+    || utf8Length(value) > maximumBytes) {
+    throw configurationError(`${name} must be a bounded non-empty string`);
+  }
+  return value;
+}
+
+function requireAndroid() {
+  if (Platform?.OS !== "android") {
+    throw new SdkError(
+      "unsupported_platform",
+      "LogBrew Android native diagnostics require an Android native build"
+    );
+  }
+}
+
+function call(method, ...args) {
+  let nativeModule;
+  try {
+    nativeModule = TurboModuleRegistry?.get?.("LogBrewFatalStore")
+      ?? NativeModules?.LogBrewFatalStore;
+  } catch {
+    nativeModule = undefined;
+  }
+  if (typeof nativeModule?.[method] !== "function") {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      `linked LogBrew Android diagnostics do not implement ${method}`
+    );
+  }
+  try {
+    return nativeModule[method](...args);
+  } catch {
+    throw new SdkError(
+      "native_diagnostics_failed",
+      `LogBrew Android native diagnostics ${method} failed`
+    );
+  }
+}
+
+function receipt(operation, value, statuses) {
+  const keys = isObject(value) ? Object.keys(value) : [];
+  if (isObject(value)
+    && value.status === "error"
+    && typeof value.code === "string"
+    && /^[a-z0-9_]{1,128}$/u.test(value.code)) {
+    throw new SdkError(
+      value.code,
+      `LogBrew Android native diagnostics ${operation} failed with ${value.code}`
+    );
+  }
+  if (!isObject(value)
+    || keys.length !== RECEIPT_KEYS.size
+    || !keys.every((key) => RECEIPT_KEYS.has(key))
+    || !statuses.has(value.status)
+    || !Number.isSafeInteger(value.pending)
+    || value.pending < 0) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      `LogBrew Android native diagnostics ${operation} returned an invalid response`
+    );
+  }
+  return Object.freeze({ pending: value.pending, status: value.status });
+}
+
+function isObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+
+function controlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.codePointAt(0);
+    return code <= 31 || (code >= 127 && code <= 159);
+  });
+}
+
+function utf8Length(value) {
+  let length = 0;
+  for (const character of value) {
+    const code = character.codePointAt(0);
+    length += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return length;
+}
+
+function configurationError(message) {
+  return new SdkError("configuration_error", `LogBrew Android native diagnostics ${message}`);
+}

package/fatal-replay.cjs

@@ -5,6 +5,7 @@ const MAX_ADMITTED_FATAL_IDS = 256;
 const MAX_FATAL_FILENAME_BYTES = 512;
 const MAX_FATAL_STACK_BYTES = 16 * 1024;
 const MAX_FATAL_STACK_FRAMES = 24;
+const DURABLE_QUEUE = Symbol.for("co.logbrew.react-native.durable-event-queue");
 
 const admittedFatalIdsByClient = new WeakMap();
 let nextFatalSequence = 0;
@@ -18,12 +19,13 @@ function createFatalController({
   sanitizers
 }) {
   const methods = fatalStoreMethods(fatalStore);
+  const directAdmission = !methods && safeReadProperty(client, DURABLE_QUEUE) === true;
   const state = {
     acknowledgedRecords: 0,
-    available: methods !== undefined,
+    available: methods !== undefined || directAdmission,
     corruptRecords: 0,
     droppedRecords: 0,
-    lastOutcome: methods ? "idle" : "unavailable",
+    lastOutcome: methods || directAdmission ? "idle" : "unavailable",
     replayedRecords: 0,
     storedRecords: 0
   };
@@ -37,6 +39,9 @@ function createFatalController({
       return fatalHealthSnapshot(state);
     },
     replay() {
+      if (!methods) {
+        return;
+      }
       replayPendingFatal({
         client,
         eventMessage,
@@ -49,6 +54,11 @@ function createFatalController({
       });
     },
     store(error) {
+      if (!methods) {
+        return directAdmission
+          ? admitFatalError({ client, error, eventMessage, issue, onDiagnostic, sanitizers, state })
+          : false;
+      }
       return storeFatalError({
         error,
         fatalStore,
@@ -61,6 +71,26 @@ function createFatalController({
   };
 }
 
+function admitFatalError({ client, error, eventMessage, issue, onDiagnostic, sanitizers, state }) {
+  const record = createFatalRecord(error, sanitizers);
+  const before = admissionSnapshot(client);
+  try {
+    issue.call(client, record.id, record.timestamp, fatalEventAttributes(record, eventMessage));
+  } catch {
+    state.lastOutcome = "storage_error";
+    emitDiagnostic(onDiagnostic, "fatal_store_failed");
+    return false;
+  }
+  if (!wasAdmitted(before, admissionSnapshot(client))) {
+    state.lastOutcome = "storage_error";
+    emitDiagnostic(onDiagnostic, "fatal_store_failed");
+    return false;
+  }
+  state.storedRecords = incrementBounded(state.storedRecords);
+  state.lastOutcome = "stored";
+  return true;
+}
+
 function fatalStoreMethods(fatalStore) {
   if (!isObjectLike(fatalStore)) {
     return undefined;
@@ -327,7 +357,9 @@ function fatalEventAttributes(record, eventMessage) {
       replayed: true,
       source: "react-native.global_error"
     }),
-    stackFrames: record.stackFrames.map((frame) => Object.freeze({ ...frame })),
+    ...(record.stackFrames.length === 0
+      ? {}
+      : { stackFrames: record.stackFrames.map((frame) => Object.freeze({ ...frame })) }),
     title: eventMessage
   });
 }

package/global-errors.d.cts

@@ -240,9 +240,9 @@ export declare function installLogBrewReactNativePromiseRejectionTracker(
 /**
  * Install reversible automatic capture for React Native global JavaScript errors.
  *
- * The React Native conditional export injects its synchronous native fatal store by default.
- * Direct Node ESM/CJS callers can inject a compatible store explicitly. Fatal replay is
- * stable-ID at-least-once and acknowledges only after observable local queue admission.
+ * The React Native conditional export admits fatal reports into its persistent event queue
+ * before the previous handler runs. Direct Node ESM/CJS callers can inject a compatible
+ * fatal store explicitly.
  * This helper does not claim local exactly-once delivery or install Promise rejection handling.
  */
 export declare function installLogBrewReactNativeGlobalErrorHandler(

package/global-errors.d.ts

@@ -240,9 +240,9 @@ export declare function installLogBrewReactNativePromiseRejectionTracker(
 /**
  * Install reversible automatic capture for React Native global JavaScript errors.
  *
- * The React Native conditional export injects its synchronous native fatal store by default.
- * Direct Node ESM/CJS callers can inject a compatible store explicitly. Fatal replay is
- * stable-ID at-least-once and acknowledges only after observable local queue admission.
+ * The React Native conditional export admits fatal reports into its persistent event queue
+ * before the previous handler runs. Direct Node ESM/CJS callers can inject a compatible
+ * fatal store explicitly.
  * This helper does not claim local exactly-once delivery or install Promise rejection handling.
  */
 export declare function installLogBrewReactNativeGlobalErrorHandler(

package/global-errors.native.js

@@ -1,5 +1,3 @@
-import { NativeModules, TurboModuleRegistry } from "react-native";
-
 import {
   createLogBrewReactNativePromiseRejectionHandlers,
   installLogBrewReactNativeGlobalErrorHandler as installPlatformNeutralHandler,
@@ -12,15 +10,6 @@ export {
 
 const hermesTrackerAdapters = new WeakMap();
 
-function defaultFatalStore() {
-  try {
-    return TurboModuleRegistry?.get?.("LogBrewFatalStore")
-      ?? NativeModules?.LogBrewFatalStore;
-  } catch {
-    return undefined;
-  }
-}
-
 function defaultPromiseRejectionTracker() {
   let hermes;
   let enable;
@@ -70,7 +59,7 @@ export function installLogBrewReactNativeGlobalErrorHandler(options = {}) {
   }
   return installPlatformNeutralHandler({
     ...forwarded,
-    fatalStore: hasInjectedStore ? forwarded.fatalStore : defaultFatalStore()
+    fatalStore: hasInjectedStore ? forwarded.fatalStore : undefined
   });
 }
 

package/index.cjs

@@ -16,7 +16,7 @@ const {
 } = require("./metadata.cjs");
 
 const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.23";
+const DEFAULT_SDK_VERSION = "0.1.25";
 const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
 const NATIVE_RANDOM_HEX = Symbol.for("co.logbrew.react-native.secure-random-hex");
 const MAX_ACTION_NAME_LENGTH = 64;

package/index.native.d.ts

@@ -3,6 +3,7 @@ import type { CreateLogBrewReactNativeClientConfig } from "./index.js";
 
 export * from "./index.js";
 export * from "./apple-native-diagnostics.js";
+export * from "./android-native-diagnostics.js";
 export {
   installLogBrewReactNativeGlobalErrorHandler,
   installLogBrewReactNativePromiseRejectionTracker
@@ -43,10 +44,13 @@ declare const defaultExport: Omit<
   createLogBrewReactNativeClient: typeof createLogBrewReactNativeClient;
   createDefaultLogBrewReactNativeClient: typeof createDefaultLogBrewReactNativeClient;
   getLogBrewAppleNativeDiagnosticsStatus: typeof import("./apple-native-diagnostics.js").getLogBrewAppleNativeDiagnosticsStatus;
+  getLogBrewAndroidNativeDiagnosticsStatus: typeof import("./android-native-diagnostics.js").getLogBrewAndroidNativeDiagnosticsStatus;
   installLogBrewAppleNativeDiagnostics: typeof import("./apple-native-diagnostics.js").installLogBrewAppleNativeDiagnostics;
+  installLogBrewAndroidNativeDiagnostics: typeof import("./android-native-diagnostics.js").installLogBrewAndroidNativeDiagnostics;
   purgeLogBrewReactNativePersistentQueue: typeof purgeLogBrewReactNativePersistentQueue;
   replayLogBrewAppleNativeDiagnostics: typeof import("./apple-native-diagnostics.js").replayLogBrewAppleNativeDiagnostics;
   setLogBrewAppleNativeCrashContext: typeof import("./apple-native-diagnostics.js").setLogBrewAppleNativeCrashContext;
+  uninstallLogBrewAndroidNativeDiagnostics: typeof import("./android-native-diagnostics.js").uninstallLogBrewAndroidNativeDiagnostics;
 };
 
 export default defaultExport;

package/index.native.js

@@ -17,6 +17,11 @@ import {
   setLogBrewAppleNativeCrashContext,
   syncLogBrewAppleNativeCrashBreadcrumbs
 } from "./apple-native-diagnostics.js";
+import {
+  getLogBrewAndroidNativeDiagnosticsStatus,
+  installLogBrewAndroidNativeDiagnostics,
+  uninstallLogBrewAndroidNativeDiagnostics
+} from "./android-native-diagnostics.js";
 import {
   purgeReactNativePersistentQueue,
   resolveReactNativePersistentEventStore
@@ -31,6 +36,11 @@ export {
   replayLogBrewAppleNativeDiagnostics,
   setLogBrewAppleNativeCrashContext
 };
+export {
+  getLogBrewAndroidNativeDiagnosticsStatus,
+  installLogBrewAndroidNativeDiagnostics,
+  uninstallLogBrewAndroidNativeDiagnostics
+};
 
 export * from "./index.js";
 
@@ -40,6 +50,7 @@ if (typeof nativeRuntime?.secureRandomHex === "function") {
   globalThis[Symbol.for("co.logbrew.react-native.secure-random-hex")] =
     nativeRuntime.secureRandomHex.bind(nativeRuntime);
 }
+const DURABLE_QUEUE = Symbol.for("co.logbrew.react-native.durable-event-queue");
 
 export function createLogBrewReactNativeClient(config = {}) {
   const input = config !== null && typeof config === "object" ? config : {};
@@ -69,14 +80,18 @@ export function createLogBrewReactNativeClient(config = {}) {
     hasExplicitPersistentQueue
   });
   try {
-    return bindAppleNativeCrashBreadcrumbs(createPlatformNeutralClient({
+    const client = createPlatformNeutralClient({
       ...forwarded,
       apiKey,
       clientKey,
       eventStore: resolved.eventStore,
       maxQueueBytes,
       maxQueueSize
-    }));
+    });
+    if (resolved.durable) {
+      Object.defineProperty(client, DURABLE_QUEUE, { value: true });
+    }
+    return bindAppleNativeCrashBreadcrumbs(client);
   } catch (error) {
     resolved.abort();
     throw error;
@@ -205,11 +220,14 @@ const defaultExport = {
   createDefaultLogBrewReactNativeClient,
   createLogBrewReactNativeClient,
   getDefaultReactNativeContext,
+  getLogBrewAndroidNativeDiagnosticsStatus,
   getLogBrewAppleNativeDiagnosticsStatus,
   installLogBrewAppleNativeDiagnostics,
+  installLogBrewAndroidNativeDiagnostics,
   purgeLogBrewReactNativePersistentQueue,
   replayLogBrewAppleNativeDiagnostics,
-  setLogBrewAppleNativeCrashContext
+  setLogBrewAppleNativeCrashContext,
+  uninstallLogBrewAndroidNativeDiagnostics
 };
 
 export default defaultExport;

package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift

@@ -3,7 +3,7 @@ import Foundation
 @objc(LBRNAppleNativeDiagnostics)
 public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
     private static let shared = LBRNAppleNativeDiagnostics()
-    private static let sdkVersion = "0.1.23"
+    private static let sdkVersion = "0.1.25"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")

package/ios/GeneratedAppleDiagnostics/LogBrew/LogBrewLogger.swift

@@ -14,9 +14,7 @@ public enum LogBrewLoggerLevel: String, Sendable {
 
     var logBrewLevel: LogLevel {
         switch self {
-        case .trace, .debug:
-            .info
-        case .info, .notice:
+        case .trace, .debug, .info, .notice:
             .info
         case .warning:
             .warning
@@ -73,7 +71,7 @@ public final class LogBrewLogger {
         baseMetadata = metadata ?? [:]
         self.transport = transport
         self.flushOnLog = flushOnLog
-        self.timestampProvider = timestampProvider ?? Self.defaultTimestamp
+        self.timestampProvider = timestampProvider ?? currentTelemetryTimestamp
         self.onError = onError
     }
 
@@ -246,12 +244,6 @@ public final class LogBrewLogger {
         }
         return merged
     }
-
-    private static func defaultTimestamp() -> String {
-        let formatter = ISO8601DateFormatter()
-        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-        return formatter.string(from: Date())
-    }
 }
 
 private struct LogBrewLoggerCall {

package/ios/GeneratedAppleDiagnostics/LogBrew/OperationTrace.swift

@@ -0,0 +1,56 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public extension LogBrewClient {
+    /// Runs one app-owned operation under a root or child trace and records its span.
+    @discardableResult
+    func withOperation<Result>(
+        _ name: String,
+        metadata: Metadata? = nil,
+        onOperationError: ((any Error) -> Void)? = nil,
+        onCaptureError: ((any Error) -> Void)? = nil,
+        operation: () async throws -> Result,
+    ) async throws -> Result {
+        let operationName = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        try requireNonEmpty("operation name", operationName)
+        let context = LogBrewTrace.current.map(LogBrewTrace.childContext(of:)) ?? LogBrewTrace
+            .continueOrCreateContext(fromTraceparent: nil)
+        let startedAtMs = ProcessInfo.processInfo.systemUptime * 1000
+        func finish(_ error: (any Error)? = nil) {
+            do {
+                var evidence = metadata ?? [:]
+                evidence["source"] = .string("swift.operation")
+                if let error {
+                    evidence["errorType"] = .string(String(reflecting: type(of: error)))
+                }
+                try span(
+                    "swift_operation_span_\(context.spanId)",
+                    timestamp: currentTelemetryTimestamp(),
+                    attributes: LogBrewTrace.spanAttributes(
+                        name: operationName,
+                        status: error == nil ? .ok : .error,
+                        durationMs: max(0, ProcessInfo.processInfo.systemUptime * 1000 - startedAtMs),
+                        metadata: evidence,
+                        context: context,
+                    ),
+                )
+            } catch {
+                onCaptureError?(error)
+            }
+        }
+
+        return try await LogBrewTrace.withContext(context) {
+            do {
+                let result = try await operation()
+                finish()
+                return result
+            } catch {
+                let operationError = error
+                onOperationError?(operationError)
+                finish(operationError)
+                throw operationError
+            }
+        }
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/URLSessionTracer.swift

@@ -23,7 +23,6 @@ public final class LogBrewURLSessionTracer: @unchecked Sendable {
         nowMsProvider: (@Sendable () -> Double)? = nil,
         onCaptureError: (@Sendable (any Error) -> Void)? = nil,
     ) throws {
-        let loader = LogBrewURLSessionDataLoader(session: session)
         try self.init(
             client: client,
             eventIDPrefix: eventIDPrefix,
@@ -31,7 +30,7 @@ public final class LogBrewURLSessionTracer: @unchecked Sendable {
             nowMsProvider: nowMsProvider,
             onCaptureError: onCaptureError,
             dataLoader: { request in
-                try await loader.data(for: request)
+                try await session.data(for: request)
             },
         )
     }
@@ -48,7 +47,7 @@ public final class LogBrewURLSessionTracer: @unchecked Sendable {
         try requireNonEmpty("URLSession tracer eventIDPrefix", normalizedPrefix)
         self.client = client
         self.eventIDPrefix = normalizedPrefix
-        self.timestampProvider = timestampProvider ?? Self.defaultTimestamp
+        self.timestampProvider = timestampProvider ?? currentTelemetryTimestamp
         self.nowMsProvider = nowMsProvider ?? Self.defaultNowMs
         self.onCaptureError = onCaptureError
         self.dataLoader = dataLoader
@@ -60,45 +59,63 @@ public final class LogBrewURLSessionTracer: @unchecked Sendable {
         routeTemplate: String? = nil,
         eventID: String? = nil,
         metadata: Metadata? = nil,
+        onRequestError: (@Sendable (any Error) throws -> Void)? = 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,
-            ))
+            let durationMs = durationSince(startedAtMs)
+            captureSpan(eventID, span: span, response: response, durationMs: durationMs, metadata: metadata)
             return (data, response)
         } catch {
-            captureSpan(URLSessionTraceCapture(
-                eventID: eventID,
-                span: span,
-                response: nil,
-                durationMs: durationSince(startedAtMs),
-                error: error,
-                metadata: metadata,
-            ))
+            let durationMs = durationSince(startedAtMs)
+            captureSpan(eventID, span: span, durationMs: durationMs, error: error, metadata: metadata)
+            captureRequestError(error, context: span.traceContext, handler: onRequestError)
             throw error
         }
     }
 
-    private func captureSpan(_ capture: URLSessionTraceCapture) {
-        do {
+    private func captureRequestError(
+        _ requestError: any Error,
+        context: LogBrewTraceContext,
+        handler: (@Sendable (any Error) throws -> Void)?,
+    ) {
+        guard let handler else {
+            return
+        }
+        capture {
+            try LogBrewTrace.withContext(context) {
+                try handler(requestError)
+            }
+        }
+    }
+
+    private func captureSpan(
+        _ eventID: String?,
+        span: LogBrewURLSessionSpan,
+        response: URLResponse? = nil,
+        durationMs: Double,
+        error: (any Error)? = nil,
+        metadata: Metadata?,
+    ) {
+        capture {
             try client.captureURLSessionSpan(
-                capture.eventID ?? nextEventID(),
+                eventID ?? nextEventID(),
                 timestamp: timestampProvider(),
-                span: capture.span,
-                statusCode: (capture.response as? HTTPURLResponse)?.statusCode,
-                durationMs: capture.durationMs,
-                error: capture.error,
-                metadata: capture.metadata,
+                span: span,
+                statusCode: (response as? HTTPURLResponse)?.statusCode,
+                durationMs: durationMs,
+                error: error,
+                metadata: metadata,
             )
+        }
+    }
+
+    private func capture(_ operation: () throws -> Void) {
+        do {
+            try operation()
         } catch {
             onCaptureError?(error)
         }
@@ -113,39 +130,14 @@ public final class LogBrewURLSessionTracer: @unchecked Sendable {
     }
 
     private func nextEventID() -> String {
-        lock.lock()
-        defer {
-            lock.unlock()
+        lock.withLock {
+            let eventID = "\(eventIDPrefix)_\(nextEventSequence)"
+            nextEventSequence += 1
+            return eventID
         }
-        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)
-    }
-}