@logbrew/react-native 0.1.0 → 0.1.1

package/examples/instrumentation-kit.mjs

@@ -0,0 +1,304 @@
+import { RecordingTransport } from "@logbrew/sdk";
+import {
+  createLogBrewReactNativeClient,
+  createReactNativeTraceContext
+} from "@logbrew/react-native";
+import { createLogBrewReactNativeInstrumentation } from "@logbrew/react-native/instrumentation";
+
+const platform = {
+  OS: "ios",
+  Version: "18.5",
+  isPad: false,
+  constants: { isTesting: true }
+};
+const appStateListeners = new Set();
+const appState = {
+  currentState: "active",
+  addEventListener(_type, listener) {
+    appStateListeners.add(listener);
+    return {
+      remove() {
+        appStateListeners.delete(listener);
+      }
+    };
+  }
+};
+const navigationListeners = new Map();
+const navigation = {
+  route: { key: "Checkout-abc123", name: "Checkout", path: "/checkout?email=dev@example.test" },
+  addListener(name, listener) {
+    navigationListeners.set(name, listener);
+    return {
+      remove() {
+        navigationListeners.delete(name);
+      }
+    };
+  },
+  getCurrentRoute() {
+    return this.route;
+  }
+};
+const nativeBridgeCalls = [];
+const nativeBridge = {
+  setLogBrewScope(scope) {
+    nativeBridgeCalls.push({ kind: "set", scope });
+  },
+  clearLogBrewScope() {
+    nativeBridgeCalls.push({ kind: "clear" });
+  }
+};
+const requests = [];
+const globalObject = {
+  async fetch(input, init = {}) {
+    requests.push({ input, init, source: "global" });
+    return { status: 206 };
+  }
+};
+class MockXMLHttpRequest {
+  static HEADERS_RECEIVED = 2;
+  static DONE = 4;
+
+  constructor() {
+    this.headers = {};
+    this.listeners = new Map();
+    this.readyState = 0;
+    this.status = 0;
+  }
+
+  addEventListener(name, listener) {
+    this.listeners.set(name, listener);
+  }
+
+  open(method, url) {
+    this.method = method;
+    this.url = url;
+  }
+
+  send(body) {
+    requests.push({
+      body,
+      headers: { ...this.headers },
+      method: this.method,
+      source: "xhr",
+      url: this.url
+    });
+    this.readyState = MockXMLHttpRequest.HEADERS_RECEIVED;
+    this.onreadystatechange?.();
+    this.listeners.get("readystatechange")?.();
+    this.status = 207;
+    this.readyState = MockXMLHttpRequest.DONE;
+    this.onreadystatechange?.();
+    this.listeners.get("readystatechange")?.();
+  }
+
+  getResponseHeader(name) {
+    if (String(name).toLowerCase() === "content-length") {
+      return "2048";
+    }
+    return null;
+  }
+
+  setRequestHeader(name, value) {
+    this.headers[String(name).toLowerCase()] = String(value);
+  }
+}
+globalObject.XMLHttpRequest = MockXMLHttpRequest;
+const originalGlobalFetch = globalObject.fetch;
+const originalXhrOpen = MockXMLHttpRequest.prototype.open;
+const originalXhrSend = MockXMLHttpRequest.prototype.send;
+const originalXhrSetRequestHeader = MockXMLHttpRequest.prototype.setRequestHeader;
+const client = createLogBrewReactNativeClient({
+  clientKey: "LOGBREW_CLIENT_KEY",
+  sdkName: "logbrew-react-native-instrumentation-kit",
+  sdkVersion: "0.1.0",
+  maxRetries: 1
+});
+const trace = createReactNativeTraceContext({
+  traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+  spanId: "e2ad6b7169206664"
+});
+const timestamps = [
+  "2026-06-02T10:40:00Z",
+  "2026-06-02T10:40:01Z",
+  "2026-06-02T10:40:02Z",
+  "2026-06-02T10:40:03Z",
+  "2026-06-02T10:40:04Z",
+  "2026-06-02T10:40:05Z",
+  "2026-06-02T10:40:06Z"
+];
+const times = [1000, 1125, 1260, 1300, 1380, 1600, 1775, 1900, 1920, 1945, 2100, 2115, 2160];
+
+const instrumentation = createLogBrewReactNativeInstrumentation(client, {
+  appState,
+  captureInitialLifecycleState: true,
+  captureInitialNavigationRoute: true,
+  fetchImpl: async (input, init = {}) => {
+    requests.push({ input, init, source: "resourceFetch" });
+    return { status: 202 };
+  },
+  globalObject,
+  instrumentGlobalFetch: true,
+  instrumentGlobalXMLHttpRequest: true,
+  logger: "NativeCheckout",
+  metadata: { flow: "checkout", nested: { dropped: true }, traceId: "spoofed" },
+  nativeBridge,
+  navigationContainer: navigation,
+  now: () => timestamps.shift(),
+  nowMs: () => times.shift(),
+  platform,
+  screen: "Checkout",
+  sessionId: "session_mobile_001",
+  trace,
+  tracePropagationTargets: ["https://api.example.test/"]
+});
+
+await instrumentation.withNativeBridgeScope(async (scope) => {
+  client.log("evt_instrumentation_native_bridge", "2026-06-02T10:40:02Z", {
+    message: "native bridge work started",
+    level: "info",
+    logger: "NativeCheckout",
+    metadata: {
+      ...scope.metadata,
+      ...scope.trace
+    }
+  });
+});
+
+await instrumentation.resourceFetch("https://api.example.test/api/checkout?email=dev@example.test#pay", {
+  method: "POST",
+  headers: { accept: "application/json" }
+});
+
+navigationListeners.get("__unsafe_action__")?.({ data: { action: { type: "NAVIGATE" } } });
+navigation.route = {
+  key: "CheckoutComplete-def456",
+  name: "CheckoutComplete",
+  path: "/checkout/complete?email=dev@example.test#done"
+};
+navigationListeners.get("state")?.();
+
+appState.currentState = "background";
+for (const listener of appStateListeners) {
+  listener("background");
+}
+
+if (globalObject.fetch === originalGlobalFetch) {
+  throw new Error("instrumentGlobalFetch should patch the supplied global object");
+}
+await globalObject.fetch("https://api.example.test/api/global?email=dev@example.test#pay", {
+  method: "GET"
+});
+if (MockXMLHttpRequest.prototype.open === originalXhrOpen) {
+  throw new Error("instrumentGlobalXMLHttpRequest should patch the supplied XMLHttpRequest prototype");
+}
+const xhr = new globalObject.XMLHttpRequest();
+xhr.open("PUT", "https://api.example.test/api/xhr?email=dev@example.test#pay");
+xhr.setRequestHeader("Accept", "application/json");
+xhr.send("ignored-body");
+
+instrumentation.remove();
+navigation.route = { key: "Ignored-ghi789", name: "Ignored", path: "/ignored" };
+navigationListeners.get("state")?.();
+for (const listener of appStateListeners) {
+  listener("active");
+}
+instrumentation.stop();
+if (globalObject.fetch !== originalGlobalFetch) {
+  throw new Error("instrumentation remove should put global fetch back");
+}
+if (
+  MockXMLHttpRequest.prototype.open !== originalXhrOpen ||
+  MockXMLHttpRequest.prototype.send !== originalXhrSend ||
+  MockXMLHttpRequest.prototype.setRequestHeader !== originalXhrSetRequestHeader
+) {
+  throw new Error("instrumentation remove should put XHR open/send back and leave setRequestHeader untouched");
+}
+
+const events = JSON.parse(client.previewJson()).events;
+if (events.length !== 8) {
+  throw new Error(`expected eight instrumentation events, got ${events.length}`);
+}
+if (requests[0].init.headers.traceparent !== `00-${trace.traceId}-${trace.spanId}-01`) {
+  throw new Error(`expected propagated traceparent, got ${requests[0].init.headers.traceparent}`);
+}
+if (requests[1].init.headers.traceparent !== `00-${trace.traceId}-${trace.spanId}-01`) {
+  throw new Error(`expected global fetch traceparent, got ${requests[1].init.headers.traceparent}`);
+}
+if (requests[2].headers.traceparent !== `00-${trace.traceId}-${trace.spanId}-01`) {
+  throw new Error(`expected global XHR traceparent, got ${requests[2].headers.traceparent}`);
+}
+if (appStateListeners.size !== 0 || navigationListeners.size !== 0) {
+  throw new Error("instrumentation remove should detach lifecycle and navigation listeners");
+}
+if (nativeBridgeCalls.map((call) => call.kind).join(",") !== "set,set,clear,clear") {
+  throw new Error(`unexpected native bridge calls: ${JSON.stringify(nativeBridgeCalls)}`);
+}
+for (const event of events) {
+  const metadata = event.attributes.metadata ?? {};
+  if (event.type !== "span" && event.type !== "log") {
+    throw new Error(`unexpected instrumentation event type: ${event.type}`);
+  }
+  if (metadata.traceId !== trace.traceId || metadata.spanId !== trace.spanId) {
+    throw new Error(`instrumentation event should share trace metadata: ${JSON.stringify(event)}`);
+  }
+  if (metadata.nested !== undefined) {
+    throw new Error(`nested metadata should be dropped: ${JSON.stringify(metadata)}`);
+  }
+}
+const sources = events.map((event) => event.attributes.metadata?.source);
+if (!sources.includes("react-native.lifecycle") || !sources.includes("react-native.navigation")) {
+  throw new Error(`expected lifecycle and navigation sources: ${JSON.stringify(sources)}`);
+}
+if (!sources.includes("react-native.resource") || !sources.includes("react-native.instrumentation")) {
+  throw new Error(`expected resource and instrumentation sources: ${JSON.stringify(sources)}`);
+}
+const resource = events.find((event) => event.attributes.metadata?.source === "react-native.resource")?.attributes;
+if (
+  resource?.name !== "POST /api/checkout" ||
+  resource.durationMs !== 175 ||
+  resource.metadata.routeTemplate !== "/api/checkout" ||
+  resource.metadata.responseStartDurationMs !== 135
+) {
+  throw new Error(`unexpected resource span: ${JSON.stringify(resource)}`);
+}
+const globalResource = events.find((event) => event.attributes.name === "GET /api/global")?.attributes;
+if (
+  globalResource?.durationMs !== 45 ||
+  globalResource.metadata.routeTemplate !== "/api/global" ||
+  globalResource.metadata.responseStartDurationMs !== 20 ||
+  globalResource.metadata.statusCode !== 206
+) {
+  throw new Error(`unexpected global fetch span: ${JSON.stringify(globalResource)}`);
+}
+const xhrResource = events.find((event) => event.attributes.name === "PUT /api/xhr")?.attributes;
+if (
+  xhrResource?.metadata.routeTemplate !== "/api/xhr" ||
+  xhrResource.metadata.statusCode !== 207 ||
+  xhrResource.metadata.responseStartDurationMs !== 15 ||
+  xhrResource.metadata.responseSizeBytes !== 2048 ||
+  xhrResource.metadata.body !== undefined
+) {
+  throw new Error(`unexpected global XHR span: ${JSON.stringify(xhrResource)}`);
+}
+const navigationSpan = events.find((event) => event.attributes.name === "navigation:CheckoutComplete")?.attributes;
+if (navigationSpan?.durationMs !== 220 || navigationSpan.metadata.routePath !== "/checkout/complete") {
+  throw new Error(`unexpected navigation span: ${JSON.stringify(navigationSpan)}`);
+}
+const lifecycleSpan = events.find((event) => event.attributes.name === "app_state:active->background")?.attributes;
+if (lifecycleSpan?.durationMs !== 775 || lifecycleSpan.metadata.toAppState !== "background") {
+  throw new Error(`unexpected lifecycle span: ${JSON.stringify(lifecycleSpan)}`);
+}
+
+const preview = client.previewJson();
+const response = await client.shutdown(RecordingTransport.alwaysAccept());
+console.log(preview);
+console.error(JSON.stringify({
+  ok: true,
+  calls: nativeBridgeCalls.map((call) => call.kind),
+  events: events.length,
+  globalFetchPutBack: globalObject.fetch === originalGlobalFetch,
+  globalXMLHttpRequestPutBack: MockXMLHttpRequest.prototype.open === originalXhrOpen,
+  propagatedTraceparent: requests[0].init.headers.traceparent,
+  status: response.statusCode,
+  traceId: trace.traceId
+}));

