@autter/runtime-node 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,3 +1,76 @@
+import {
+  CODE_PATTERN,
+  DEFAULT_REQUEST_ID_HEADER,
+  RuntimeError,
+  addBreadcrumb,
+  breadcrumbEventAttributes,
+  captureExceptionAsLog,
+  compileIgnore,
+  configureRuntimeLogger,
+  consoleSink,
+  createRequestState,
+  createRuntimeLogger,
+  currentOperation,
+  defineRuntimeErrors,
+  emitSummary,
+  errorAttributes,
+  errorCodeOf,
+  errorInternal,
+  fileSink,
+  fingerprintEventAttributes,
+  fingerprintValues,
+  flushRuntimeLogs,
+  isError,
+  isRuntimeErrorLike,
+  local,
+  makeRedactor,
+  normalizeRoutePath,
+  noteOperationError,
+  notifyException,
+  otlpSink,
+  parseUserAgent,
+  recordOperationAiUsage,
+  redactAttributes,
+  redactText,
+  reportExplicitFailure,
+  requestOutcome,
+  resolveRequestId,
+  responseStatusOf,
+  runInBackground,
+  runtimeContext,
+  runtimeLogStats,
+  runtimeLogger,
+  sanitizeBreadcrumbs,
+  shutdownRuntimeLogger,
+  splitFingerprint,
+  toClientError,
+  withRuntimeOperation
+} from "./chunk-FBKYOHU2.js";
+import {
+  runDoctor
+} from "./chunk-Y4T7SQMO.js";
+import {
+  COMPAT_MANIFEST,
+  CountingExporter,
+  INGESTER_VERSION_HEADER,
+  SDK_IDENTITY,
+  configureCompatCheck,
+  debugLog,
+  ensureCompatConfigured,
+  evaluateCompat,
+  featuresForBrowserEvents,
+  fetchIngesterCompat,
+  installAutterAutoFlush,
+  isDebugEnabled,
+  noteCompatFeature,
+  noteRelayRejection,
+  observeIngesterResponse,
+  registerFlushTarget,
+  setDebugMode,
+  telemetryStats,
+  unregisterFlushTargets
+} from "./chunk-OY2HTUWY.js";
+
 // src/relay.ts
 var IpWindow = class {
   constructor(limitPerMinute) {
@@ -17,8 +90,8 @@ var IpWindow = class {
     return entry.count <= this.limitPerMinute;
   }
 };
-function firstForwardedFor(value2) {
-  const raw = Array.isArray(value2) ? value2[0] : value2;
+function firstForwardedFor(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
   return raw ? (raw.split(",")[0] ?? "").trim() : "";
 }
 var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
@@ -36,7 +109,142 @@ var EVENT_TYPES = /* @__PURE__ */ new Set([
   "timing"
 ]);
 var SEVERITIES = /* @__PURE__ */ new Set(["fatal", "error", "warning", "info"]);
-function sanitizeBrowserPayload(raw) {
+var TRACE_ID = /^(?!0{32})[0-9a-f]{32}$/;
+var CONTEXT_MAX_DEPTH = 6;
+var CONTEXT_MAX_NODES = 256;
+var CONTEXT_MAX_STRING = 4e3;
+var CONTEXT_MAX_ARRAY = 100;
+var CONTEXT_MAX_KEYS = 100;
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function boundContext(value) {
+  let nodes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v, depth) => {
+    if (v === null) return null;
+    const t = typeof v;
+    if (t === "string") return v.slice(0, CONTEXT_MAX_STRING);
+    if (t === "number" || t === "boolean") return v;
+    if (t !== "object") return void 0;
+    if (depth >= CONTEXT_MAX_DEPTH || nodes >= CONTEXT_MAX_NODES) return void 0;
+    const obj = v;
+    if (seen.has(obj)) return void 0;
+    seen.add(obj);
+    let isArr = false;
+    try {
+      isArr = Array.isArray(v);
+    } catch {
+      return void 0;
+    }
+    if (isArr) {
+      const arr = v;
+      const out2 = [];
+      let len = 0;
+      try {
+        len = arr.length;
+      } catch {
+        return out2;
+      }
+      for (let i = 0; i < len && i < CONTEXT_MAX_ARRAY; i++) {
+        if (nodes >= CONTEXT_MAX_NODES) break;
+        nodes++;
+        let el;
+        try {
+          el = walk(arr[i], depth + 1);
+        } catch {
+          el = void 0;
+        }
+        if (el !== void 0) out2.push(el);
+      }
+      return out2;
+    }
+    let keys;
+    try {
+      keys = Object.keys(obj);
+    } catch {
+      return void 0;
+    }
+    const out = {};
+    for (let i = 0; i < keys.length && i < CONTEXT_MAX_KEYS; i++) {
+      if (nodes >= CONTEXT_MAX_NODES) break;
+      const key = keys[i];
+      if (key === void 0) continue;
+      nodes++;
+      let child;
+      try {
+        child = walk(obj[key], depth + 1);
+      } catch {
+        child = void 0;
+      }
+      if (child !== void 0) out[key] = child;
+    }
+    return out;
+  };
+  let result;
+  try {
+    result = walk(value, 0);
+  } catch {
+    result = void 0;
+  }
+  return result && typeof result === "object" ? result : {};
+}
+async function readBodyBounded(request, maxBody) {
+  const body = request.body;
+  if (!body) {
+    const text = await request.text();
+    return byteLength(text) > maxBody ? { tooLarge: true } : { tooLarge: false, text };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBody) {
+      void Promise.resolve().then(() => reader.cancel()).catch(() => {
+      });
+      return { tooLarge: true };
+    }
+    chunks.push(value);
+  }
+  const buf = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buf.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { tooLarge: false, text: new TextDecoder().decode(buf) };
+}
+function relayContext(raw, redactor) {
+  const bounded = boundContext(raw);
+  return Array.isArray(bounded) ? {} : { context: redactor(bounded) };
+}
+function relayBreadcrumbs(raw, redactor) {
+  const breadcrumbs = sanitizeBreadcrumbs(raw, redactor);
+  return breadcrumbs ? { breadcrumbs } : {};
+}
+var DEBUG_ID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+function relayDebugIds(raw, redactor) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+  const debugIds = {};
+  let count = 0;
+  for (const [url, id] of Object.entries(raw)) {
+    if (count >= 50) break;
+    if (typeof id !== "string" || !DEBUG_ID_RE.test(id) || url.length > 1e3) continue;
+    debugIds[redactor.text(url.split(/[?#]/)[0])] = id.toLowerCase();
+    count++;
+  }
+  return count ? { debugIds } : {};
+}
+function relayFingerprint(raw, redactor) {
+  const values = fingerprintValues(raw, redactor.text);
+  return values ? { fingerprint: Array.isArray(raw) ? values : values[0] } : {};
+}
+var defaultRelayRedactor = makeRedactor(true);
+function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
   if (typeof raw !== "object" || raw === null) return null;
   const p = raw;
   if (p.version !== 1) return null;
@@ -53,16 +261,20 @@ function sanitizeBrowserPayload(raw) {
       type: e.type,
       timestamp: e.timestamp,
       ...typeof e.severity === "string" && SEVERITIES.has(e.severity) ? { severity: e.severity } : {},
-      message: typeof e.message === "string" ? e.message.slice(0, 4e3) : "",
-      ...typeof e.name === "string" ? { name: e.name.slice(0, 200) } : {},
+      message: typeof e.message === "string" ? redactor.text(e.message.slice(0, 4512)).slice(0, 4e3) : "",
+      ...typeof e.name === "string" ? { name: redactor.text(e.name.slice(0, 712)).slice(0, 200) } : {},
       ...typeof e.durationMs === "number" && Number.isFinite(e.durationMs) ? { durationMs: Math.max(0, Math.min(12e4, e.durationMs)) } : {},
-      ...typeof e.stack === "string" ? { stack: e.stack.slice(0, 32e3) } : {},
+      ...typeof e.stack === "string" ? { stack: redactor.text(e.stack.slice(0, 32512)).slice(0, 32e3) } : {},
       ...typeof e.errorType === "string" ? { errorType: e.errorType.slice(0, 200) } : {},
       ...typeof e.filename === "string" ? { filename: e.filename.split("?")[0].slice(0, 1e3) } : {},
       ...typeof e.line === "number" ? { line: e.line } : {},
       ...typeof e.column === "number" ? { column: e.column } : {},
       ...typeof e.route === "string" ? { route: e.route.split("?")[0].slice(0, 1e3) } : {},
-      ...typeof e.context === "object" && e.context !== null ? { context: e.context } : {}
+      ...typeof e.context === "object" && e.context !== null ? relayContext(e.context, redactor) : {},
+      ...relayBreadcrumbs(e.breadcrumbs, redactor),
+      ...relayDebugIds(e.debugIds, redactor),
+      ...relayFingerprint(e.fingerprint, redactor),
+      ...typeof e.traceId === "string" && TRACE_ID.test(e.traceId) ? { traceId: e.traceId } : {}
     });
   }
   return {
@@ -71,11 +283,16 @@ function sanitizeBrowserPayload(raw) {
     service: p.service.slice(0, 200),
     environment: p.environment.slice(0, 100),
     ...typeof p.release === "string" ? { release: p.release.slice(0, 200) } : {},
+    // @autter/runtime-browser version, for the ingester's compat records.
+    ...typeof p.sdk === "string" && /^\d{1,6}\.\d{1,6}\.\d{1,6}[0-9A-Za-z.+-]{0,20}$/.test(p.sdk) ? { sdk: p.sdk } : {},
     events
   };
 }
 function forward(payload, opts) {
-  const url = `${(opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, "")}/v1/browser`;
+  const endpoint = (opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, "");
+  const url = `${endpoint}/v1/browser`;
+  const compat = opts.compatCheck !== false;
+  if (compat) ensureCompatConfigured(endpoint);
   void fetch(url, {
     method: "POST",
     headers: {
@@ -84,6 +301,17 @@ function forward(payload, opts) {
     },
     body: JSON.stringify(payload),
     signal: AbortSignal.timeout(1e4)
+  }).then((response) => {
+    if (!compat) return;
+    const types = new Set(
+      (payload.events ?? []).map((e) => String(e.type))
+    );
+    observeIngesterResponse({ status: response.status, headers: response.headers });
+    for (const feature of featuresForBrowserEvents(types)) noteCompatFeature(feature);
+    if ((payload.events ?? []).some((e) => e.traceId)) {
+      noteCompatFeature("browser_trace_propagation");
+    }
+    noteRelayRejection(types, response.status, response.headers);
   }).catch((err) => {
     (opts.onError ?? ((e) => console.warn("autter relay forward failed:", e)))(
       err
@@ -92,6 +320,7 @@ function forward(payload, opts) {
 }
 function createBrowserRelayFetchHandler(opts) {
   const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : makeRedactor(opts.redact);
   const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
   return async (request) => {
     if (request.method !== "POST") {
@@ -105,21 +334,28 @@ function createBrowserRelayFetchHandler(opts) {
         });
       }
     }
-    const text = await request.text();
-    if (text.length > maxBody) {
+    let bounded;
+    try {
+      bounded = await readBodyBounded(request, maxBody);
+    } catch {
+      return new Response(JSON.stringify({ error: "invalid json" }), {
+        status: 400
+      });
+    }
+    if (bounded.tooLarge) {
       return new Response(JSON.stringify({ error: "payload too large" }), {
         status: 413
       });
     }
     let raw;
     try {
-      raw = JSON.parse(text);
+      raw = JSON.parse(bounded.text);
     } catch {
       return new Response(JSON.stringify({ error: "invalid json" }), {
         status: 400
       });
     }
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       return new Response(JSON.stringify({ error: "invalid payload" }), {
         status: 400
@@ -131,6 +367,7 @@ function createBrowserRelayFetchHandler(opts) {
 }
 function createBrowserRelayHandler(opts) {
   const maxBody = opts.maxBodyBytes ?? DEFAULT_MAX_BODY;
+  const redactor = opts.redact === void 0 || opts.redact === true ? defaultRelayRedactor : makeRedactor(opts.redact);
   const limiter = opts.perIpRateLimit === false ? null : new IpWindow(opts.perIpRateLimit ?? 120);
   function respond(res, status, body) {
     res.statusCode = status;
@@ -142,7 +379,7 @@ function createBrowserRelayHandler(opts) {
     }
   }
   function handleParsed(raw, res) {
-    const payload = sanitizeBrowserPayload(raw);
+    const payload = sanitizeBrowserPayload(raw, redactor);
     if (!payload) {
       respond(res, 400, { error: "invalid payload" });
       return;
@@ -204,22 +441,22 @@ function createBrowserRelayHandler(opts) {
 
 // src/server.ts
 import { ServerResponse } from "http";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 import {
-  context,
+  context as context2,
   trace as trace2,
   SpanKind,
   SpanStatusCode,
   TraceFlags
 } from "@opentelemetry/api";
-import { getRPCMetadata, RPCType } from "@opentelemetry/core";
+import { getRPCMetadata as getRPCMetadata2, RPCType as RPCType2 } from "@opentelemetry/core";
 import {
   AggregationTemporalityPreference,
   OTLPMetricExporter
 } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { Resource } from "@opentelemetry/resources";
+import { Resource as Resource2 } from "@opentelemetry/resources";
 import { ExplicitBucketHistogramAggregation, PeriodicExportingMetricReader, View } from "@opentelemetry/sdk-metrics";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import {
@@ -235,50 +472,83 @@ import {
   ATTR_SERVICE_VERSION
 } from "@opentelemetry/semantic-conventions";
 
-// src/lifecycle.ts
+// src/redact-exporter.ts
 import { ExportResultCode } from "@opentelemetry/core";
-var debugEnabled = process.env.AUTTER_DEBUG === "1" || process.env.AUTTER_DEBUG === "true";
-function setDebugMode(enabled) {
-  debugEnabled = enabled;
-}
-function isDebugEnabled() {
-  return debugEnabled;
-}
-function debugLog(...args) {
-  if (debugEnabled) {
-    console.error("[autter]", ...args);
-  }
+import { Resource } from "@opentelemetry/resources";
+import {
+  AggregationTemporality
+} from "@opentelemetry/sdk-metrics";
+var scrubbedResources = /* @__PURE__ */ new WeakMap();
+function redactResource(resource, redactor) {
+  const cached = scrubbedResources.get(resource);
+  if (cached) return cached;
+  const scrubbed = new Resource(redactor.exported(resource.attributes));
+  scrubbedResources.set(resource, scrubbed);
+  return scrubbed;
+}
+function redactSpan(span, redactor) {
+  const status = span.status.message ? { ...span.status, message: redactor.text(span.status.message) } : span.status;
+  return {
+    name: redactor.text(span.name),
+    kind: span.kind,
+    spanContext: () => span.spanContext(),
+    parentSpanId: span.parentSpanId,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    status,
+    attributes: redactor.exported(span.attributes),
+    links: span.links.map(
+      (link) => link.attributes ? { ...link, attributes: redactor.exported(link.attributes) } : link
+    ),
+    events: span.events.map((event) => ({
+      ...event,
+      name: redactor.text(event.name),
+      ...event.attributes ? { attributes: redactor.exported(event.attributes) } : {}
+    })),
+    duration: span.duration,
+    ended: span.ended,
+    resource: redactResource(span.resource, redactor),
+    instrumentationLibrary: span.instrumentationLibrary,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
 }
-var TelemetryStats = class {
-  /** Captures queued via our APIs and not yet seen leaving an exporter. */
-  pendingCaptures = 0;
-  markCaptured(count = 1) {
-    this.pendingCaptures += count;
-  }
-  /** An exporter batch left the process successfully. */
-  onExported(spanCount) {
-    this.pendingCaptures = Math.max(0, this.pendingCaptures - spanCount);
-    if (debugEnabled && spanCount > 0) {
-      debugLog(`exported ${spanCount} span${spanCount === 1 ? "" : "s"}`);
-    }
-  }
-  markAllFlushed() {
-    this.pendingCaptures = 0;
-  }
-};
-var telemetryStats = new TelemetryStats();
-var CountingExporter = class {
-  constructor(inner) {
+var RedactingSpanExporter = class {
+  constructor(inner, redactor) {
     this.inner = inner;
+    this.redactor = redactor;
   }
   inner;
+  redactor;
   export(spans, resultCallback) {
-    this.inner.export(spans, (result) => {
-      if (result.code === ExportResultCode.SUCCESS) {
-        telemetryStats.onExported(spans.length);
+    const redactor = this.redactor();
+    let scrubbed = spans;
+    let failed = 0;
+    if (redactor.enabled) {
+      scrubbed = [];
+      for (const span of spans) {
+        try {
+          scrubbed.push(redactSpan(span, redactor));
+        } catch {
+          failed++;
+        }
       }
-      resultCallback(result);
-    });
+    }
+    if (!failed) {
+      this.inner.export(scrubbed, resultCallback);
+      return;
+    }
+    const error = new Error(`autter-runtime: ${failed} span(s) could not be redacted and were not exported`);
+    const fail = () => resultCallback({ code: ExportResultCode.FAILED, error });
+    if (!scrubbed.length) {
+      fail();
+      return;
+    }
+    this.inner.export(
+      scrubbed,
+      (result) => result.code === ExportResultCode.SUCCESS ? fail() : resultCallback(result)
+    );
   }
   shutdown() {
     return this.inner.shutdown();
@@ -287,394 +557,38 @@ var CountingExporter = class {
     return this.inner.forceFlush?.() ?? Promise.resolve();
   }
 };
-var flushTargets = /* @__PURE__ */ new Map();
-function registerFlushTarget(key, target) {
-  flushTargets.set(key, target);
-}
-function unregisterFlushTargets() {
-  flushTargets.clear();
-}
-function activeFlushTargets() {
-  return [...flushTargets.values()];
-}
-var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-var SIGNAL_EXIT_CODES = {
-  SIGINT: 130,
-  SIGTERM: 143
-};
-function installAutterAutoFlush(options = {}) {
-  const logger = options.logger ?? console;
-  const log = options.log !== false;
-  const warnOnUnflushedExit = options.warnOnUnflushedExit !== false;
-  const timeoutMs = Math.max(100, options.timeoutMs ?? 3e3);
-  const signals = options.signals ?? DEFAULT_SIGNALS;
-  const flushOnUncaughtException = options.flushOnUncaughtException !== false;
-  let disposed = false;
-  let inFlight2 = null;
-  const doFlush = async () => {
-    const targets = options.targets ?? activeFlushTargets();
-    if (targets.length === 0) return true;
-    let timer2;
-    const timedOut = new Promise((resolve) => {
-      timer2 = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const drained = Promise.allSettled(
-      targets.map(
-        (target) => Promise.resolve().then(() => target.forceFlush())
-      )
-    ).then(
-      (results) => results.every((result) => result.status === "fulfilled")
-    );
-    let ok;
-    try {
-      ok = await Promise.race([drained, timedOut]);
-    } finally {
-      clearTimeout(timer2);
-    }
-    if (ok) {
-      telemetryStats.markAllFlushed();
-      if (log) {
-        logger.log("[autter] telemetry flushed");
-      }
-    } else {
-      logger.error(
-        `[autter] flush did not finish within ${timeoutMs}ms \u2014 some telemetry may be lost`
-      );
-    }
-    return ok;
-  };
-  const flush = (reason = "exit") => {
-    if (disposed) return Promise.resolve(false);
-    if (!inFlight2) {
-      inFlight2 = doFlush().finally(() => {
-        inFlight2 = null;
-      });
-    }
-    if (isDebugEnabled()) debugLog(`auto-flush requested on ${reason}`);
-    return inFlight2;
-  };
-  const signalCounts = /* @__PURE__ */ new Map();
-  let handlingUncaughtException = false;
-  const onUncaughtException = (error) => {
-    if (process.listenerCount("uncaughtException") > 1) return;
-    if (handlingUncaughtException) return;
-    handlingUncaughtException = true;
-    logger.error(error instanceof Error ? error.stack ?? error.message : String(error));
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs + 50);
-    void flush("uncaughtException").finally(() => {
-      clearTimeout(keepAlive);
-      process.exit(1);
-    });
-  };
-  const onSignal = (signal) => {
-    const count = (signalCounts.get(signal) ?? 0) + 1;
-    signalCounts.set(signal, count);
-    const exitCode = SIGNAL_EXIT_CODES[signal] ?? 1;
-    if (count > 1) {
-      process.exit(exitCode);
-    }
-    const otherHandlers = process.listenerCount(signal) - 1;
-    if (otherHandlers > 0) {
-      void flush(signal);
-      return;
-    }
-    void flush(signal).finally(() => {
-      process.exit(exitCode);
-    });
-  };
-  const MAX_BEFORE_EXIT_FLUSHES = 10;
-  let beforeExitFlushes = 0;
-  const onBeforeExit = () => {
-    if (disposed) return;
-    const targets = options.targets ?? activeFlushTargets();
-    const worthIt = beforeExitFlushes === 0 ? targets.length > 0 : telemetryStats.pendingCaptures > 0;
-    if (!worthIt || beforeExitFlushes >= MAX_BEFORE_EXIT_FLUSHES) return;
-    beforeExitFlushes++;
-    const keepAlive = setTimeout(() => {
-    }, timeoutMs);
-    void flush("beforeExit").finally(() => clearTimeout(keepAlive));
-  };
-  const onExit = () => {
-    if (!warnOnUnflushedExit || disposed) return;
-    const pending = telemetryStats.pendingCaptures;
-    if (pending > 0) {
-      logger.error(
-        `[autter] process exiting with ~${pending} captured item(s) never confirmed exported \u2014 await autter.shutdown() on graceful shutdown`
-      );
-    }
-  };
-  const signalHandlers = /* @__PURE__ */ new Map();
-  process.on("beforeExit", onBeforeExit);
-  if (flushOnUncaughtException) {
-    process.on("uncaughtException", onUncaughtException);
-  }
-  for (const signal of signals) {
-    const handler = () => onSignal(signal);
-    signalHandlers.set(signal, handler);
-    process.on(signal, handler);
-  }
-  process.on("exit", onExit);
-  return {
-    flush,
-    dispose() {
-      disposed = true;
-      process.removeListener("beforeExit", onBeforeExit);
-      process.removeListener("uncaughtException", onUncaughtException);
-      process.removeListener("exit", onExit);
-      for (const [signal, handler] of signalHandlers) {
-        process.removeListener(signal, handler);
-      }
-      signalHandlers.clear();
-    }
-  };
-}
-
-// src/redact.ts
-var SENSITIVE_KEY_PATTERNS = [
-  /e-?mail/,
-  /pass(word|wd|phrase)|^pass$/,
-  /token/,
-  /secret/,
-  /credential/,
-  /(api|access|secret|private|consumer|client|signing|encryption)-?[_.]?key/,
-  /^-?x?-?authorization$|^auth(-|_|$)|bearer/,
-  /cookie/,
-  /phone|msisdn/,
-  /\bssn\b|social[-_ ]?security/,
-  /cvv|cvc|card([-_. ]?(number|num|no))?$/,
-  /credit[-_.]?card/,
-  /connection[-_.]?string/,
-  /recovery[-_.]?code|\botp\b|magic[-_.]?link/
-];
-var PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g;
-var EMAIL_VALUE_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
-var JWT_RE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
-var OPENAI_KEY_RE = /\bsk-[A-Za-z0-9]{20,}\b/g;
-var GITHUB_TOKEN_RE = /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g;
-var AWS_KEY_RE = /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g;
-var SLACK_TOKEN_RE = /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g;
-var BEARER_RE = /\bbearer\s+[A-Za-z0-9._~+/=-]{10,}/gi;
-var URL_CREDENTIALS_RE = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi;
-function toCaseInsensitive(pattern) {
-  return typeof pattern === "string" ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i") : new RegExp(pattern.source, pattern.flags.includes("i") ? pattern.flags : `${pattern.flags}i`);
-}
-function compile(options) {
-  const keyPatterns = [...SENSITIVE_KEY_PATTERNS];
-  const valuePatterns = [
-    JWT_RE,
-    OPENAI_KEY_RE,
-    GITHUB_TOKEN_RE,
-    AWS_KEY_RE,
-    SLACK_TOKEN_RE,
-    BEARER_RE
-  ];
-  if (options?.additionalKeyPatterns) {
-    for (const p of options.additionalKeyPatterns) {
-      keyPatterns.push(toCaseInsensitive(p));
-    }
+var RedactingMetricExporter = class {
+  constructor(inner, redactor) {
+    this.inner = inner;
+    this.redactor = redactor;
   }
-  if (options?.additionalValuePatterns) {
-    for (const p of options.additionalValuePatterns) {
-      if (!valuePatterns.some((existing) => existing.source === (typeof p === "string" ? p : p.source))) {
-        valuePatterns.push(typeof p === "string" ? new RegExp(p, "gi") : p);
-      }
+  inner;
+  redactor;
+  export(metrics2, resultCallback) {
+    const redactor = this.redactor();
+    if (!redactor.enabled) {
+      this.inner.export(metrics2, resultCallback);
+      return;
     }
-  }
-  return {
-    keyPatterns,
-    valuePatterns,
-    urlCredentials: URL_CREDENTIALS_RE,
-    privateKeyBlock: PRIVATE_KEY_BLOCK_RE,
-    mask: options?.mask ?? "[redacted]",
-    scrubEmailValues: options?.scrubEmailValues !== false
-  };
-}
-function redactString(value2, r) {
-  let out = value2.replace(r.privateKeyBlock, r.mask);
-  for (const re of r.valuePatterns) {
-    out = out.replace(re, r.mask);
-  }
-  out = out.replace(r.urlCredentials, "$1" + r.mask + "@");
-  if (r.scrubEmailValues) {
-    out = out.replace(EMAIL_VALUE_RE, r.mask);
-  }
-  return out;
-}
-var MAX_REDACTION_DEPTH = 64;
-var MAX_REDACTION_WORK = 1e4;
-var MAX_COLLECTION_ENTRIES = 1e3;
-function canTraverse(depth, state) {
-  if (depth > MAX_REDACTION_DEPTH || state.remainingWork <= 0) return false;
-  state.remainingWork -= 1;
-  return true;
-}
-function redactValue(value2, r, state, depth) {
-  if (typeof value2 === "string") return redactString(value2, r);
-  let isArray = false;
-  try {
-    isArray = Array.isArray(value2);
-  } catch {
-    return r.mask;
-  }
-  if (isArray) {
-    return redactArray(value2, r, state, depth);
-  }
-  if (typeof value2 === "object" && value2 !== null) {
-    return redactObject(value2, r, state, depth);
-  }
-  return value2;
-}
-function redactArray(value2, r, state, depth) {
-  const existing = state.ancestors.get(value2);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = [];
-  state.ancestors.set(value2, out);
-  let length;
-  try {
-    length = value2.length;
-  } catch {
-    state.ancestors.delete(value2);
-    return r.mask;
-  }
-  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
-  for (let i = 0; i < limit; i += 1) {
-    let item;
+    let resource;
     try {
-      item = value2[i];
-    } catch {
-      out.push(r.mask);
-      continue;
+      resource = redactResource(metrics2.resource, redactor);
+    } catch (error) {
+      resultCallback({ code: ExportResultCode.FAILED, error });
+      return;
     }
-    out.push(redactValue(item, r, state, depth + 1));
+    this.inner.export({ ...metrics2, resource }, resultCallback);
   }
-  if (length > limit) {
-    out.push(r.mask);
+  forceFlush() {
+    return this.inner.forceFlush();
   }
-  state.ancestors.delete(value2);
-  return out;
-}
-function redactObject(value2, r, state, depth) {
-  const existing = state.ancestors.get(value2);
-  if (existing) return r.mask;
-  if (!canTraverse(depth, state)) return r.mask;
-  const out = {};
-  state.ancestors.set(value2, out);
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in value2) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        value2,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES) {
-        truncated = true;
-        break;
-      }
-      let nestedValue;
-      try {
-        nestedValue = value2[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        continue;
-      }
-      count += 1;
-      out[key] = isSensitiveKey(key, nestedValue, r) ? r.mask : redactValue(
-        nestedValue,
-        r,
-        state,
-        depth + 1
-      );
-    }
-  } catch {
-    truncated = true;
-  }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
-  }
-  state.ancestors.delete(value2);
-  return out;
-}
-var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
-  "input_tokens",
-  "output_tokens",
-  "prompt_tokens",
-  "completion_tokens",
-  "total_tokens",
-  "token_count",
-  "gen_ai.usage.input_tokens",
-  "gen_ai.usage.output_tokens",
-  "gen_ai.usage.prompt_tokens",
-  "gen_ai.usage.completion_tokens",
-  "gen_ai.usage.total_tokens",
-  "gen_ai.usage.token_count"
-]);
-function isSensitiveKey(key, value2, r) {
-  const lowered = key.toLowerCase();
-  if (USAGE_TOKEN_KEYS.has(lowered)) {
-    return !(typeof value2 === "number" && Number.isFinite(value2) && value2 >= 0);
-  }
-  return r.keyPatterns.some((re) => re.test(lowered));
-}
-function redactAttributes(attributes, options) {
-  const r = compile(options);
-  return redactWith(attributes, r);
-}
-function redactWith(attributes, r) {
-  const out = {};
-  if (!attributes) return out;
-  const state = {
-    ancestors: /* @__PURE__ */ new WeakMap(),
-    remainingWork: MAX_REDACTION_WORK
-  };
-  let count = 0;
-  let truncated = false;
-  try {
-    for (const key in attributes) {
-      if (!Object.prototype.propertyIsEnumerable.call(
-        attributes,
-        key
-      )) {
-        continue;
-      }
-      if (count >= MAX_COLLECTION_ENTRIES || state.remainingWork <= 0) {
-        truncated = true;
-        break;
-      }
-      let value2;
-      try {
-        value2 = attributes[key];
-      } catch {
-        out[key] = r.mask;
-        count += 1;
-        state.remainingWork -= 1;
-        continue;
-      }
-      count += 1;
-      state.remainingWork -= 1;
-      if (value2 === void 0) continue;
-      out[key] = isSensitiveKey(key, value2, r) ? r.mask : redactValue(value2, r, state, 0);
-    }
-  } catch {
-    truncated = true;
+  shutdown() {
+    return this.inner.shutdown();
   }
-  if (truncated) {
-    out.__redaction_truncated__ = r.mask;
+  selectAggregationTemporality(instrumentType) {
+    return this.inner.selectAggregationTemporality ? this.inner.selectAggregationTemporality(instrumentType) : AggregationTemporality.CUMULATIVE;
   }
-  return out;
-}
-function makeRedactor(options) {
-  if (options === false) {
-    return (attributes) => ({ ...attributes ?? {} });
-  }
-  const r = compile(options === true ? void 0 : options);
-  return (attributes) => redactWith(attributes, r);
-}
+};
 
 // src/memory.ts
 import { PerformanceObserver } from "perf_hooks";
@@ -721,388 +635,544 @@ function startMemoryMetrics() {
   };
 }
 
-// src/logger.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-import { trace } from "@opentelemetry/api";
-var local = new AsyncLocalStorage();
-var config = null;
-var queue = [];
-var queueBytes = 0;
-var inFlightBytes = 0;
-var timer;
-var flushing = null;
-var dropped = 0;
-var inFlight = 0;
-var stopping = false;
-var failureStreak = 0;
-var severity = { debug: 5, info: 9, warning: 13, error: 17 };
-function safe(attributes = {}) {
-  const redacted = config?.redact(attributes) ?? redactAttributes(attributes);
-  let budget = 512;
-  let characters = 16384;
-  let truncated = false;
-  const visit = (input, depth) => {
-    if (--budget < 0 || depth > 6) {
-      truncated = true;
-      return "[truncated]";
-    }
-    if (typeof input === "string") {
-      const text = input.replace(/(https?:\/\/[^\s?#]+)[?#][^\s]*/gi, "$1");
-      const kept = text.slice(0, Math.max(0, characters));
-      truncated ||= kept.length < text.length;
-      characters -= kept.length;
-      return kept;
-    }
-    if (typeof input === "number")
-      return Number.isFinite(input) ? input : void 0;
-    if (typeof input === "boolean" || input === null) return input;
-    if (Array.isArray(input)) {
-      truncated ||= input.length > 64;
-      return input.slice(0, 64).map((item) => visit(item, depth + 1));
+// src/requests.ts
+import { AsyncResource } from "async_hooks";
+import { context, trace } from "@opentelemetry/api";
+import { getRPCMetadata, RPCType } from "@opentelemetry/core";
+var REQUEST_STATE = /* @__PURE__ */ Symbol.for("autter.runtime.request");
+var BOUND = /* @__PURE__ */ Symbol.for("autter.runtime.bound");
+var CAPTURED = /* @__PURE__ */ new WeakSet();
+var capturer = () => {
+};
+function setRequestExceptionCapturer(fn) {
+  capturer = fn;
+}
+var annotator = () => {
+};
+function setRequestSpanAnnotator(fn) {
+  annotator = fn;
+}
+function markCaptured(error) {
+  if (error && typeof error === "object") CAPTURED.add(error);
+}
+function expressRouteOf(req) {
+  const props = req;
+  const path = props?.route?.path;
+  if (typeof path !== "string" || path === "") return null;
+  const base = typeof props?.baseUrl === "string" ? props.baseUrl : "";
+  const route = base + path;
+  return route.startsWith("/") ? route : null;
+}
+function defaultShouldCapture(error) {
+  return error instanceof RuntimeError || errorCodeOf(error) !== void 0 || responseStatusOf(error) >= 500;
+}
+function onRequestSpan(fn) {
+  const active2 = context.active();
+  const metadata = getRPCMetadata(active2);
+  const span = metadata?.type === RPCType.HTTP ? metadata.span : void 0;
+  if (!span || !span.isRecording() || trace.getSpan(active2) === span) {
+    fn();
+    return;
+  }
+  context.with(trace.setSpan(active2, span), fn);
+}
+function captureAtBoundary(error, state, rule = void 0, attributes) {
+  let wanted;
+  try {
+    wanted = typeof rule === "function" ? rule(error) : rule === void 0 ? defaultShouldCapture(error) : rule;
+  } catch {
+    wanted = false;
+  }
+  if (!wanted) return;
+  if (error && typeof error === "object" && CAPTURED.has(error)) return;
+  markCaptured(error);
+  try {
+    const run = () => onRequestSpan(() => capturer(error, attributes));
+    if (state && !state.sealed) local.run(state, run);
+    else run();
+  } catch {
+  }
+}
+function requestStateOf(req) {
+  if (!req || typeof req !== "object") return void 0;
+  return req[REQUEST_STATE];
+}
+function captureRequestError(error, attributes) {
+  if (error && typeof error === "object" && CAPTURED.has(error)) {
+    if (!attributes) return;
+    try {
+      onRequestSpan(() => annotator(attributes));
+    } catch {
     }
-    if (input && typeof input === "object") {
-      const entries = Object.entries(input);
-      if (depth === 0) {
-        const priority = (key) => /^autter\.(?:operation|event)\./.test(key) ? 2 : /^exception\./.test(key) ? 1 : 0;
-        entries.sort(([a], [b]) => priority(b) - priority(a));
-      }
-      truncated ||= entries.length > 100;
-      return Object.fromEntries(
-        entries.slice(0, 100).filter(([key]) => !/^(?:__proto__|constructor|prototype)$/.test(key)).map(([key, item]) => [key.slice(0, 200), visit(item, depth + 1)])
-      );
+    return;
+  }
+  captureAtBoundary(error, currentOperation(), true, attributes);
+}
+function bindEmitter(emitter, state) {
+  const target = emitter;
+  if (!target || typeof target !== "object" || target[BOUND]) return;
+  target[BOUND] = true;
+  const wrappers = /* @__PURE__ */ new WeakMap();
+  const wrap = (listener) => {
+    if (typeof listener !== "function") return listener;
+    let wrapped = wrappers.get(listener);
+    if (!wrapped) {
+      wrapped = function(...args) {
+        return local.run(
+          state,
+          () => listener.apply(this, args)
+        );
+      };
+      wrappers.set(listener, wrapped);
     }
-    return void 0;
+    return wrapped;
   };
-  const result = visit(redacted, 0);
-  if (truncated) result["autter.context.truncated"] = true;
-  return result;
-}
-function operationAttributes(state) {
-  return state ? {
-    "autter.operation.id": state.id,
-    "autter.operation.name": state.name,
-    ...state.parentId ? { "autter.operation.parent_id": state.parentId } : {},
-    ...state.attributes
-  } : {};
-}
-function userAttributes(attributes = {}) {
-  return Object.fromEntries(
-    Object.entries(safe(attributes)).filter(
-      ([key]) => !/^autter\.(?:operation|event)\./.test(key)
-    )
-  );
+  for (const method of [
+    "on",
+    "addListener",
+    "prependListener",
+    "once",
+    "prependOnceListener"
+  ]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      return original.call(this, event, wrap(listener));
+    };
+  }
+  for (const method of ["removeListener", "off"]) {
+    const original = target[method];
+    if (typeof original !== "function") continue;
+    target[method] = function(event, listener) {
+      const wrapped = typeof listener === "function" ? wrappers.get(listener) ?? listener : listener;
+      return original.call(this, event, wrapped);
+    };
+  }
 }
-function mergeContext(current, next = {}) {
-  const merge = (left, right, depth) => {
-    const result = { ...left };
-    for (const [key, value2] of Object.entries(right)) {
-      const prior = result[key];
-      result[key] = depth < 6 && value2 && typeof value2 === "object" && !Array.isArray(value2) && prior && typeof prior === "object" && !Array.isArray(prior) ? merge(prior, value2, depth + 1) : value2;
+function exposeHeaderValue(current, header) {
+  const text = Array.isArray(current) ? current.join(", ") : String(current ?? "");
+  const names = text.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  if (names.includes("*") || names.includes(header)) return null;
+  return names.length ? `${text}, ${header}` : header;
+}
+function exposeOnCors(res, header) {
+  const original = res.writeHead;
+  res.writeHead = function(...args) {
+    try {
+      const inline = args.slice(1).find(
+        (arg) => !!arg && typeof arg === "object" && !Array.isArray(arg)
+      );
+      const inlineKey = (name) => inline ? Object.keys(inline).find((key) => key.toLowerCase() === name) : void 0;
+      const cors = res.getHeader("access-control-allow-origin") !== void 0 || inlineKey("access-control-allow-origin") !== void 0;
+      if (cors) {
+        const key = inlineKey("access-control-expose-headers");
+        const value = exposeHeaderValue(
+          key && inline ? inline[key] : res.getHeader("access-control-expose-headers"),
+          header
+        );
+        if (value && key && inline) inline[key] = value;
+        else if (value) res.setHeader("access-control-expose-headers", value);
+      }
+    } catch {
     }
-    return result;
+    return original.apply(this, args);
   };
-  return userAttributes(merge(current, userAttributes(next), 0));
-}
-function traceAttributes(state) {
-  return Object.fromEntries(
-    Object.entries(operationAttributes(state)).filter(([, item]) => item !== null && item !== void 0).map(([key, item]) => [
-      key,
-      typeof item === "object" ? JSON.stringify(item) : item
-    ])
-  );
 }
-function scheduleFlush() {
-  if (!timer && config && !stopping && queue.length) {
-    timer = setTimeout(
-      () => {
-        timer = void 0;
-        void flushRuntimeLogs().catch(() => {
-        });
-      },
-      Math.min(3e4, 2e3 * 2 ** Math.min(failureStreak, 4))
+function pathOf(req) {
+  const raw = req.originalUrl ?? req.url ?? "/";
+  return raw.split(/[?#]/)[0] || "/";
+}
+function finishRequest(state, input) {
+  if (state.sealed) return;
+  state.name = (input.name ?? `${input.method} ${input.route}`).slice(0, 200);
+  state.outcome = requestOutcome({
+    ...state.explicitOutcome ? { explicit: state.outcome } : {},
+    ...state.error !== void 0 ? { error: state.error } : {},
+    ...state.errorThrown ? { thrown: true } : {},
+    status: input.status,
+    aborted: input.aborted
+  });
+  const span = trace.getActiveSpan();
+  if (span?.isRecording()) span.setAttribute("autter.operation.outcome", state.outcome);
+  if (input.span) {
+    const remote = trace.wrapSpanContext(input.span);
+    context.with(
+      trace.setSpan(context.active(), remote),
+      () => reportExplicitFailure(state)
     );
-    timer.unref();
-  }
-}
-function value(input) {
-  if (typeof input === "number") return { doubleValue: input };
-  if (typeof input === "boolean") return { boolValue: input };
-  if (Array.isArray(input))
-    return { arrayValue: { values: input.slice(0, 64).map(value) } };
-  if (input && typeof input === "object")
-    return {
-      kvlistValue: {
-        values: Object.entries(input).slice(0, 128).map(([key, item]) => ({ key, value: value(item) }))
-      }
-    };
-  return { stringValue: String(input ?? "").slice(0, 32e3) };
+  } else reportExplicitFailure(state);
+  emitSummary(state, {
+    http: {
+      "http.request.method": input.method,
+      "http.route": input.route,
+      "http.response.status_code": input.status,
+      "autter.request.aborted": input.aborted
+    },
+    ...input.span ? { span: input.span } : {}
+  });
 }
-function emit(level, message, attributes, extra = {}) {
-  const state = local.getStore();
-  if (state?.sealed) return;
-  if (extra["autter.event.type"] !== "operation" && severity[level] < severity[config?.options?.minLevel ?? "debug"])
-    return;
-  const span = trace.getActiveSpan()?.spanContext();
-  const user = mergeContext(state?.attributes ?? {}, attributes);
-  const exceptions = Object.fromEntries(
-    Object.entries(user).filter(([key]) => key.startsWith("exception."))
+function beginNodeRequest(req, res, options, route) {
+  const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const requestId = resolveRequestId(
+    options.trustRequestId === false ? void 0 : req.headers[header]
   );
-  const attrs = safe({
-    "autter.event.id": randomUUID(),
-    ...extra,
-    ...exceptions,
-    ...operationAttributes(state),
-    ...user
+  const method = (req.method ?? "GET").toUpperCase();
+  const path = pathOf(req);
+  const state = createRequestState({
+    name: `${method} ${normalizeRoutePath(path)}`,
+    requestId,
+    req,
+    res
   });
-  const record = {
-    timeUnixNano: String(BigInt(Date.now()) * 1000000n),
-    severityNumber: severity[level],
-    severityText: level.toUpperCase(),
-    body: value(String(safe({ message }).message ?? "").slice(0, 4e3)),
-    attributes: Object.entries(attrs).map(([key, item]) => ({
-      key,
-      value: value(item)
-    })),
-    ...span && /^[a-f0-9]{32}$/.test(span.traceId) && !/^0+$/.test(span.traceId) ? { traceId: span.traceId, spanId: span.spanId } : {}
+  req[REQUEST_STATE] = state;
+  try {
+    if (!res.headersSent) res.setHeader(header, requestId);
+    exposeOnCors(res, header);
+  } catch {
+  }
+  const span = trace.getActiveSpan();
+  if (span?.isRecording())
+    span.setAttributes({
+      "autter.request.id": requestId,
+      "autter.operation.kind": "request"
+    });
+  const spanContext = span?.spanContext();
+  bindEmitter(req, state);
+  bindEmitter(res, state);
+  let finished = false;
+  const done = () => {
+    finishRequest(state, {
+      method,
+      route: route?.() ?? expressRouteOf(req) ?? normalizeRoutePath(path),
+      status: res.statusCode,
+      aborted: !finished,
+      ...spanContext ? { span: spanContext } : {}
+    });
+  };
+  res.once("finish", () => {
+    finished = true;
+    done();
+  });
+  res.once("close", done);
+  return state;
+}
+function autterRequests(options = {}) {
+  const ignored = compileIgnore(options.ignore);
+  return function autterRequestsMiddleware(req, res, next) {
+    if (req[REQUEST_STATE] || ignored(pathOf(req))) {
+      next();
+      return;
+    }
+    const state = beginNodeRequest(req, res, options);
+    local.run(state, () => next());
   };
-  if (config?.options?.console !== false)
-    console.log(
-      JSON.stringify({ ...attrs, level, message: record.body.stringValue })
+}
+function autterErrorResponse(options = {}) {
+  return function autterErrorResponseMiddleware(error, req, res, next) {
+    const state = req[REQUEST_STATE];
+    if (state) noteOperationError(error, true, state);
+    captureAtBoundary(error, state, options.capture);
+    if (res.headersSent) {
+      next(error);
+      return;
+    }
+    const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+    const inbound = req.headers?.[header];
+    const requestId = state?.requestId ?? (typeof inbound === "string" ? inbound.slice(0, 128) : void 0);
+    res.statusCode = responseStatusOf(error);
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(toClientError(error, requestId)));
+  };
+}
+var RESOURCE = /* @__PURE__ */ Symbol.for("autter.runtime.resource");
+function autterFastify(fastify, options, done) {
+  const opts = options ?? {};
+  const header = (opts.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const ignored = compileIgnore(opts.ignore);
+  const stateOf = (request) => request[REQUEST_STATE];
+  fastify.addHook("onRequest", ((request, reply, next) => {
+    if (ignored(request.url) || request.raw[REQUEST_STATE]) {
+      next();
+      return;
+    }
+    const requestId = resolveRequestId(
+      opts.trustRequestId === false ? void 0 : request.headers[header]
     );
-  if (!config) return;
-  if (stopping) {
-    dropped++;
-    return;
+    const method = String(request.method ?? "GET").toUpperCase();
+    const state = createRequestState({
+      name: `${method} ${normalizeRoutePath(request.url)}`,
+      requestId,
+      req: request.raw,
+      res: reply.raw
+    });
+    request[REQUEST_STATE] = state;
+    request.raw[REQUEST_STATE] = state;
+    reply.header(header, requestId);
+    const span = trace.getActiveSpan();
+    if (span?.isRecording())
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
+      });
+    const spanContext = span?.spanContext();
+    bindEmitter(request.raw, state);
+    bindEmitter(reply.raw, state);
+    let finished = false;
+    const finish = (aborted) => finishRequest(state, {
+      method,
+      route: request.routeOptions?.url ?? request.routerPath ?? normalizeRoutePath(request.url),
+      status: reply.raw.statusCode || reply.statusCode,
+      aborted,
+      ...spanContext ? { span: spanContext } : {}
+    });
+    reply.raw.once("finish", () => {
+      finished = true;
+      finish(false);
+    });
+    reply.raw.once("close", () => finish(!finished));
+    local.run(state, () => {
+      request[RESOURCE] = new AsyncResource("autter-request");
+      next();
+    });
+  }));
+  fastify.addHook("preHandler", ((request, _reply, next) => {
+    const resource = request[RESOURCE];
+    if (resource) resource.runInAsyncScope(() => next());
+    else next();
+  }));
+  fastify.addHook("onSend", ((request, reply, payload, next) => {
+    try {
+      if (stateOf(request) && reply.getHeader("access-control-allow-origin") !== void 0) {
+        const value = exposeHeaderValue(reply.getHeader("access-control-expose-headers"), header);
+        if (value) reply.header("access-control-expose-headers", value);
+      }
+    } catch {
+    }
+    next(null, payload);
+  }));
+  fastify.addHook("onError", ((request, _reply, error, next) => {
+    const state = stateOf(request);
+    if (state) noteOperationError(error, true, state);
+    captureAtBoundary(error, state);
+    next();
+  }));
+  done();
+}
+autterFastify[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+autterFastify[/* @__PURE__ */ Symbol.for("fastify.display-name")] = "autter-runtime";
+function withHeaders(response, header, requestId) {
+  const apply = (target) => {
+    target.headers.set(header, requestId);
+    if (target.headers.get("access-control-allow-origin") !== null) {
+      const value = exposeHeaderValue(
+        target.headers.get("access-control-expose-headers") ?? "",
+        header
+      );
+      if (value) target.headers.set("access-control-expose-headers", value);
+    }
+    return target;
+  };
+  try {
+    return apply(response);
+  } catch {
+    try {
+      return apply(new Response(response.body, response));
+    } catch {
+      return response;
+    }
   }
-  const bytes = Buffer.byteLength(JSON.stringify(record));
-  if (bytes > 256 * 1024 || queue.length + inFlight >= 1e3 || queueBytes + inFlightBytes + bytes > 4 * 1024 * 1024) {
-    dropped++;
-    console.warn(
-      "[autter-runtime] log buffer or record limit reached; record dropped"
+}
+function withRuntimeRequest(handler, options = {}) {
+  const header = (options.requestIdHeader ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase();
+  const ignored = compileIgnore(options.ignore);
+  return async (request, ...rest) => {
+    let pathname = "/";
+    try {
+      pathname = new URL(request.url, "http://localhost").pathname;
+    } catch {
+    }
+    if (ignored(pathname)) return handler(request, ...rest);
+    const requestId = resolveRequestId(
+      options.trustRequestId === false ? void 0 : request.headers.get(header)
     );
-    return;
-  }
-  queue.push({ record, bytes });
-  queueBytes += bytes;
-  scheduleFlush();
-}
-function configureRuntimeLogger(next) {
-  config = next;
-  stopping = false;
-  failureStreak = 0;
-}
-function runtimeLogStats() {
-  return { buffered: queue.length + inFlight, dropped };
-}
-async function flushRuntimeLogs() {
-  if (flushing) return flushing;
-  if (!config || !queue.length) return;
-  if (timer) {
-    clearTimeout(timer);
-    timer = void 0;
-  }
-  const activeConfig = config;
-  const deadline = Date.now() + 1e4;
-  flushing = (async () => {
-    const count = queue.length;
-    for (let remaining = count; remaining > 0; ) {
-      const batch = [];
-      inFlightBytes = 0;
-      while (batch.length < Math.min(50, remaining) && queue.length) {
-        const next = queue[0];
-        if (batch.length && inFlightBytes + next.bytes > 512 * 1024) break;
-        batch.push(queue.shift());
-        inFlightBytes += next.bytes;
-        queueBytes -= next.bytes;
-      }
-      remaining -= batch.length;
-      inFlight = batch.length;
-      const body = JSON.stringify({
-        resourceLogs: [
-          {
-            resource: {
-              attributes: Object.entries({
-                "service.name": activeConfig.service,
-                "deployment.environment.name": activeConfig.environment,
-                ...activeConfig.release ? { "service.version": activeConfig.release } : {}
-              }).map(([key, item]) => ({ key, value: value(item) }))
-            },
-            scopeLogs: [
-              {
-                scope: { name: "autter-runtime" },
-                logRecords: batch.map((entry) => entry.record)
-              }
-            ]
-          }
-        ]
+    const method = String(request.method ?? "GET").toUpperCase();
+    const route = options.route ?? normalizeRoutePath(pathname);
+    const state = createRequestState({
+      name: `${method} ${options.name ?? route}`,
+      requestId,
+      req: request
+    });
+    const span = trace.getActiveSpan();
+    if (span?.isRecording())
+      span.setAttributes({
+        "autter.request.id": requestId,
+        "autter.operation.kind": "request"
       });
-      let failure;
-      for (let attempt = 0; attempt < 3; attempt++) {
+    const spanContext = span?.spanContext();
+    let status = 500;
+    try {
+      const response = await local.run(state, async () => {
         try {
-          if (Date.now() >= deadline)
-            throw new Error("Runtime log flush exceeded 10 seconds");
-          const response = await fetch(`${activeConfig.endpoint}/v1/logs`, {
-            method: "POST",
-            headers: {
-              "content-type": "application/json",
-              authorization: `Bearer ${activeConfig.apiKey}`
-            },
-            body,
-            signal: AbortSignal.timeout(
-              Math.max(1, Math.min(3e3, deadline - Date.now()))
-            )
-          });
-          if (!response.ok)
-            throw new Error(`Runtime log export failed (${response.status})`);
-          failure = void 0;
-          break;
+          return await handler(request, ...rest);
         } catch (error) {
-          failure = error;
+          noteOperationError(error, true, state);
+          captureAtBoundary(error, state, true);
+          throw error;
+        }
+      });
+      status = response.status;
+      return withHeaders(response, header, requestId);
+    } finally {
+      const aborted = request.signal?.aborted === true;
+      finishRequest(state, {
+        method,
+        route,
+        name: `${method} ${options.name ?? route}`,
+        status,
+        aborted,
+        ...spanContext ? { span: spanContext } : {}
+      });
+      if (options.waitUntil) {
+        try {
+          options.waitUntil(flushRuntimeLogs().catch(() => {
+          }));
+        } catch {
         }
       }
-      inFlight = 0;
-      if (failure) {
-        failureStreak++;
-        queue = [...batch, ...queue];
-        queueBytes += inFlightBytes;
-        inFlightBytes = 0;
-        throw failure;
-      }
-      inFlightBytes = 0;
-      failureStreak = 0;
     }
-  })().finally(() => {
-    flushing = null;
-    scheduleFlush();
-  });
-  return flushing;
+  };
+}
+function startHookRequest(res) {
+  const req = res.req;
+  if (!req || req[REQUEST_STATE]) return;
+  const state = beginNodeRequest(req, res, {});
+  local.enterWith(state);
 }
-async function shutdownRuntimeLogger() {
-  stopping = true;
+
+// src/unhandled-rejections.ts
+var MODES = /* @__PURE__ */ new Set([
+  "throw",
+  "strict",
+  "warn",
+  "warn-with-error-code",
+  "none"
+]);
+var LISTENER_MARK = /* @__PURE__ */ Symbol.for("autter.runtime.unhandledRejection.listener");
+var HANDLED_KEY = /* @__PURE__ */ Symbol.for("autter.runtime.unhandledRejection.handled");
+function handledPromises() {
+  const registry = globalThis;
+  let set = registry[HANDLED_KEY];
+  if (!set) {
+    set = /* @__PURE__ */ new WeakSet();
+    registry[HANDLED_KEY] = set;
+  }
+  return set;
+}
+var recorded = /* @__PURE__ */ new WeakSet();
+function markRecorded(reason) {
+  if (!reason || typeof reason !== "object") return;
+  recorded.add(reason);
+  setImmediate(() => recorded.delete(reason)).unref?.();
+}
+function recordedAsRejection(error) {
+  return !!error && typeof error === "object" && recorded.has(error);
+}
+function splitOptions(value) {
+  return value ? value.split(/\s+/).filter(Boolean) : [];
+}
+function unhandledRejectionsMode(execArgv = process.execArgv, nodeOptions = process.env.NODE_OPTIONS) {
+  const args = [...splitOptions(nodeOptions), ...execArgv];
+  let mode = "throw";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (!arg.startsWith("--")) continue;
+    const eq = arg.indexOf("=");
+    const name = (eq < 0 ? arg : arg.slice(0, eq)).replace(/_/g, "-");
+    if (name !== "--unhandled-rejections") continue;
+    const value = eq < 0 ? args[++i] : arg.slice(eq + 1);
+    if (value && MODES.has(value))
+      mode = value;
+  }
+  return mode;
+}
+function isErrorLike(value) {
   try {
-    await flushRuntimeLogs();
-  } finally {
-    if (queue.length) {
-      dropped += queue.length;
-      console.warn(
-        `[autter-runtime] ${queue.length} log records could not be delivered before shutdown`
-      );
+    return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, "stack");
+  } catch {
+    return false;
+  }
+}
+function describeReason(reason) {
+  if (typeof reason !== "object" && typeof reason !== "function" || reason === null) {
+    try {
+      return String(reason);
+    } catch {
+      return typeof reason;
     }
-    queue = [];
-    queueBytes = 0;
-    config = null;
-    if (timer) clearTimeout(timer);
-    timer = void 0;
+  }
+  try {
+    const proto = Object.getPrototypeOf(reason);
+    const ctor = proto?.constructor;
+    const name = typeof ctor === "function" ? ctor.name : "";
+    return name ? `#<${name}>` : "[object Object]";
+  } catch {
+    return "[object Object]";
   }
 }
-function createRuntimeLogger(attributes = {}) {
-  const attrs = userAttributes(attributes);
-  return {
-    debug: (message, extra) => emit("debug", message, mergeContext(attrs, extra)),
-    info: (message, extra) => emit("info", message, mergeContext(attrs, extra)),
-    warn: (message, extra) => emit("warning", message, mergeContext(attrs, extra)),
-    error: (error, extra) => emit("error", error instanceof Error ? error.message : String(error), {
-      ...attrs,
-      ...extra,
-      ...error instanceof Error ? {
-        "exception.type": error.name,
-        "exception.stacktrace": error.stack ?? ""
-      } : {}
-    })
-  };
+function toUncaught(reason, from) {
+  if (isErrorLike(reason)) return reason;
+  const error = new Error(
+    `This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${describeReason(reason)}".`
+  );
+  error.name = "UnhandledPromiseRejection";
+  error.code = "ERR_UNHANDLED_REJECTION";
+  Error.captureStackTrace?.(error, from);
+  return error;
 }
-var runtimeLogger = createRuntimeLogger();
-function withRuntimeOperation(name, fn, attributes = {}) {
-  const parent = local.getStore();
-  const state = {
-    id: randomUUID(),
-    name: String(safe({ name }).name).slice(0, 200),
-    parentId: parent?.sealed ? void 0 : parent?.id,
-    attributes: mergeContext(
-      parent?.sealed ? {} : parent?.attributes ?? {},
-      attributes
-    ),
-    startedAt: Date.now(),
-    outcome: "succeeded",
-    steps: []
+var warningId = 0;
+function emitNodeWarning(reason) {
+  try {
+    const text = isErrorLike(reason) ? String(reason.stack) : describeReason(reason);
+    process.emitWarning(text, "UnhandledPromiseRejectionWarning");
+    process.emitWarning(
+      `Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag \`--unhandled-rejections=strict\` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: ${++warningId})`,
+      "UnhandledPromiseRejectionWarning"
+    );
+  } catch {
+  }
+}
+function installUnhandledRejectionCapture(capture, mode = unhandledRejectionsMode()) {
+  if (mode === "strict") return () => {
   };
-  const operation = {
-    id: state.id,
-    setContext: (attrs) => {
-      if (!state.sealed) {
-        state.attributes = mergeContext(state.attributes, attrs);
-        trace.getActiveSpan()?.setAttributes(traceAttributes(state));
+  const listener = (reason, promise) => {
+    try {
+      if (promise && typeof promise === "object") {
+        const handled = handledPromises();
+        if (handled.has(promise)) return;
+        handled.add(promise);
       }
-    },
-    outcome: (status, message) => {
-      if (state.sealed) return;
-      state.outcome = status;
-      state.message = message;
-      if (status === "failed")
-        state.reportingStack = new Error("Operation outcome reported here").stack ?? "";
-    },
-    step: async (stepName, stepFn) => {
-      const started = Date.now();
-      let status = "succeeded";
-      try {
-        return await stepFn();
-      } catch (error) {
-        status = "failed";
-        throw error;
-      } finally {
-        if (!state.sealed && state.steps.length < 64)
-          state.steps.push({
-            name: String(safe({ name: stepName }).name).slice(0, 200),
-            status,
-            durationMs: Date.now() - started
-          });
+      const alone = process.listeners("unhandledRejection").every((fn) => fn[LISTENER_MARK] === true);
+      if (alone && mode === "throw") {
+        const error = toUncaught(reason, listener);
+        process.nextTick(() => {
+          throw error;
+        });
+        return;
       }
+      if (alone && mode === "warn-with-error-code") {
+        emitNodeWarning(reason);
+        process.exitCode = 1;
+      }
+      markRecorded(reason);
+      capture(reason);
+    } catch {
     }
   };
-  const run = () => local.run(state, async () => {
-    let thrown;
-    try {
-      return await fn(operation);
-    } catch (error) {
-      state.outcome = "failed";
-      thrown = error;
-      throw error;
-    } finally {
-      trace.getActiveSpan()?.setAttributes({
-        ...traceAttributes(state),
-        "autter.operation.outcome": state.outcome
-      });
-      if (state.outcome === "failed" && !thrown)
-        config?.reportOutcome(
-          state.name,
-          state.message ?? "Operation failed",
-          {
-            ...traceAttributes(state),
-            "autter.outcome.stack": state.reportingStack ?? ""
-          }
-        );
-      emit(
-        state.outcome === "failed" ? "error" : "info",
-        state.message ?? `${state.name}: ${state.outcome}`,
-        {
-          ...operationAttributes(state),
-          ...thrown instanceof Error ? {
-            "exception.type": thrown.name,
-            "exception.stacktrace": thrown.stack ?? ""
-          } : {}
-        },
-        {
-          "autter.event.type": "operation",
-          "autter.operation.outcome": state.outcome,
-          "autter.operation.duration_ms": Date.now() - state.startedAt,
-          "autter.operation.steps": state.steps
-        }
-      );
-      state.sealed = true;
-    }
-  });
-  return config ? config.run(state.name, run, traceAttributes(state)) : run();
+  listener[LISTENER_MARK] = true;
+  process.on("unhandledRejection", listener);
+  return () => {
+    process.off("unhandledRejection", listener);
+  };
 }
 
 // src/server.ts
@@ -1326,36 +1396,43 @@ async function runLlmSpan(tracer, info, fn) {
     kind: SpanKind.CLIENT,
     attributes: llmBaseAttributes(info)
   });
-  const setResponseModel = (model) => span.setAttribute("gen_ai.response.model", model);
+  const usage = {};
+  let responseModel;
+  const setResponseModel = (model) => {
+    responseModel = model;
+    span.setAttribute("gen_ai.response.model", model);
+  };
   const handle = {
-    setUsage: (usage) => span.setAttributes(usageAttributes(usage)),
-    setCost: (usd) => span.setAttribute("autter.llm.cost_usd", usd),
+    setUsage: (next) => {
+      Object.assign(usage, next);
+      span.setAttributes(usageAttributes(next));
+    },
+    setCost: (usd) => {
+      usage.costUsd = usd;
+      span.setAttribute("autter.llm.cost_usd", usd);
+    },
     setResponseModel,
     setModel: setResponseModel,
-    setAttributes: (attributes) => span.setAttributes(attributes)
+    setAttributes: (attributes) => span.setAttributes(activeRedactor(attributes))
   };
   try {
-    const result = await context.with(
-      trace2.setSpan(context.active(), span),
+    const result = await context2.with(
+      trace2.setSpan(context2.active(), span),
       () => fn(handle)
     );
     span.setStatus({ code: SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) {
-      span.recordException(err);
-      span.setAttribute("error.type", err.name);
-    }
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
+    if (isError(err)) span.setAttribute("error.type", err.name);
     throw err;
   } finally {
     span.end();
+    recordOperationAiUsage({ ...usage, model: responseModel ?? info.model });
   }
 }
 function recordLlmCall(tracer, call) {
+  recordOperationAiUsage({ ...call, model: call.model });
   const durationMs = Math.max(0, call.durationMs ?? 0);
   const endTime = /* @__PURE__ */ new Date();
   const startTime = new Date(endTime.getTime() - durationMs);
@@ -1368,51 +1445,54 @@ function recordLlmCall(tracer, call) {
     }
   );
   if (call.error !== void 0 && call.error !== null) {
-    if (call.error instanceof Error) {
-      span.recordException(call.error);
+    recordError(span, call.error);
+    if (isError(call.error)) {
       span.setAttribute("error.type", call.error.name);
     }
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: call.error instanceof Error ? call.error.message : String(call.error)
-    });
   } else {
     span.setStatus({ code: SpanStatusCode.OK });
   }
   span.end(endTime);
 }
-async function runWithSpan(tracer, name, fn, attributes) {
-  const span = tracer.startSpan(name, { attributes });
+async function runWithSpan(tracer, name, fn, attributes, links) {
+  const span = tracer.startSpan(name, {
+    attributes,
+    ...links?.length ? { links } : {}
+  });
   try {
-    const result = await context.with(
-      trace2.setSpan(context.active(), span),
+    const result = await context2.with(
+      trace2.setSpan(context2.active(), span),
       fn
     );
     span.setStatus({ code: SpanStatusCode.OK });
     return result;
   } catch (err) {
-    if (err instanceof Error) span.recordException(err);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: err instanceof Error ? err.message : String(err)
-    });
+    recordError(span, err);
     throw err;
   } finally {
     span.end();
   }
 }
-function expressRouteOf(req) {
-  const props = req;
-  const path = props?.route?.path;
-  if (typeof path !== "string" || path === "") return null;
-  const base = typeof props?.baseUrl === "string" ? props.baseUrl : "";
-  const route = base + path;
-  return route.startsWith("/") ? route : null;
+function recordError(span, err) {
+  const isErr = isError(err);
+  const message = activeRedactor.text(isErr ? err.message : String(err));
+  if (isErr) {
+    span.addEvent("exception", {
+      "exception.type": err.name,
+      "exception.message": message,
+      ...err.stack ? { "exception.stacktrace": activeRedactor.text(err.stack) } : {},
+      ...breadcrumbEventAttributes(activeRedactor.text, err)
+    });
+  }
+  span.setStatus({ code: SpanStatusCode.ERROR, message });
+}
+function redactWithActive(attributes) {
+  return activeRedactor(attributes);
 }
 function captureExpressRoute(_span, response) {
   if (!(response instanceof ServerResponse)) return;
-  const rpcMetadata = getRPCMetadata(context.active());
-  if (rpcMetadata?.type !== RPCType.HTTP) return;
+  const rpcMetadata = getRPCMetadata2(context2.active());
+  if (rpcMetadata?.type !== RPCType2.HTTP) return;
   const setRoute = () => {
     if (rpcMetadata.route) return;
     const route = expressRouteOf(response.req);
@@ -1420,6 +1500,21 @@ function captureExpressRoute(_span, response) {
   };
   response.prependListener("finish", setRoute);
   response.prependListener("close", setRoute);
+  if (hookRequests) startHookRequest(response);
+}
+var hookRequests = false;
+function structuredErrorAttributes(error) {
+  const attrs = { ...errorAttributes(error, { causes: false }) };
+  const internal = errorInternal(error);
+  if (internal) {
+    try {
+      attrs["autter.error.internal"] = JSON.stringify(
+        activeRedactor(internal)
+      ).slice(0, 4e3);
+    } catch {
+    }
+  }
+  return attrs;
 }
 var active = null;
 var activeAlwaysOnProvider = null;
@@ -1431,22 +1526,41 @@ function initAutterServer(options) {
     ""
   );
   const headers = { authorization: `Bearer ${options.apiKey}` };
+  const traceExporter = () => new CountingExporter(
+    new RedactingSpanExporter(
+      new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers }),
+      () => activeRedactor
+    )
+  );
   const environment = options.environment ?? process.env.NODE_ENV ?? "production";
   if (isDebugEnabled() || options.debug === true) setDebugMode(true);
   debugLog(`initialising service=${options.service} endpoint=${endpoint}`);
   activeRedactor = makeRedactor(options.redactAttributes ?? true);
-  const resource = new Resource({
+  const distro = options.distro ?? SDK_IDENTITY;
+  configureCompatCheck({ endpoint, enabled: options.compatCheck !== false, sdk: distro });
+  const resource = new Resource2({
     [ATTR_SERVICE_NAME]: options.service,
-    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || randomUUID2()).slice(0, 128),
+    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || randomUUID()).slice(0, 128),
     ...options.release ? { [ATTR_SERVICE_VERSION]: options.release } : {},
     "deployment.environment": environment,
+    // OTel semconv for SDK distributions: the ingester records which
+    // Autter SDK version each service runs (version compatibility checks).
+    "telemetry.distro.name": distro.name,
+    "telemetry.distro.version": distro.version,
     // Tells the ingester request metrics arrive on the metrics pipe, so
     // it must not also fold our server spans into usage rollups (that
     // would double-count every sampled request).
     "autter.metrics_wired": true
   });
+  const rootSampler = new TraceIdRatioBasedSampler(options.traceSampleRate ?? 0.01);
   const headSampler = new ParentBasedSampler({
-    root: new TraceIdRatioBasedSampler(options.traceSampleRate ?? 0.01)
+    root: rootSampler,
+    // Browsers (runtime-browser's traceparent) send unsampled parents: they
+    // make no sampling decision. Apply this service's own rate to such
+    // requests instead of never head-sampling them. The ratio sampler is
+    // deterministic by trace id, so services sharing a rate still agree
+    // with an upstream service that chose not to sample.
+    remoteParentNotSampled: rootSampler
   });
   const retainOnError = options.retainTracesOnError !== false;
   const slowThresholdMs = Number.isFinite(options.retainTracesAboveMs) ? Math.max(0, options.retainTracesAboveMs) : 0;
@@ -1454,30 +1568,24 @@ function initAutterServer(options) {
   let sampler = retainTraces ? new RecordUnsampledSampler(headSampler) : headSampler;
   if (options.llmTracing !== false) sampler = new LlmAwareSampler(sampler);
   const errorTraceBuffer = retainTraces ? new ErrorTraceRetentionProcessor(
-    new BatchSpanProcessor(
-      new CountingExporter(
-        new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-      ),
-      { scheduledDelayMillis: 2e3 }
-    ),
+    new BatchSpanProcessor(traceExporter(), { scheduledDelayMillis: 2e3 }),
     retainOnError,
     slowThresholdMs
   ) : null;
-  const mainSpanProcessor = new BatchSpanProcessor(
-    new CountingExporter(
-      new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-    )
-  );
+  const mainSpanProcessor = new BatchSpanProcessor(traceExporter());
   const metricReader = new PeriodicExportingMetricReader({
-    exporter: new OTLPMetricExporter({
-      url: `${endpoint}/v1/metrics`,
-      headers,
-      // Deltas, not lifetime totals: the ingester SUMs data points
-      // into runtime_metrics_1m, and the default (cumulative)
-      // temporality would re-count every past request on each
-      // 60 s export.
-      temporalityPreference: AggregationTemporalityPreference.DELTA
-    }),
+    exporter: new RedactingMetricExporter(
+      new OTLPMetricExporter({
+        url: `${endpoint}/v1/metrics`,
+        headers,
+        // Deltas, not lifetime totals: the ingester SUMs data points
+        // into runtime_metrics_1m, and the default (cumulative)
+        // temporality would re-count every past request on each
+        // 60 s export.
+        temporalityPreference: AggregationTemporalityPreference.DELTA
+      }),
+      () => activeRedactor
+    ),
     exportIntervalMillis: options.metricIntervalMs ?? 6e4
   });
   const sdk = new NodeSDK({
@@ -1503,16 +1611,14 @@ function initAutterServer(options) {
   });
   sdk.start();
   const stopMemoryMetrics = options.memoryMetrics === false ? null : startMemoryMetrics();
+  noteCompatFeature("endpoint_latency");
+  if (stopMemoryMetrics) noteCompatFeature("memory_metrics");
+  if (options.llmTracing !== false) noteCompatFeature("llm_calls");
   const alwaysOnProvider = new BasicTracerProvider({
     resource,
     sampler: new AlwaysOnSampler(),
     spanProcessors: [
-      new BatchSpanProcessor(
-        new CountingExporter(
-          new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers })
-        ),
-        { scheduledDelayMillis: 2e3 }
-      )
+      new BatchSpanProcessor(traceExporter(), { scheduledDelayMillis: 2e3 })
     ]
   });
   const errorTracer = alwaysOnProvider.getTracer("autter-errors");
@@ -1521,53 +1627,73 @@ function initAutterServer(options) {
   function captureException2(error, attributes) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
-    const isError = error instanceof Error;
-    const message = isError ? error.message : String(error);
-    const redacted = activeRedactor(attributes);
+    const isErr = isError(error);
+    const message = activeRedactor.text(isErr ? error.message : String(error));
+    const stackText = isErr && error.stack ? activeRedactor.text(error.stack) : "";
+    const split = splitFingerprint(attributes);
+    const fingerprint = fingerprintEventAttributes(split.fingerprint, activeRedactor.text);
+    if (fingerprint["autter.fingerprint"]) noteCompatFeature("fingerprint_override");
+    const redacted = activeRedactor(split.attributes);
     const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
-    const span = reuseActive ? activeSpan : errorTracer.startSpan(isError ? error.name : "Error");
-    span.setAttributes({ "autter.severity": "error", ...redacted });
-    if (isError && error.stack) {
-      if (redacted["autter.handled"] === true) {
-        span.addEvent("exception", {
-          "exception.type": error.name,
-          "exception.message": message,
-          "exception.stacktrace": error.stack,
-          "autter.handled": true,
-          "autter.sampled": redacted["autter.sampled"] === true
-        });
-      } else {
-        span.recordException(error);
-      }
+    const span = reuseActive ? activeSpan : errorTracer.startSpan(isErr ? error.name : "Error");
+    const structured = structuredErrorAttributes(error);
+    const causes = errorAttributes(error);
+    const declared = {
+      ...Object.fromEntries(Object.entries(causes).filter(([key]) => key !== "autter.error.internal")),
+      ...fingerprint
+    };
+    const requestId = currentOperation()?.requestId;
+    span.setAttributes({
+      "autter.severity": "error",
+      ...redacted,
+      ...structured,
+      ...requestId ? { "autter.request.id": requestId } : {}
+    });
+    markCaptured(error);
+    noteOperationError(error);
+    notifyException(error, { ...redacted, ...fingerprint });
+    if (isErr && stackText) {
+      span.addEvent("exception", {
+        "exception.type": error.name,
+        "exception.message": message,
+        "exception.stacktrace": stackText,
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared,
+        ...breadcrumbEventAttributes(activeRedactor.text, error)
+      });
     } else {
       const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureException")).join("\n");
       span.addEvent("exception", {
-        "exception.type": isError ? error.name : "Error",
+        "exception.type": isErr ? error.name : "Error",
         "exception.message": message,
-        ...stack ? { "exception.stacktrace": stack } : {},
-        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {}
+        ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+        ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
+        ...declared,
+        ...breadcrumbEventAttributes(activeRedactor.text, error)
       });
     }
     span.setStatus({ code: SpanStatusCode.ERROR, message });
     if (!reuseActive) span.end();
   }
-  function captureMessage2(message, severity2 = "warning", attributes) {
-    if (severity2 === "error" || severity2 === "fatal") {
+  function captureMessage2(message, severity = "warning", attributes) {
+    if (severity === "error" || severity === "fatal") {
       errorTraceBuffer?.retainActiveTrace();
     }
     telemetryStats.markCaptured();
     const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureMessage")).join("\n");
+    const safeMessage = activeRedactor.text(message);
     const span = errorTracer.startSpan("Message", {
-      attributes: { "autter.severity": severity2, ...activeRedactor(attributes) }
+      attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
     });
     span.addEvent("exception", {
       "exception.type": "Message",
-      "exception.message": message,
-      ...stack ? { "exception.stacktrace": stack } : {},
-      "autter.severity": severity2
+      "exception.message": safeMessage,
+      ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+      "autter.severity": severity,
+      ...breadcrumbEventAttributes(activeRedactor.text)
     });
-    span.setStatus({ code: SpanStatusCode.ERROR, message });
+    span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     span.end();
   }
   function reportOutcome2(name, message, attributes) {
@@ -1593,18 +1719,29 @@ function initAutterServer(options) {
     apiKey: options.apiKey,
     service: options.service,
     environment,
+    distro,
     release: options.release,
     options: options.logging,
     redact: activeRedactor,
-    run: (name, fn, attributes) => runWithSpan(processTracer, name, fn, activeRedactor(attributes)),
+    run: (name, fn, attributes, links) => runWithSpan(processTracer, name, fn, activeRedactor(attributes), links),
     reportOutcome: reportOutcome2
   });
+  hookRequests = options.logging?.requests === true;
+  let onCrash = null;
+  let uninstallRejections = null;
   if (options.captureGlobalErrors !== false) {
-    process.on("uncaughtExceptionMonitor", (err) => {
+    onCrash = (err) => {
+      if (recordedAsRejection(err)) return;
       captureException2(err, { "autter.unhandled": true });
       if (options.autoFlush === false) void Promise.resolve(flushTarget.forceFlush()).catch(() => {
       });
-    });
+    };
+    process.on("uncaughtExceptionMonitor", onCrash);
+    if (options.captureUnhandledRejections !== false) {
+      uninstallRejections = installUnhandledRejectionCapture(
+        (reason) => captureException2(reason, { "autter.unhandled_rejection": true })
+      );
+    }
   }
   const flushTarget = {
     forceFlush: async () => {
@@ -1637,6 +1774,9 @@ function initAutterServer(options) {
     trackLlmCall: (call) => recordLlmCall(llmTracer, call),
     shutdown: async () => {
       const logShutdown = await Promise.allSettled([shutdownRuntimeLogger()]);
+      hookRequests = false;
+      if (onCrash) process.off("uncaughtExceptionMonitor", onCrash);
+      uninstallRejections?.();
       stopMemoryMetrics?.();
       active = null;
       activeAlwaysOnProvider = null;
@@ -1657,17 +1797,41 @@ function captureException(error, attributes) {
     active.captureException(error, attributes);
     return;
   }
-  const span = trace2.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", { attributes });
-  if (error instanceof Error) span.recordException(error);
-  span.setStatus({
-    code: SpanStatusCode.ERROR,
-    message: error instanceof Error ? error.message : String(error)
+  if (loggerOnlyCapture) {
+    loggerOnlyCapture(error, attributes);
+    return;
+  }
+  markCaptured(error);
+  noteOperationError(error);
+  const split = splitFingerprint(attributes);
+  const fingerprint = fingerprintEventAttributes(split.fingerprint, activeRedactor.text);
+  notifyException(error, { ...split.attributes, ...fingerprint });
+  const span = trace2.getTracer("autter-errors").startSpan(isError(error) ? error.name : "Error", {
+    attributes: { ...activeRedactor(split.attributes), ...fingerprint }
   });
+  recordError(span, error);
   span.end();
 }
+var loggerOnlyCapture = null;
+function setLoggerOnlyCapture(fn) {
+  loggerOnlyCapture = fn;
+}
+function serverActive() {
+  return active !== null;
+}
+setRequestExceptionCapturer((error, attributes) => captureException(error, attributes));
+setRequestSpanAnnotator((attributes) => {
+  const span = trace2.getActiveSpan();
+  if (span?.isRecording()) span.setAttributes(activeRedactor(splitFingerprint(attributes).attributes));
+});
 function withProcessSpan(name, fn, attributes) {
   if (active) return active.withProcessSpan(name, fn, attributes);
-  return runWithSpan(trace2.getTracer("autter-processes"), name, fn, attributes);
+  return runWithSpan(
+    trace2.getTracer("autter-processes"),
+    name,
+    fn,
+    activeRedactor(attributes)
+  );
 }
 function withLlmCall(info, fn) {
   if (active) return active.withLlmCall(info, fn);
@@ -1680,20 +1844,22 @@ function trackLlmCall(call) {
   }
   recordLlmCall(trace2.getTracer("autter-llm"), call);
 }
-function captureMessage(message, severity2 = "warning", attributes) {
+function captureMessage(message, severity = "warning", attributes) {
   if (active) {
-    active.captureMessage(message, severity2, attributes);
+    active.captureMessage(message, severity, attributes);
     return;
   }
+  const safeMessage = activeRedactor.text(message);
   const span = trace2.getTracer("autter-errors").startSpan("Message", {
-    attributes: { "autter.severity": severity2, ...attributes }
+    attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
   });
   span.addEvent("exception", {
     "exception.type": "Message",
-    "exception.message": message,
-    "autter.severity": severity2
+    "exception.message": safeMessage,
+    "autter.severity": severity,
+    ...breadcrumbEventAttributes(activeRedactor.text)
   });
-  span.setStatus({ code: SpanStatusCode.ERROR, message });
+  span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
   span.end();
 }
 function reportOutcome(name, message, attributes) {
@@ -1715,7 +1881,7 @@ function makeSafeCapture(options) {
   const clean = (attributes) => attributes ? { ...redactAttributes(attributes, options) } : void 0;
   return {
     captureException: (error, attributes) => captureException(error, clean(attributes)),
-    captureMessage: (message, severity2, attributes) => captureMessage(message, severity2 ?? "warning", clean(attributes))
+    captureMessage: (message, severity, attributes) => captureMessage(message, severity ?? "warning", clean(attributes))
   };
 }
 function alwaysOnTracer(name) {
@@ -1787,15 +1953,26 @@ function extractUsage(result) {
   const r = result;
   const usage = r?.usage ?? r?.message?.usage;
   const meta = r?.usageMetadata;
+  const details = usage?.prompt_tokens_details;
+  const cached = usage?.cache_read_input_tokens ?? (typeof details?.cached_tokens === "number" ? details.cached_tokens : void 0) ?? meta?.cachedContentTokenCount;
   const input = usage?.prompt_tokens ?? usage?.input_tokens ?? meta?.promptTokenCount ?? void 0;
   const output = usage?.completion_tokens ?? usage?.output_tokens ?? meta?.candidatesTokenCount ?? void 0;
   const responseModel = r?.model ?? r?.modelVersion;
   return {
     inputTokens: typeof input === "number" ? input : void 0,
     outputTokens: typeof output === "number" ? output : void 0,
+    cacheReadTokens: typeof cached === "number" ? cached : void 0,
     responseModel: typeof responseModel === "string" ? responseModel : void 0
   };
 }
+function rollUp(model, usage) {
+  recordOperationAiUsage({
+    model: usage.responseModel ?? model,
+    ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
+    ...usage.outputTokens !== void 0 ? { outputTokens: usage.outputTokens } : {},
+    ...usage.cacheReadTokens !== void 0 ? { cacheReadTokens: usage.cacheReadTokens } : {}
+  });
+}
 function applyUsage(span, usage) {
   if (usage.inputTokens !== void 0) {
     span.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens);
@@ -1808,14 +1985,10 @@ function applyUsage(span, usage) {
   }
 }
 function endWithError(span, err) {
-  if (err instanceof Error) span.recordException(err);
-  span.setStatus({
-    code: SpanStatusCode2.ERROR,
-    message: err instanceof Error ? err.message : String(err)
-  });
+  recordError(span, err);
   span.end();
 }
-function wrapStream(stream, span) {
+function wrapStream(stream, span, model) {
   let ended = false;
   const seen = {
     inputTokens: void 0,
@@ -1826,6 +1999,7 @@ function wrapStream(stream, span) {
     if (ended) return;
     ended = true;
     applyUsage(span, seen);
+    rollUp(model, seen);
     span.setAttribute("autter.llm.streamed", true);
     if (err !== void 0) {
       endWithError(span, err);
@@ -1847,6 +2021,7 @@ function wrapStream(stream, span) {
                   const usage = extractUsage(step.value);
                   if (usage.inputTokens !== void 0) seen.inputTokens = usage.inputTokens;
                   if (usage.outputTokens !== void 0) seen.outputTokens = usage.outputTokens;
+                  if (usage.cacheReadTokens !== void 0) seen.cacheReadTokens = usage.cacheReadTokens;
                   if (usage.responseModel) seen.responseModel = usage.responseModel;
                 } else {
                   finish();
@@ -1857,9 +2032,9 @@ function wrapStream(stream, span) {
                 throw err;
               }
             },
-            async return(value3) {
+            async return(value2) {
               finish();
-              return inner.return ? inner.return(value3) : { done: true, value: void 0 };
+              return inner.return ? inner.return(value2) : { done: true, value: void 0 };
             },
             async throw(err) {
               finish(err);
@@ -1869,8 +2044,8 @@ function wrapStream(stream, span) {
           };
         };
       }
-      const value2 = Reflect.get(target, prop, receiver);
-      return typeof value2 === "function" ? value2.bind(target) : value2;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
     }
   });
 }
@@ -1892,7 +2067,7 @@ function instrumentLlmClient(client, options) {
         "gen_ai.system": provider,
         "gen_ai.request.model": request.model,
         ...userId ? { "autter.user_id": userId } : {},
-        ...options?.attributes
+        ...redactWithActive(options?.attributes)
       }
     });
     let result;
@@ -1904,9 +2079,11 @@ function instrumentLlmClient(client, options) {
     }
     if (!(result instanceof Promise)) {
       if (result && typeof result === "object" && Symbol.asyncIterator in result) {
-        return wrapStream(result, span);
+        return wrapStream(result, span, request.model);
       }
-      applyUsage(span, extractUsage(result));
+      const usage = extractUsage(result);
+      applyUsage(span, usage);
+      rollUp(request.model, usage);
       span.setStatus({ code: SpanStatusCode2.OK });
       span.end();
       return result;
@@ -1914,9 +2091,11 @@ function instrumentLlmClient(client, options) {
     return result.then(
       (resolved) => {
         if (resolved && typeof resolved === "object" && Symbol.asyncIterator in resolved) {
-          return wrapStream(resolved, span);
+          return wrapStream(resolved, span, request.model);
         }
-        applyUsage(span, extractUsage(resolved));
+        const usage = extractUsage(resolved);
+        applyUsage(span, usage);
+        rollUp(request.model, usage);
         span.setStatus({ code: SpanStatusCode2.OK });
         span.end();
         return resolved;
@@ -1932,30 +2111,30 @@ function instrumentLlmClient(client, options) {
     if (cached) return cached;
     const proxy = new Proxy(target, {
       get(t, prop, receiver) {
-        const value2 = Reflect.get(t, prop, receiver);
-        if (typeof prop === "symbol") return value2;
+        const value = Reflect.get(t, prop, receiver);
+        if (typeof prop === "symbol") return value;
         const propPath = path ? `${path}.${prop}` : prop;
-        if (typeof value2 === "function") {
+        if (typeof value === "function") {
           if (CALL_METHODS.has(prop)) {
             return (...args) => {
               const first = args[0];
               if (first && typeof first === "object" && typeof first.model === "string") {
                 return traceCall(
-                  value2,
+                  value,
                   t,
                   propPath,
                   args
                 );
               }
-              return value2.apply(t, args);
+              return value.apply(t, args);
             };
           }
-          return value2.bind(t);
+          return value.bind(t);
         }
-        if (value2 !== null && typeof value2 === "object" && !(value2 instanceof Promise)) {
-          return deepProxy(value2, propPath);
+        if (value !== null && typeof value === "object" && !(value instanceof Promise)) {
+          return deepProxy(value, propPath);
         }
-        return value2;
+        return value;
       }
     });
     proxied.set(target, proxy);
@@ -2007,26 +2186,300 @@ ${frames.join("\n")}`;
     });
   } };
 }
+
+// src/framework-errors.ts
+function recordBoundaryError(error, req, rule) {
+  try {
+    const state = requestStateOf(req);
+    if (state) noteOperationError(error, false, state);
+    captureAtBoundary(error, state, rule);
+  } catch {
+  }
+}
+function autterErrorHandler(options = {}) {
+  return function autterErrorHandlerMiddleware(error, req, _res, next) {
+    recordBoundaryError(error, req, options.capture);
+    next(error);
+  };
+}
+function autterFastifyErrors(fastify, options, done) {
+  const rule = options?.capture;
+  fastify.addHook("onError", ((request, _reply, error, next) => {
+    recordBoundaryError(error, request?.raw, rule);
+    next();
+  }));
+  done?.();
+}
+autterFastifyErrors[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+autterFastifyErrors[/* @__PURE__ */ Symbol.for("fastify.display-name")] = "autter-runtime-errors";
+function autterKoa(options = {}) {
+  return async function autterKoaMiddleware(ctx, next) {
+    try {
+      await next();
+    } catch (error) {
+      recordBoundaryError(error, ctx?.req, options.capture);
+      throw error;
+    }
+  };
+}
+
+// src/logging-only.ts
+import {
+  SpanStatusCode as SpanStatusCode3,
+  trace as trace3
+} from "@opentelemetry/api";
+var activeLogging = null;
+function initAutterLogging(options) {
+  if (activeLogging) return activeLogging;
+  if (serverActive()) {
+    console.warn(
+      "[autter-runtime] initAutterLogging() ignored: initAutterServer() is already active and includes logging"
+    );
+    return {
+      captureException,
+      flush: flushRuntimeLogs,
+      shutdown: async () => {
+      }
+    };
+  }
+  if (isDebugEnabled() || options.debug === true) setDebugMode(true);
+  const endpoint = (options.endpoint ?? "https://otlp.autter.dev").replace(/\/$/, "");
+  const environment = options.environment ?? process.env.NODE_ENV ?? "production";
+  const redact = makeRedactor(options.redactAttributes ?? true);
+  const mode = options.exceptions ?? "auto";
+  debugLog(`initialising logger-only service=${options.service} endpoint=${endpoint}`);
+  function captureException2(error, attributes) {
+    markCaptured(error);
+    const split = splitFingerprint(attributes);
+    const fingerprint = fingerprintEventAttributes(split.fingerprint, redact.text);
+    const redacted = redact(split.attributes);
+    const span = trace3.getActiveSpan();
+    if (mode === "auto" && span?.isRecording()) {
+      noteOperationError(error);
+      notifyException(error, { ...redacted, ...fingerprint });
+      span.setAttributes({ "autter.severity": "error", ...redacted, ...structuredErrorAttributes(error) });
+      const declared = { ...errorAttributes(error), ...fingerprint };
+      if (isError(error)) {
+        span.addEvent("exception", {
+          "exception.type": error.name,
+          "exception.message": error.message,
+          ...error.stack ? { "exception.stacktrace": error.stack } : {},
+          ...declared
+        });
+      } else {
+        span.addEvent("exception", {
+          "exception.type": "Error",
+          "exception.message": String(error),
+          ...declared
+        });
+      }
+      span.setStatus({
+        code: SpanStatusCode3.ERROR,
+        message: isError(error) ? error.message : String(error)
+      });
+      return;
+    }
+    notifyException(error, { ...redacted, ...fingerprint });
+    captureExceptionAsLog(error, { ...redacted, ...fingerprint });
+  }
+  const captured = /* @__PURE__ */ new WeakSet();
+  configureRuntimeLogger({
+    endpoint,
+    apiKey: options.apiKey ?? "",
+    service: options.service,
+    environment,
+    ...options.release ? { release: options.release } : {},
+    ...options.logging ? { options: options.logging } : {},
+    redact,
+    reportOutcome: (name, message, attributes) => {
+      runtimeLogger.error(message, {
+        ...attributes,
+        "autter.outcome.name": name.slice(0, 200),
+        "autter.outcome.message": message.slice(0, 1e3)
+      });
+    },
+    captureThrown: (error) => {
+      if (error && typeof error === "object") {
+        if (captured.has(error)) return;
+        captured.add(error);
+      }
+      captureException2(error);
+    }
+  });
+  setLoggerOnlyCapture(captureException2);
+  const onCrash = (error) => {
+    if (recordedAsRejection(error)) return;
+    captureException2(error, { "autter.unhandled": true });
+  };
+  let uninstallRejections = null;
+  if (options.captureGlobalErrors !== false) {
+    process.on("uncaughtExceptionMonitor", onCrash);
+    if (options.captureUnhandledRejections !== false)
+      uninstallRejections = installUnhandledRejectionCapture(
+        (reason) => captureException2(reason, { "autter.unhandled_rejection": true })
+      );
+  }
+  registerFlushTarget("logging", { forceFlush: () => flushRuntimeLogs() });
+  let autoFlushHandle = options.autoFlush === false ? null : installAutterAutoFlush();
+  const handle = {
+    captureException: captureException2,
+    flush: flushRuntimeLogs,
+    shutdown: async () => {
+      process.off("uncaughtExceptionMonitor", onCrash);
+      uninstallRejections?.();
+      uninstallRejections = null;
+      setLoggerOnlyCapture(null);
+      autoFlushHandle?.dispose();
+      autoFlushHandle = null;
+      unregisterFlushTargets();
+      activeLogging = null;
+      await shutdownRuntimeLogger();
+    }
+  };
+  activeLogging = handle;
+  return handle;
+}
+
+// src/enrichers.ts
+function headerOf(req, name) {
+  const headers = req?.headers;
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    return headers.get(name) ?? void 0;
+  }
+  const value = headers[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] === void 0 ? void 0 : String(value[0]);
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function enrichUserAgent() {
+  return (event, { req }) => {
+    const ua = headerOf(req, "user-agent");
+    if (!ua) return;
+    const info = parseUserAgent(ua);
+    if (info.browser) event.attributes["user_agent.browser"] = info.browser;
+    if (info.os) event.attributes["user_agent.os"] = info.os;
+    event.attributes["user_agent.device"] = info.device;
+    event.attributes["user_agent.bot"] = info.bot;
+  };
+}
+function enrichRequestSize() {
+  return (event, { req, res }) => {
+    const request = Number(headerOf(req, "content-length"));
+    if (Number.isFinite(request) && request >= 0)
+      event.attributes["http.request.body.size"] = request;
+    const raw = res?.getHeader?.(
+      "content-length"
+    );
+    const response = Number(raw);
+    if (raw !== void 0 && Number.isFinite(response) && response >= 0)
+      event.attributes["http.response.body.size"] = response;
+  };
+}
+var COUNTRY_HEADERS = [
+  "cf-ipcountry",
+  "x-vercel-ip-country",
+  "cloudfront-viewer-country",
+  "x-country-code",
+  "fastly-geo-country-code"
+];
+function enrichEdgeGeo() {
+  return (event, { req }) => {
+    for (const name of COUNTRY_HEADERS) {
+      const value = headerOf(req, name)?.trim().toUpperCase();
+      if (value && /^[A-Z]{2}$/.test(value) && value !== "XX" && value !== "T1") {
+        event.attributes["geo.country.iso_code"] = value;
+        return;
+      }
+    }
+  };
+}
+var REGION_VARS = [
+  "AUTTER_REGION",
+  "AWS_REGION",
+  "VERCEL_REGION",
+  "FLY_REGION",
+  "RAILWAY_REPLICA_REGION",
+  "GOOGLE_CLOUD_REGION",
+  "CLOUD_RUN_REGION",
+  "RENDER_REGION",
+  "AZURE_REGION"
+];
+var COMMIT_VARS = [
+  "AUTTER_COMMIT",
+  "GIT_SHA",
+  "GIT_COMMIT",
+  "COMMIT_SHA",
+  "SOURCE_COMMIT",
+  "VERCEL_GIT_COMMIT_SHA",
+  "GITHUB_SHA",
+  "RENDER_GIT_COMMIT",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "HEROKU_SLUG_COMMIT",
+  "SOURCE_VERSION"
+];
+function enrichDeployment(env = process.env) {
+  const pick = (names) => names.map((name) => env[name]?.trim()).find((value) => value);
+  const region = pick(REGION_VARS)?.slice(0, 64);
+  const commit = pick(COMMIT_VARS)?.slice(0, 64);
+  return (event) => {
+    if (region) event.attributes["deployment.region"] = region;
+    if (commit) event.attributes["deployment.commit"] = commit;
+  };
+}
 export {
+  CODE_PATTERN,
+  COMPAT_MANIFEST,
+  INGESTER_VERSION_HEADER,
+  RuntimeError,
+  SDK_IDENTITY,
+  addBreadcrumb,
+  autterErrorHandler,
+  autterErrorResponse,
+  autterFastify,
+  autterFastifyErrors,
+  autterKoa,
+  autterRequests,
   captureException,
   captureMessage,
+  captureRequestError,
+  consoleSink,
   createBrowserRelayFetchHandler,
   createBrowserRelayHandler,
   createRuntimeLogger,
+  defineRuntimeErrors,
   emitLlmSelftestTrace,
+  enrichDeployment,
+  enrichEdgeGeo,
+  enrichRequestSize,
+  enrichUserAgent,
+  errorAttributes,
+  evaluateCompat,
+  fetchIngesterCompat,
+  fileSink,
   flushRuntimeLogs,
+  initAutterLogging,
   initAutterServer,
   installAutterAutoFlush,
   instrumentLlmClient,
+  isRuntimeErrorLike,
   makeSafeCapture,
+  otlpSink,
   redactAttributes,
+  redactText,
   reportOutcome,
+  runDoctor,
+  runInBackground,
+  runtimeContext,
   runtimeLogStats,
   runtimeLogger,
   sanitizeBrowserPayload,
   startCaughtExceptionSampler,
+  toClientError,
   trackLlmCall,
+  unhandledRejectionsMode,
   withLlmCall,
   withProcessSpan,
-  withRuntimeOperation
+  withRuntimeOperation,
+  withRuntimeRequest
 };