@logbrew/react-native 0.1.20 → 0.1.22

package/instrumentation.js

@@ -1,634 +1,5 @@
-import { SdkError } from "@logbrew/sdk";
-import {
-  captureReactNativeResourceSpan,
-  createReactNavigationSpanListener,
-  createReactNativeTraceContext,
-  createReactNativeTraceHeaders,
-  getActiveLogBrewTrace,
-  shouldPropagateTraceparent
-} from "./index.js";
-import { createAppStateLifecycleSpanListener } from "./lifecycle.js";
-import { createSafeReactNativeMetadata } from "./metadata.js";
-import {
-  clearLogBrewNativeBridgeScope,
-  syncLogBrewNativeBridgeScope,
-  withLogBrewNativeBridgeScope
-} from "./native-bridge.js";
-import { createReactNativeResourceFetch } from "./resource-fetch.js";
+import implementation from "./instrumentation.cjs";
 
-export function createLogBrewReactNativeInstrumentation(client, {
-  appState,
-  captureInitialLifecycleState = false,
-  captureInitialNavigationRoute = false,
-  fetchImpl,
-  globalObject = globalThis,
-  includeRouteKey = false,
-  instrumentGlobalFetch = false,
-  instrumentGlobalXMLHttpRequest = false,
-  logger,
-  measureFetchResponseBodySize = false,
-  measureXhrResponseBodySize = false,
-  metadata = {},
-  metadataFactory,
-  nativeBridge,
-  navigation,
-  navigationContainer,
-  now = () => new Date().toISOString(),
-  nowMs = () => Date.now(),
-  onError,
-  platform,
-  randomValues,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  traceFlags = "01",
-  tracePropagationTargets = []
-} = {}) {
-  requireClient(client);
-  const activeTrace = resolveInstrumentationTrace({ randomValues, trace, traceFlags });
-  const removers = [];
-  const resolvedNavigation = navigationContainer ?? navigation;
+export const { createLogBrewReactNativeInstrumentation } = implementation;
 
-  if (appState?.addEventListener) {
-    removers.push(createAppStateLifecycleSpanListener(client, appState, {
-      captureInitialState: captureInitialLifecycleState,
-      metadata,
-      now,
-      nowMs,
-      onError,
-      platform,
-      screen,
-      sessionId,
-      trace: activeTrace
-    }));
-  }
-
-  if (resolvedNavigation) {
-    removers.push(createReactNavigationSpanListener(client, resolvedNavigation, {
-      appState,
-      captureInitialRoute: captureInitialNavigationRoute,
-      includeRouteKey,
-      metadata,
-      now,
-      nowMs,
-      onError,
-      platform,
-      trace: activeTrace
-    }));
-  }
-
-  if (nativeBridge) {
-    syncLogBrewNativeBridgeScope(nativeBridge, {
-      logger,
-      metadata,
-      screen,
-      sessionId,
-      source: "react-native.instrumentation",
-      trace: activeTrace
-    });
-  }
-
-  const resourceFetch = createReactNativeResourceFetch(client, {
-    appState,
-    fetchImpl,
-    measureResponseBodySize: measureFetchResponseBodySize,
-    metadata,
-    metadataFactory,
-    now,
-    nowMs,
-    platform,
-    randomValues,
-    routeTemplate,
-    routeTemplateFactory,
-    screen,
-    sessionId,
-    trace: activeTrace,
-    traceFlags,
-    tracePropagationTargets
-  });
-  let globalFetch;
-  let globalXMLHttpRequest;
-  try {
-    globalFetch = instrumentGlobalFetch ? installGlobalFetchInstrumentation(client, {
-      appState,
-      globalObject,
-      measureFetchResponseBodySize,
-      metadata,
-      metadataFactory,
-      now,
-      nowMs,
-      platform,
-      randomValues,
-      routeTemplate,
-      routeTemplateFactory,
-      screen,
-      sessionId,
-      trace: activeTrace,
-      traceFlags,
-      tracePropagationTargets
-    }) : undefined;
-    if (globalFetch) {
-      removers.push(globalFetch.remove);
-    }
-    globalXMLHttpRequest = instrumentGlobalXMLHttpRequest ? installGlobalXMLHttpRequestInstrumentation(client, {
-      appState,
-      globalObject,
-      measureXhrResponseBodySize,
-      metadata,
-      metadataFactory,
-      now,
-      nowMs,
-      platform,
-      routeTemplate,
-      routeTemplateFactory,
-      screen,
-      sessionId,
-      trace: activeTrace,
-      tracePropagationTargets
-    }) : undefined;
-    if (globalXMLHttpRequest) {
-      removers.push(globalXMLHttpRequest.remove);
-    }
-  } catch (error) {
-    removeConfiguredInstrumentation({ nativeBridge, removers });
-    throw error;
-  }
-
-  let removed = false;
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    removeConfiguredInstrumentation({ nativeBridge, removers });
-  };
-
-  const handle = {
-    globalFetch,
-    globalXMLHttpRequest,
-    remove,
-    resourceFetch,
-    stop: remove,
-    syncNativeBridgeScope(options = {}) {
-      if (!nativeBridge) {
-        return undefined;
-      }
-      return syncLogBrewNativeBridgeScope(nativeBridge, {
-        logger,
-        metadata,
-        screen,
-        sessionId,
-        source: "react-native.instrumentation",
-        trace: activeTrace,
-        ...options
-      });
-    },
-    trace: activeTrace,
-    withNativeBridgeScope(callbackOrOptions, maybeCallback) {
-      if (!nativeBridge) {
-        throw new SdkError("configuration_error", "withNativeBridgeScope requires nativeBridge");
-      }
-      if (typeof callbackOrOptions === "function") {
-        return withLogBrewNativeBridgeScope(nativeBridge, {
-          logger,
-          metadata,
-          screen,
-          sessionId,
-          source: "react-native.instrumentation",
-          trace: activeTrace
-        }, callbackOrOptions);
-      }
-      return withLogBrewNativeBridgeScope(nativeBridge, {
-        logger,
-        metadata,
-        screen,
-        sessionId,
-        source: "react-native.instrumentation",
-        trace: activeTrace,
-        ...(callbackOrOptions ?? {})
-      }, maybeCallback);
-    }
-  };
-  return Object.freeze(handle);
-}
-
-function resolveInstrumentationTrace({ randomValues, trace, traceFlags }) {
-  if (typeof trace === "string") {
-    return createReactNativeTraceContext({ randomValues, traceFlags, traceparent: trace });
-  }
-  return trace ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext({ randomValues, traceFlags });
-}
-
-function requireClient(client) {
-  if (!client) {
-    throw new SdkError("configuration_error", "createLogBrewReactNativeInstrumentation requires a client");
-  }
-}
-
-function removeConfiguredInstrumentation({ nativeBridge, removers }) {
-  if (nativeBridge) {
-    clearLogBrewNativeBridgeScope(nativeBridge);
-  }
-  for (const removeListener of removers.splice(0).reverse()) {
-    removeListener();
-  }
-}
-
-function installGlobalFetchInstrumentation(client, {
-  appState,
-  globalObject,
-  measureFetchResponseBodySize,
-  metadata,
-  metadataFactory,
-  now,
-  nowMs,
-  platform,
-  randomValues,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  traceFlags,
-  tracePropagationTargets
-}) {
-  if ((typeof globalObject !== "object" && typeof globalObject !== "function") || globalObject === null) {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch requires a globalObject");
-  }
-  const originalFetch = globalObject.fetch;
-  if (typeof originalFetch !== "function") {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch requires globalObject.fetch");
-  }
-  const globalResourceFetch = createReactNativeResourceFetch(client, {
-    appState,
-    fetchImpl: (input, init) => originalFetch.call(globalObject, input, init),
-    measureResponseBodySize: measureFetchResponseBodySize,
-    metadata,
-    metadataFactory,
-    now,
-    nowMs,
-    platform,
-    randomValues,
-    routeTemplate,
-    routeTemplateFactory,
-    screen,
-    sessionId,
-    trace,
-    traceFlags,
-    tracePropagationTargets
-  });
-  let removed = false;
-  const wrappedFetch = (input, init) => globalResourceFetch(input, init);
-  try {
-    globalObject.fetch = wrappedFetch;
-  } catch {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch could not patch globalObject.fetch");
-  }
-  if (globalObject.fetch !== wrappedFetch) {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch could not patch globalObject.fetch");
-  }
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    if (globalObject.fetch === wrappedFetch) {
-      globalObject.fetch = originalFetch;
-    }
-  };
-  return Object.freeze({
-    fetch: wrappedFetch,
-    remove,
-    stop: remove
-  });
-}
-
-/* eslint-disable no-invalid-this */
-function installGlobalXMLHttpRequestInstrumentation(client, {
-  appState,
-  globalObject,
-  measureXhrResponseBodySize,
-  metadata,
-  metadataFactory,
-  now,
-  nowMs,
-  platform,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  tracePropagationTargets
-}) {
-  if ((typeof globalObject !== "object" && typeof globalObject !== "function") || globalObject === null) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires a globalObject");
-  }
-  const xhrType = globalObject.XMLHttpRequest;
-  if (typeof xhrType !== "function" || !xhrType.prototype) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires globalObject.XMLHttpRequest");
-  }
-  const prototype = xhrType.prototype;
-  const originalOpen = prototype.open;
-  const originalSend = prototype.send;
-  const originalSetRequestHeader = prototype.setRequestHeader;
-  if (typeof originalOpen !== "function" || typeof originalSend !== "function" || typeof originalSetRequestHeader !== "function") {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires open, send, and setRequestHeader");
-  }
-
-  const contextKey = Symbol("logbrew.xhr");
-  const headersReceivedState = typeof xhrType.HEADERS_RECEIVED === "number" ? xhrType.HEADERS_RECEIVED : 2;
-  const doneState = typeof xhrType.DONE === "number" ? xhrType.DONE : 4;
-  const safeRouteTemplateFactory = routeTemplateFactory ?? defaultXhrRouteTemplateFactory;
-
-  function wrappedOpen(method, url) {
-    this[contextKey] = {
-      method: normalizeXhrMethod(method),
-      reported: false,
-      url: xhrUrl(url)
-    };
-    return originalOpen.apply(this, arguments);
-  }
-
-  function wrappedSend(body) {
-    const context = this[contextKey];
-    if (!context) {
-      return originalSend.apply(this, arguments);
-    }
-    context.body = xhrRequestBody(body);
-    context.startedAtMs = nowMs();
-    context.timestamp = now();
-    installXhrReadyStateTracker(this, context, {
-      appState,
-      client,
-      doneState,
-      headersReceivedState,
-      measureXhrResponseBodySize,
-      metadata,
-      metadataFactory,
-      nowMs,
-      platform,
-      routeTemplate,
-      routeTemplateFactory: safeRouteTemplateFactory,
-      screen,
-      sessionId,
-      trace
-    });
-    if (shouldPropagateTraceparent(context.url, tracePropagationTargets)) {
-      originalSetRequestHeader.call(this, "traceparent", createReactNativeTraceHeaders(trace).traceparent);
-    }
-    try {
-      return originalSend.apply(this, arguments);
-    } catch (error) {
-      captureXhrResourceSpan(this, context, {
-        appState,
-        client,
-        metadata: {
-          ...metadata,
-          xhrErrorName: errorName(error),
-          xhrErrorValueType: typeof error
-        },
-        metadataFactory,
-        nowMs,
-        platform,
-        routeTemplate,
-        routeTemplateFactory: safeRouteTemplateFactory,
-        screen,
-        sessionId,
-        status: "error",
-        trace
-      });
-      throw error;
-    }
-  }
-
-  prototype.open = wrappedOpen;
-  prototype.send = wrappedSend;
-  if (prototype.open !== wrappedOpen || prototype.send !== wrappedSend) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest could not patch XMLHttpRequest");
-  }
-
-  let removed = false;
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    if (prototype.open === wrappedOpen) {
-      prototype.open = originalOpen;
-    }
-    if (prototype.send === wrappedSend) {
-      prototype.send = originalSend;
-    }
-  };
-
-  return Object.freeze({
-    remove,
-    stop: remove
-  });
-}
-
-function installXhrReadyStateTracker(xhr, context, options) {
-  const onReadyStateChange = () => {
-    if (xhr.readyState === options.headersReceivedState && context.responseStartAtMs === undefined) {
-      context.responseStartAtMs = options.nowMs();
-      return;
-    }
-    if (xhr.readyState === options.doneState && !context.reported) {
-      captureXhrResourceSpan(xhr, context, options);
-    }
-  };
-  if (typeof xhr.addEventListener === "function") {
-    xhr.addEventListener("readystatechange", onReadyStateChange);
-    return;
-  }
-  const originalOnReadyStateChange = xhr.onreadystatechange;
-  xhr.onreadystatechange = function logBrewOnReadyStateChange() {
-    onReadyStateChange();
-    if (typeof originalOnReadyStateChange === "function") {
-      return originalOnReadyStateChange.apply(this, arguments);
-    }
-    return undefined;
-  };
-}
-
-function captureXhrResourceSpan(xhr, context, {
-  appState,
-  client,
-  measureXhrResponseBodySize,
-  metadata,
-  metadataFactory,
-  nowMs,
-  platform,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  status,
-  trace
-}) {
-  if (context.reported) {
-    return;
-  }
-  context.reported = true;
-  const durationMs = elapsedMs(context.startedAtMs, nowMs);
-  const responseStartDurationMs = context.responseStartAtMs === undefined
-    ? undefined
-    : elapsedMs(context.startedAtMs, () => context.responseStartAtMs);
-  const responseSizeBytes = xhrResponseSizeBytes(xhr, { measureXhrResponseBodySize });
-  const safeRouteTemplate = routeTemplate ?? routeTemplateFactory({ url: context.url });
-  const statusCode = xhrStatusCode(xhr);
-  captureReactNativeResourceSpan(client, {
-    appState,
-    durationMs,
-    metadata: {
-      ...createSafeReactNativeMetadata(metadata, metadataFactory, {
-        durationMs,
-        init: context.body === undefined ? undefined : { body: context.body },
-        input: context.url,
-        method: context.method,
-        routeTemplate: safeRouteTemplate,
-        status: status ?? undefined,
-        statusCode,
-        url: context.url
-      }),
-      responseStartDurationMs,
-      transport: "xhr"
-    },
-    method: context.method,
-    platform,
-    routeTemplate: safeRouteTemplate,
-    screen,
-    responseSizeBytes,
-    sessionId,
-    status: status ?? undefined,
-    statusCode,
-    timestamp: context.timestamp,
-    trace
-  });
-}
-
-function normalizeXhrMethod(method) {
-  return String(method ?? "GET").toUpperCase();
-}
-
-function xhrUrl(url) {
-  if (typeof url === "string") {
-    return url;
-  }
-  try {
-    return url.toString();
-  } catch {
-    return String(url);
-  }
-}
-
-function xhrRequestBody(body) {
-  if (typeof body === "string") {
-    return body;
-  }
-  if (body instanceof String) {
-    return body.toString();
-  }
-  return undefined;
-}
-
-function defaultXhrRouteTemplateFactory({ url }) {
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function") {
-    try {
-      const parsedUrl = new URLConstructor(url, "https://logbrew.local");
-      return parsedUrl.pathname;
-    } catch {
-      // Fall back to query/hash stripping below for non-standard request keys.
-    }
-  }
-  return String(url).split(/[?#]/u, 1)[0];
-}
-
-function elapsedMs(startedAtMs, nowMs) {
-  const durationMs = nowMs() - startedAtMs;
-  return Number.isFinite(durationMs) ? Math.max(0, durationMs) : undefined;
-}
-
-function xhrStatusCode(xhr) {
-  return typeof xhr?.status === "number" && Number.isFinite(xhr.status) ? xhr.status : undefined;
-}
-
-function xhrResponseSizeBytes(xhr, { measureXhrResponseBodySize = false } = {}) {
-  if (typeof xhr?.getResponseHeader !== "function") {
-    return measureXhrResponseBodySize ? xhrResponseBodySizeBytes(xhr) : undefined;
-  }
-  const contentLength = Number.parseInt(String(xhr.getResponseHeader("Content-Length") ?? ""), 10);
-  if (Number.isFinite(contentLength) && contentLength >= 0) {
-    return contentLength;
-  }
-  return measureXhrResponseBodySize ? xhrResponseBodySizeBytes(xhr) : undefined;
-}
-
-function xhrResponseBodySizeBytes(xhr) {
-  const responseType = readXhrResponseValue(xhr, "responseType");
-  if (responseType === undefined || responseType === "" || responseType === "text") {
-    const responseText = readXhrResponseValue(xhr, "responseText");
-    if (typeof responseText === "string" || responseText instanceof String) {
-      return utf8ByteLength(responseText.toString());
-    }
-  }
-  const response = readXhrResponseValue(xhr, "response");
-  if (typeof response === "string" || response instanceof String) {
-    return utf8ByteLength(response.toString());
-  }
-  if (typeof ArrayBuffer === "function") {
-    if (response instanceof ArrayBuffer) {
-      return response.byteLength;
-    }
-    if (typeof ArrayBuffer.isView === "function" && ArrayBuffer.isView(response)) {
-      return response.byteLength;
-    }
-  }
-  if (typeof response?.size === "number" && Number.isFinite(response.size) && response.size >= 0) {
-    return response.size;
-  }
-  return undefined;
-}
-
-function readXhrResponseValue(xhr, property) {
-  try {
-    return xhr?.[property];
-  } catch {
-    return undefined;
-  }
-}
-
-function utf8ByteLength(value) {
-  let bytes = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code <= 0x7f) {
-      bytes += 1;
-    } else if (code <= 0x7ff) {
-      bytes += 2;
-    } else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
-      const next = value.charCodeAt(index + 1);
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        bytes += 4;
-        index += 1;
-      } else {
-        bytes += 3;
-      }
-    } else {
-      bytes += 3;
-    }
-  }
-  return bytes;
-}
-
-function errorName(error) {
-  return typeof error?.name === "string" && error.name.trim() !== "" ? error.name : "Error";
-}
-/* eslint-enable no-invalid-this */
-
-export default {
-  createLogBrewReactNativeInstrumentation
-};
+export default implementation.default;