package/examples/lifecycle-spans.mjs

@@ -0,0 +1,131 @@
+import { RecordingTransport } from "@logbrew/sdk";
+import {
+  createLogBrewReactNativeClient,
+  createReactNativeTraceContext
+} from "@logbrew/react-native";
+import { createAppStateLifecycleSpanListener } from "@logbrew/react-native/lifecycle";
+
+const platform = {
+  OS: "ios",
+  Version: "18.0",
+  isPad: false,
+  constants: { isTesting: true }
+};
+const listeners = new Set();
+const appState = {
+  currentState: "active",
+  addEventListener(type, listener) {
+    if (type !== "change") {
+      throw new Error(`unexpected listener type: ${type}`);
+    }
+    listeners.add(listener);
+    return {
+      remove() {
+        listeners.delete(listener);
+      }
+    };
+  }
+};
+const client = createLogBrewReactNativeClient({
+  clientKey: "LOGBREW_CLIENT_KEY",
+  sdkName: "logbrew-react-native-lifecycle-spans",
+  sdkVersion: "0.1.0",
+  maxRetries: 1
+});
+const trace = createReactNativeTraceContext({
+  traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+  spanId: "c2ad6b7169204442"
+});
+const timestamps = [
+  "2026-06-02T10:30:00Z",
+  "2026-06-02T10:30:01Z",
+  "2026-06-02T10:30:02Z",
+  "2026-06-02T10:30:03Z"
+];
+const timeMs = [1000, 1120, 1400, 1415];
+
+const stopLifecycle = createAppStateLifecycleSpanListener(client, appState, {
+  captureInitialState: true,
+  metadata: { flow: "checkout", nested: { dropped: true } },
+  now: () => timestamps.shift(),
+  nowMs: () => timeMs.shift(),
+  platform,
+  screen: "Checkout",
+  sessionId: "session_mobile_001",
+  trace
+});
+
+emitAppState("inactive");
+emitAppState("background");
+emitAppState("active");
+stopLifecycle();
+emitAppState("background");
+
+const events = JSON.parse(client.previewJson()).events;
+if (events.length !== 4) {
+  throw new Error(`expected four lifecycle spans, got ${events.length}`);
+}
+for (const event of events) {
+  if (event.type !== "span") {
+    throw new Error(`expected span event, got ${event.type}`);
+  }
+  const metadata = event.attributes.metadata ?? {};
+  if (event.attributes.traceId !== trace.traceId || metadata.traceId !== trace.traceId) {
+    throw new Error(`lifecycle span should share trace: ${JSON.stringify(event)}`);
+  }
+  if (metadata.source !== "react-native.lifecycle" || metadata.screen !== "Checkout") {
+    throw new Error(`unexpected lifecycle metadata: ${JSON.stringify(metadata)}`);
+  }
+  if (metadata.nested !== undefined) {
+    throw new Error("nested lifecycle metadata should be dropped");
+  }
+}
+const initial = events[0].attributes;
+if (initial.name !== "app_state:active" || initial.metadata.toAppState !== "active") {
+  throw new Error(`unexpected initial lifecycle span: ${JSON.stringify(initial)}`);
+}
+const inactive = events[1].attributes;
+if (
+  inactive.name !== "app_state:active->inactive" ||
+  inactive.durationMs !== 120 ||
+  inactive.metadata.fromAppState !== "active" ||
+  inactive.metadata.toAppState !== "inactive"
+) {
+  throw new Error(`unexpected inactive lifecycle span: ${JSON.stringify(inactive)}`);
+}
+const background = events[2].attributes;
+if (
+  background.name !== "app_state:inactive->background" ||
+  background.durationMs !== 280 ||
+  background.metadata.appState !== "background"
+) {
+  throw new Error(`unexpected background lifecycle span: ${JSON.stringify(background)}`);
+}
+const foreground = events[3].attributes;
+if (
+  foreground.name !== "app_state:background->active" ||
+  foreground.durationMs !== 15 ||
+  foreground.metadata.appState !== "active"
+) {
+  throw new Error(`unexpected foreground lifecycle span: ${JSON.stringify(foreground)}`);
+}
+
+const preview = client.previewJson();
+const response = await client.shutdown(RecordingTransport.alwaysAccept());
+console.log(preview);
+console.error(JSON.stringify({
+  ok: true,
+  events: events.length,
+  status: response.statusCode,
+  inactiveSpan: inactive.name,
+  backgroundSpan: background.name,
+  listenerRemoved: listeners.size === 0,
+  traceId: trace.traceId
+}));
+
+function emitAppState(state) {
+  appState.currentState = state;
+  for (const listener of Array.from(listeners)) {
+    listener(state);
+  }
+}

