@autter/runtime-node 1.5.0 → 1.6.0

package/dist/index.js

@@ -2,6 +2,8 @@ import {
   CODE_PATTERN,
   DEFAULT_REQUEST_ID_HEADER,
   RuntimeError,
+  addBreadcrumb,
+  breadcrumbEventAttributes,
   captureExceptionAsLog,
   compileIgnore,
   configureRuntimeLogger,
@@ -15,7 +17,10 @@ import {
   errorCodeOf,
   errorInternal,
   fileSink,
+  fingerprintEventAttributes,
+  fingerprintValues,
   flushRuntimeLogs,
+  isError,
   isRuntimeErrorLike,
   local,
   makeRedactor,
@@ -35,13 +40,15 @@ import {
   runtimeContext,
   runtimeLogStats,
   runtimeLogger,
+  sanitizeBreadcrumbs,
   shutdownRuntimeLogger,
+  splitFingerprint,
   toClientError,
   withRuntimeOperation
-} from "./chunk-3TJHUCZ6.js";
+} from "./chunk-FBKYOHU2.js";
 import {
   runDoctor
-} from "./chunk-ZS4WQJQR.js";
+} from "./chunk-Y4T7SQMO.js";
 import {
   COMPAT_MANIFEST,
   CountingExporter,
@@ -62,7 +69,7 @@ import {
   setDebugMode,
   telemetryStats,
   unregisterFlushTargets
-} from "./chunk-L7HWKMCZ.js";
+} from "./chunk-OY2HTUWY.js";
 
 // src/relay.ts
 var IpWindow = class {
@@ -102,6 +109,7 @@ var EVENT_TYPES = /* @__PURE__ */ new Set([
   "timing"
 ]);
 var SEVERITIES = /* @__PURE__ */ new Set(["fatal", "error", "warning", "info"]);
+var TRACE_ID = /^(?!0{32})[0-9a-f]{32}$/;
 var CONTEXT_MAX_DEPTH = 6;
 var CONTEXT_MAX_NODES = 256;
 var CONTEXT_MAX_STRING = 4e3;
@@ -214,6 +222,27 @@ 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;
@@ -241,7 +270,11 @@ function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
       ...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 ? relayContext(e.context, redactor) : {}
+      ...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 {
@@ -275,6 +308,9 @@ function forward(payload, opts) {
     );
     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)))(
@@ -413,7 +449,7 @@ import {
   SpanStatusCode,
   TraceFlags
 } from "@opentelemetry/api";
-import { getRPCMetadata, RPCType } from "@opentelemetry/core";
+import { getRPCMetadata as getRPCMetadata2, RPCType as RPCType2 } from "@opentelemetry/core";
 import {
   AggregationTemporalityPreference,
   OTLPMetricExporter
@@ -602,6 +638,7 @@ function startMemoryMetrics() {
 // 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();
@@ -610,6 +647,11 @@ 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);
 }
@@ -624,17 +666,48 @@ function expressRouteOf(req) {
 function defaultShouldCapture(error) {
   return error instanceof RuntimeError || errorCodeOf(error) !== void 0 || responseStatusOf(error) >= 500;
 }
-function captureAtBoundary(error, state, rule = void 0) {
-  const wanted = typeof rule === "function" ? rule(error) : rule === void 0 ? defaultShouldCapture(error) : rule;
+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 {
-    if (state && !state.sealed) local.run(state, () => capturer(error));
-    else capturer(error);
+    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 {
+    }
+    return;
+  }
+  captureAtBoundary(error, currentOperation(), true, attributes);
+}
 function bindEmitter(emitter, state) {
   const target = emitter;
   if (!target || typeof target !== "object" || target[BOUND]) return;
@@ -976,6 +1049,132 @@ function startHookRequest(res) {
   local.enterWith(state);
 }
 
+// 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 {
+    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;
+    }
+  }
+  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 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 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 listener = (reason, promise) => {
+    try {
+      if (promise && typeof promise === "object") {
+        const handled = handledPromises();
+        if (handled.has(promise)) return;
+        handled.add(promise);
+      }
+      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 {
+    }
+  };
+  listener[LISTENER_MARK] = true;
+  process.on("unhandledRejection", listener);
+  return () => {
+    process.off("unhandledRejection", listener);
+  };
+}
+
 // src/server.ts
 var LLM_MARKER_ATTRIBUTES = [
   "gen_ai.operation.name",
@@ -1225,7 +1424,7 @@ async function runLlmSpan(tracer, info, fn) {
     return result;
   } catch (err) {
     recordError(span, err);
-    if (err instanceof Error) span.setAttribute("error.type", err.name);
+    if (isError(err)) span.setAttribute("error.type", err.name);
     throw err;
   } finally {
     span.end();
@@ -1247,7 +1446,7 @@ function recordLlmCall(tracer, call) {
   );
   if (call.error !== void 0 && call.error !== null) {
     recordError(span, call.error);
-    if (call.error instanceof Error) {
+    if (isError(call.error)) {
       span.setAttribute("error.type", call.error.name);
     }
   } else {
@@ -1275,13 +1474,14 @@ async function runWithSpan(tracer, name, fn, attributes, links) {
   }
 }
 function recordError(span, err) {
-  const isError = err instanceof Error;
-  const message = activeRedactor.text(isError ? err.message : String(err));
-  if (isError) {
+  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) } : {}
+      ...err.stack ? { "exception.stacktrace": activeRedactor.text(err.stack) } : {},
+      ...breadcrumbEventAttributes(activeRedactor.text, err)
     });
   }
   span.setStatus({ code: SpanStatusCode.ERROR, message });
@@ -1291,8 +1491,8 @@ function redactWithActive(attributes) {
 }
 function captureExpressRoute(_span, response) {
   if (!(response instanceof ServerResponse)) return;
-  const rpcMetadata = getRPCMetadata(context2.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);
@@ -1352,8 +1552,15 @@ function initAutterServer(options) {
     // 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;
@@ -1420,18 +1627,22 @@ function initAutterServer(options) {
   function captureException2(error, attributes) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
-    const isError = error instanceof Error;
-    const message = activeRedactor.text(isError ? error.message : String(error));
-    const stackText = isError && error.stack ? activeRedactor.text(error.stack) : "";
-    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");
+    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")
-    );
+    const declared = {
+      ...Object.fromEntries(Object.entries(causes).filter(([key]) => key !== "autter.error.internal")),
+      ...fingerprint
+    };
     const requestId = currentOperation()?.requestId;
     span.setAttributes({
       "autter.severity": "error",
@@ -1441,23 +1652,25 @@ function initAutterServer(options) {
     });
     markCaptured(error);
     noteOperationError(error);
-    notifyException(error, redacted);
-    if (isError && stackText) {
+    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
+        ...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": activeRedactor.text(stack) } : {},
         ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
-        ...declared
+        ...declared,
+        ...breadcrumbEventAttributes(activeRedactor.text, error)
       });
     }
     span.setStatus({ code: SpanStatusCode.ERROR, message });
@@ -1477,7 +1690,8 @@ function initAutterServer(options) {
       "exception.type": "Message",
       "exception.message": safeMessage,
       ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
-      "autter.severity": severity
+      "autter.severity": severity,
+      ...breadcrumbEventAttributes(activeRedactor.text)
     });
     span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     span.end();
@@ -1513,12 +1727,21 @@ function initAutterServer(options) {
     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 () => {
@@ -1552,6 +1775,8 @@ function initAutterServer(options) {
     shutdown: async () => {
       const logShutdown = await Promise.allSettled([shutdownRuntimeLogger()]);
       hookRequests = false;
+      if (onCrash) process.off("uncaughtExceptionMonitor", onCrash);
+      uninstallRejections?.();
       stopMemoryMetrics?.();
       active = null;
       activeAlwaysOnProvider = null;
@@ -1578,9 +1803,11 @@ function captureException(error, attributes) {
   }
   markCaptured(error);
   noteOperationError(error);
-  notifyException(error, attributes);
-  const span = trace2.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", {
-    attributes: activeRedactor(attributes)
+  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();
@@ -1592,7 +1819,11 @@ function setLoggerOnlyCapture(fn) {
 function serverActive() {
   return active !== null;
 }
-setRequestExceptionCapturer((error) => captureException(error));
+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(
@@ -1625,7 +1856,8 @@ function captureMessage(message, severity = "warning", attributes) {
   span.addEvent("exception", {
     "exception.type": "Message",
     "exception.message": safeMessage,
-    "autter.severity": severity
+    "autter.severity": severity,
+    ...breadcrumbEventAttributes(activeRedactor.text)
   });
   span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
   span.end();
@@ -1955,6 +2187,42 @@ ${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,
@@ -1982,14 +2250,16 @@ function initAutterLogging(options) {
   debugLog(`initialising logger-only service=${options.service} endpoint=${endpoint}`);
   function captureException2(error, attributes) {
     markCaptured(error);
-    const redacted = redact(attributes);
+    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);
+      notifyException(error, { ...redacted, ...fingerprint });
       span.setAttributes({ "autter.severity": "error", ...redacted, ...structuredErrorAttributes(error) });
-      const declared = errorAttributes(error);
-      if (error instanceof Error) {
+      const declared = { ...errorAttributes(error), ...fingerprint };
+      if (isError(error)) {
         span.addEvent("exception", {
           "exception.type": error.name,
           "exception.message": error.message,
@@ -2005,12 +2275,12 @@ function initAutterLogging(options) {
       }
       span.setStatus({
         code: SpanStatusCode3.ERROR,
-        message: error instanceof Error ? error.message : String(error)
+        message: isError(error) ? error.message : String(error)
       });
       return;
     }
-    notifyException(error, redacted);
-    captureExceptionAsLog(error, redacted);
+    notifyException(error, { ...redacted, ...fingerprint });
+    captureExceptionAsLog(error, { ...redacted, ...fingerprint });
   }
   const captured = /* @__PURE__ */ new WeakSet();
   configureRuntimeLogger({
@@ -2037,9 +2307,18 @@ function initAutterLogging(options) {
     }
   });
   setLoggerOnlyCapture(captureException2);
-  const onCrash = (error) => captureException2(error, { "autter.unhandled": true });
-  if (options.captureGlobalErrors !== false)
+  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 = {
@@ -2047,6 +2326,8 @@ function initAutterLogging(options) {
     flush: flushRuntimeLogs,
     shutdown: async () => {
       process.off("uncaughtExceptionMonitor", onCrash);
+      uninstallRejections?.();
+      uninstallRejections = null;
       setLoggerOnlyCapture(null);
       autoFlushHandle?.dispose();
       autoFlushHandle = null;
@@ -2152,11 +2433,16 @@ export {
   INGESTER_VERSION_HEADER,
   RuntimeError,
   SDK_IDENTITY,
+  addBreadcrumb,
+  autterErrorHandler,
   autterErrorResponse,
   autterFastify,
+  autterFastifyErrors,
+  autterKoa,
   autterRequests,
   captureException,
   captureMessage,
+  captureRequestError,
   consoleSink,
   createBrowserRelayFetchHandler,
   createBrowserRelayHandler,
@@ -2191,6 +2477,7 @@ export {
   startCaughtExceptionSampler,
   toClientError,
   trackLlmCall,
+  unhandledRejectionsMode,
   withLlmCall,
   withProcessSpan,
   withRuntimeOperation,