package/ios/AppleDiagnostics/LBRNAppleDiagnosticsModule.mm

@@ -45,6 +45,11 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(setNativeDiagnosticsContext:(NSDictionary
     return [LBRNAppleNativeDiagnostics setCorrelationContext:context];
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(setNativeDiagnosticsBreadcrumbs:(NSDictionary *)snapshot)
+{
+    return [LBRNAppleNativeDiagnostics setBreadcrumbs:snapshot];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(nativeDiagnosticsStatus)
 {
     return [LBRNAppleNativeDiagnostics status];

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.20"
+    private static let sdkVersion = "0.1.22"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")
@@ -44,6 +44,11 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
         shared.updateCorrelationContext(rawContext)
     }
 
+    @objc(setBreadcrumbs:)
+    public static func setBreadcrumbs(_ rawSnapshot: NSDictionary?) -> NSDictionary {
+        shared.updateBreadcrumbs(rawSnapshot)
+    }
+
     private func installOnMainThread(_ rawConfiguration: NSDictionary) -> NSDictionary {
         guard let configuration = InstalledConfiguration(rawConfiguration) else {
             return failure("native_diagnostics_invalid_configuration")
@@ -144,8 +149,11 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
             return failure("native_diagnostics_not_installed")
         }
         do {
-            let context = try rawContext.map { try NativeCrashCorrelation.validated($0) }
-            try capture.setCorrelationContext(context)
+            let snapshot = try rawContext.map { try NativeCrashCorrelation.validated($0) }
+            try capture.setDiagnosticContext(
+                context: snapshot?.correlationContext,
+                impact: snapshot?.impact,
+            )
             return ["status": rawContext == nil ? "cleared" : "updated"]
         } catch let error as NativeCrashError {
             return failure(error.code.rawValue)
@@ -154,6 +162,26 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
         }
     }
 
+    private func updateBreadcrumbs(_ rawSnapshot: NSDictionary?) -> NSDictionary {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let capture else {
+            return failure("native_diagnostics_not_installed")
+        }
+        do {
+            let snapshot = try rawSnapshot.map { try NativeCrashBreadcrumbs.validated($0) }
+            try capture.setBreadcrumbs(
+                snapshot?.breadcrumbs,
+                truncated: snapshot?.truncated ?? false,
+            )
+            return ["status": rawSnapshot == nil ? "cleared" : "updated"]
+        } catch let error as NativeCrashError {
+            return failure(error.code.rawValue)
+        } catch {
+            return failure("native_diagnostics_failed")
+        }
+    }
+
     private func captureStatus(status: String) -> NSDictionary {
         guard let capture else {
             return failure("native_diagnostics_not_installed")