package/examples/native-bridge-scope.mjs

@@ -0,0 +1,107 @@
+import { RecordingTransport } from "@logbrew/sdk";
+import {
+  createLogBrewReactNativeClient,
+  createReactNativeTraceContext
+} from "@logbrew/react-native";
+import {
+  createLogBrewNativeBridgeScope,
+  syncLogBrewNativeBridgeScope,
+  withLogBrewNativeBridgeScope
+} from "@logbrew/react-native/native-bridge";
+
+const client = createLogBrewReactNativeClient({
+  clientKey: "LOGBREW_CLIENT_KEY",
+  sdkName: "logbrew-react-native-native-bridge",
+  sdkVersion: "0.1.0",
+  maxRetries: 1
+});
+const trace = createReactNativeTraceContext({
+  traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+  spanId: "d2ad6b7169205553"
+});
+const calls = [];
+const nativeBridge = {
+  currentScope: undefined,
+  setLogBrewScope(scope) {
+    calls.push({ kind: "set", scope });
+    this.currentScope = scope;
+  },
+  clearLogBrewScope() {
+    calls.push({ kind: "clear" });
+    this.currentScope = undefined;
+  }
+};
+
+const previewScope = createLogBrewNativeBridgeScope({
+  logger: "NativeCheckout",
+  metadata: { routeTemplate: "/native/checkout", nested: { dropped: true }, traceId: "spoofed" },
+  screen: "Checkout",
+  sessionId: "session_mobile_001",
+  trace
+});
+if (previewScope.trace.traceId !== trace.traceId || previewScope.trace.spanId !== trace.spanId) {
+  throw new Error(`unexpected preview trace scope: ${JSON.stringify(previewScope)}`);
+}
+if (previewScope.metadata.nested !== undefined || previewScope.metadata.traceId !== undefined) {
+  throw new Error(`bridge preview metadata should be primitive-only: ${JSON.stringify(previewScope.metadata)}`);
+}
+
+const syncedScope = syncLogBrewNativeBridgeScope(nativeBridge, {
+  logger: "NativeCheckout",
+  metadata: { routeTemplate: "/native/preview" },
+  screen: "Checkout",
+  trace
+});
+if (nativeBridge.currentScope?.trace?.traceId !== trace.traceId) {
+  throw new Error("native bridge should receive synced trace scope");
+}
+if (syncedScope.metadata.routeTemplate !== "/native/preview") {
+  throw new Error(`unexpected synced scope metadata: ${JSON.stringify(syncedScope.metadata)}`);
+}
+
+await withLogBrewNativeBridgeScope(nativeBridge, {
+  logger: "NativeCheckout",
+  metadata: { routeTemplate: "/native/checkout", nested: { dropped: true } },
+  screen: "Checkout",
+  sessionId: "session_mobile_001",
+  trace
+}, async (scope) => {
+  if (nativeBridge.currentScope?.trace?.spanId !== trace.spanId) {
+    throw new Error("native bridge scope should be active during async callback");
+  }
+  client.log("evt_native_bridge_scope", "2026-06-02T10:30:00Z", {
+    message: "native bridge scope synced",
+    level: "info",
+    logger: "NativeCheckout",
+    metadata: {
+      ...scope.metadata,
+      ...scope.trace
+    }
+  });
+});
+if (nativeBridge.currentScope !== undefined) {
+  throw new Error("native bridge scope should be cleared after callback");
+}
+const events = JSON.parse(client.previewJson()).events;
+const event = events[0]?.attributes;
+if (
+  events.length !== 1 ||
+  event.metadata.traceId !== trace.traceId ||
+  event.metadata.spanId !== trace.spanId ||
+  event.metadata.parentSpanId !== trace.parentSpanId ||
+  event.metadata.nested !== undefined
+) {
+  throw new Error(`unexpected native bridge event: ${JSON.stringify(events)}`);
+}
+
+const preview = client.previewJson();
+const response = await client.shutdown(RecordingTransport.alwaysAccept());
+console.log(preview);
+console.error(JSON.stringify({
+  ok: true,
+  calls: calls.map((call) => call.kind),
+  events: events.length,
+  status: response.statusCode,
+  traceId: trace.traceId,
+  spanId: trace.spanId
+}));

package/examples/navigation-resource-spans.mjs

@@ -0,0 +1,156 @@
+import { RecordingTransport } from "@logbrew/sdk";
+import {
+  captureReactNativeResourceSpan,
+  createLogBrewReactNativeClient,
+  createReactNavigationSpanListener,
+  createReactNativeResourceSpanEvent,
+  createReactNativeTraceContext,
+  withLogBrewTrace
+} from "@logbrew/react-native";
+
+const platform = {
+  OS: "android",
+  Version: "16",
+  isPad: false,
+  constants: { isTesting: true }
+};
+const appState = { currentState: "active" };
+const client = createLogBrewReactNativeClient({
+  clientKey: "LOGBREW_CLIENT_KEY",
+  sdkName: "logbrew-react-native-navigation-resource-spans",
+  sdkVersion: "0.1.0",
+  maxRetries: 1
+});
+const trace = createReactNativeTraceContext({
+  traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+  spanId: "c2ad6b7169204442"
+});
+const routeListeners = new Map();
+const navigation = {
+  route: { key: "Checkout-abc123", name: "Checkout", path: "/checkout?email=dev@example.test" },
+  addListener(name, listener) {
+    routeListeners.set(name, listener);
+    return {
+      remove() {
+        routeListeners.delete(name);
+      }
+    };
+  },
+  getCurrentRoute() {
+    return this.route;
+  }
+};
+const timestamps = [
+  "2026-06-02T10:20:00Z",
+  "2026-06-02T10:20:01Z",
+  "2026-06-02T10:20:02Z"
+];
+const timeMs = [1000, 1128, 1171];
+
+withLogBrewTrace(trace, () => {
+  const stopNavigation = createReactNavigationSpanListener(client, navigation, {
+    captureInitialRoute: true,
+    metadata: { flow: "checkout", nested: { dropped: true } },
+    now: () => timestamps.shift(),
+    nowMs: () => timeMs.shift(),
+    platform,
+    appState
+  });
+
+  routeListeners.get("__unsafe_action__")?.({ data: { action: { type: "NAVIGATE" } } });
+  navigation.route = {
+    key: "CheckoutComplete-def456",
+    name: "CheckoutComplete",
+    path: "/checkout/complete?email=dev@example.test#done"
+  };
+  routeListeners.get("state")?.();
+  stopNavigation();
+
+  captureReactNativeResourceSpan(client, {
+    id: "evt_resource_checkout_post",
+    timestamp: "2026-06-02T10:20:03Z",
+    durationMs: 171,
+    method: "post",
+    routeTemplate: "/api/checkout?email=dev@example.test#pay",
+    statusCode: 202,
+    responseSizeBytes: 512,
+    screen: "CheckoutComplete",
+    sessionId: "session_mobile_001",
+    platform,
+    appState
+  });
+});
+
+const directResource = createReactNativeResourceSpanEvent({
+  id: "evt_resource_checkout_retry",
+  timestamp: "2026-06-02T10:20:04Z",
+  durationMs: 88,
+  method: "get",
+  routeTemplate: "/api/cart?itemId=123#items",
+  statusCode: 503,
+  screen: "Checkout",
+  trace
+});
+client.span(directResource.id, directResource.timestamp, directResource.attributes);
+
+const events = JSON.parse(client.previewJson()).events;
+if (events.length !== 4) {
+  throw new Error(`expected four span events, got ${events.length}`);
+}
+for (const event of events) {
+  if (event.type !== "span") {
+    throw new Error(`expected span event, got ${event.type}`);
+  }
+  if (event.attributes.traceId !== trace.traceId) {
+    throw new Error(`span should share trace: ${JSON.stringify(event)}`);
+  }
+  const metadata = event.attributes.metadata ?? {};
+  if (metadata.traceId !== trace.traceId || metadata.spanId !== trace.spanId) {
+    throw new Error(`span metadata should include trace fields: ${JSON.stringify(metadata)}`);
+  }
+  if (metadata.routeKey !== undefined || metadata.previousRouteKey !== undefined) {
+    throw new Error("route keys should be opt-in to avoid high-cardinality defaults");
+  }
+  if (metadata.nested !== undefined) {
+    throw new Error("nested metadata should be dropped");
+  }
+}
+const initialNavigation = events[0].attributes;
+if (initialNavigation.name !== "navigation:Checkout" || initialNavigation.metadata.previousRouteName !== undefined) {
+  throw new Error(`unexpected initial navigation span: ${JSON.stringify(initialNavigation)}`);
+}
+const changedNavigation = events[1].attributes;
+if (
+  changedNavigation.name !== "navigation:CheckoutComplete" ||
+  changedNavigation.durationMs !== 128 ||
+  changedNavigation.metadata.routePath !== "/checkout/complete" ||
+  changedNavigation.metadata.actionType !== "NAVIGATE" ||
+  changedNavigation.metadata.previousRouteName !== "Checkout"
+) {
+  throw new Error(`unexpected route change span: ${JSON.stringify(changedNavigation)}`);
+}
+const resourceSpan = events[2].attributes;
+if (
+  resourceSpan.name !== "POST /api/checkout" ||
+  resourceSpan.status !== "ok" ||
+  resourceSpan.metadata.routeTemplate !== "/api/checkout" ||
+  resourceSpan.metadata.responseSizeBytes !== 512
+) {
+  throw new Error(`unexpected resource span: ${JSON.stringify(resourceSpan)}`);
+}
+const failedResourceSpan = events[3].attributes;
+if (failedResourceSpan.name !== "GET /api/cart" || failedResourceSpan.status !== "error") {
+  throw new Error(`unexpected failed resource span: ${JSON.stringify(failedResourceSpan)}`);
+}
+
+const preview = client.previewJson();
+const response = await client.shutdown(RecordingTransport.alwaysAccept());
+console.log(preview);
+console.error(JSON.stringify({
+  ok: true,
+  events: events.length,
+  status: response.statusCode,
+  navigationSpan: changedNavigation.name,
+  resourceSpan: resourceSpan.name,
+  traceId: trace.traceId
+}));