@autter/runtime-node 1.9.0 → 1.10.0

package/dist/index.js

@@ -51,15 +51,17 @@ import {
   stopLoggedErrorCapture,
   toClientError,
   withRuntimeOperation
-} from "./chunk-HHKQ3UCH.js";
+} from "./chunk-V65UY6LU.js";
 import {
-  runDoctor
-} from "./chunk-JSGGUWRD.js";
+  runDoctor,
+  runVerify
+} from "./chunk-3UODRQBD.js";
 import {
   COMPAT_MANIFEST,
   CountingExporter,
   INGESTER_VERSION_HEADER,
   SDK_IDENTITY,
+  authHeaders,
   configureCompatCheck,
   debugLog,
   ensureCompatConfigured,
@@ -69,14 +71,18 @@ import {
   installAutterAutoFlush,
   isDebugEnabled,
   noteCompatFeature,
+  noteIngestRefusal,
   noteRelayRejection,
   observeIngesterResponse,
   registerFlushTarget,
+  resolveIngestKey,
   setDebugMode,
   sharedSlot,
   telemetryStats,
-  unregisterFlushTargets
-} from "./chunk-ZKM76SDP.js";
+  unregisterFlushTargets,
+  warnKeyKind,
+  warnMissingKey
+} from "./chunk-KWAJIELR.js";
 
 // src/relay.ts
 var IpWindow = class {
@@ -358,18 +364,53 @@ function relayFingerprint(raw, redactor) {
 }
 var defaultRelayRedactor = makeRedactor(true);
 function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
-  if (typeof raw !== "object" || raw === null) return null;
+  const checked = checkBrowserPayload(raw, redactor);
+  return "payload" in checked ? checked.payload : null;
+}
+var MAX_RELAY_ISSUES = 5;
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "string") return value ? `"${value.slice(0, 40)}"` : "an empty string";
+  return typeof value === "undefined" ? "missing" : `a ${typeof value}`;
+}
+function checkBrowserPayload(raw, redactor = defaultRelayRedactor) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { issues: [{ path: [], message: `expected a JSON object, got ${describe(raw)}` }] };
+  }
   const p = raw;
-  if (p.version !== 1) return null;
-  if (typeof p.service !== "string" || !p.service) return null;
-  if (typeof p.environment !== "string" || !p.environment) return null;
-  if (!Array.isArray(p.events) || p.events.length > MAX_EVENTS) return null;
+  const issues = [];
+  const issue = (path, message) => {
+    if (issues.length < MAX_RELAY_ISSUES) issues.push({ path, message });
+  };
+  if (p.version !== 1) issue(["version"], `expected 1, got ${describe(p.version)}`);
+  if (typeof p.service !== "string" || !p.service) issue(["service"], `expected a non-empty string, got ${describe(p.service)}`);
+  if (typeof p.environment !== "string" || !p.environment) {
+    issue(["environment"], `expected a non-empty string, got ${describe(p.environment)}`);
+  }
+  if (!Array.isArray(p.events)) issue(["events"], `expected an array, got ${describe(p.events)}`);
+  else if (p.events.length > MAX_EVENTS) issue(["events"], `at most ${MAX_EVENTS} events per batch, got ${p.events.length}`);
+  if (Array.isArray(p.events) && p.events.length <= MAX_EVENTS) {
+    p.events.forEach((rawEvent, index) => {
+      if (typeof rawEvent !== "object" || rawEvent === null) {
+        issue(["events", index], `expected an object, got ${describe(rawEvent)}`);
+        return;
+      }
+      const e = rawEvent;
+      if (typeof e.type !== "string" || !EVENT_TYPES.has(e.type)) {
+        issue(["events", index, "type"], `expected one of ${[...EVENT_TYPES].join(", ")}, got ${describe(e.type)}`);
+      }
+      if (typeof e.timestamp !== "string") {
+        issue(["events", index, "timestamp"], `expected an ISO 8601 string, got ${describe(e.timestamp)}`);
+      }
+    });
+  }
+  if (issues.length) return { issues };
+  const service = p.service;
+  const environment = p.environment;
   const events = [];
   for (const rawEvent of p.events) {
-    if (typeof rawEvent !== "object" || rawEvent === null) return null;
     const e = rawEvent;
-    if (typeof e.type !== "string" || !EVENT_TYPES.has(e.type)) return null;
-    if (typeof e.timestamp !== "string") return null;
     events.push({
       type: e.type,
       timestamp: e.timestamp,
@@ -390,31 +431,62 @@ function sanitizeBrowserPayload(raw, redactor = defaultRelayRedactor) {
       ...typeof e.traceId === "string" && TRACE_ID.test(e.traceId) ? { traceId: e.traceId } : {}
     });
   }
-  return {
+  return { payload: {
     version: 1,
     ...typeof p.sessionId === "string" ? { sessionId: p.sessionId.slice(0, 100) } : {},
-    service: p.service.slice(0, 200),
-    environment: p.environment.slice(0, 100),
+    service: service.slice(0, 200),
+    environment: 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) {
+var NO_KEY_BODY = {
+  error: "relay has no ingest key",
+  fix: "set AUTTER_RUNTIME_KEY (a server key, autter_rt_\u2026) where the relay runs"
+};
+var FORWARD_ATTEMPTS = 3;
+var FORWARD_MAX_WAIT_MS = 1e4;
+function forward(payload, opts, apiKey) {
   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: {
-      "content-type": "application/json",
-      authorization: `Bearer ${opts.apiKey}`
-    },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(1e4)
-  }).then((response) => {
+  const body = JSON.stringify(payload);
+  const attempt = async (n) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...authHeaders(apiKey)
+        },
+        body,
+        signal: AbortSignal.timeout(1e4)
+      });
+    } catch (err) {
+      if (n >= FORWARD_ATTEMPTS) throw err;
+      await sleep(1e3 * 2 ** (n - 1));
+      return attempt(n + 1);
+    }
+    if ((response.status === 429 || response.status >= 500) && n < FORWARD_ATTEMPTS) {
+      const seconds = Number(response.headers.get("retry-after"));
+      await response.body?.cancel().catch(() => {
+      });
+      await sleep(seconds > 0 ? Math.min(seconds * 1e3, FORWARD_MAX_WAIT_MS) : 1e3 * 2 ** (n - 1));
+      return attempt(n + 1);
+    }
+    if (!response.ok) {
+      noteIngestRefusal({
+        status: response.status,
+        route: "/v1/browser",
+        endpoint,
+        body: await response.clone().text().catch(() => ""),
+        via: "relay"
+      });
+    }
     if (!compat) return;
     const types = new Set(
       (payload.events ?? []).map((e) => String(e.type))
@@ -425,20 +497,33 @@ function forward(payload, opts) {
       noteCompatFeature("browser_trace_propagation");
     }
     noteRelayRejection(types, response.status, response.headers);
-  }).catch((err) => {
+  };
+  void attempt(1).catch((err) => {
     (opts.onError ?? ((e) => console.warn("autter relay forward failed:", e)))(
       err
     );
   });
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 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);
+  const apiKey = resolveIngestKey(opts.apiKey);
+  if (!apiKey) warnMissingKey("relay");
+  else warnKeyKind(apiKey);
   return async (request) => {
     if (request.method !== "POST") {
       return new Response(null, { status: 405 });
     }
+    if (!apiKey) {
+      return new Response(JSON.stringify(NO_KEY_BODY), {
+        status: 500,
+        headers: { "content-type": "application/json" }
+      });
+    }
     if (limiter) {
       const ip = fetchClientKey(request, opts);
       if (!limiter.allow(ip)) {
@@ -468,13 +553,14 @@ function createBrowserRelayFetchHandler(opts) {
         status: 400
       });
     }
-    const payload = sanitizeBrowserPayload(raw, redactor);
-    if (!payload) {
-      return new Response(JSON.stringify({ error: "invalid payload" }), {
-        status: 400
+    const checked = checkBrowserPayload(raw, redactor);
+    if (!("payload" in checked)) {
+      return new Response(JSON.stringify({ error: "invalid payload", issues: checked.issues }), {
+        status: 400,
+        headers: { "content-type": "application/json" }
       });
     }
-    forward(payload, opts);
+    forward(checked.payload, opts, apiKey);
     return new Response(null, { status: 202 });
   };
 }
@@ -491,13 +577,16 @@ function createBrowserRelayHandler(opts) {
       res.end();
     }
   }
+  const apiKey = resolveIngestKey(opts.apiKey);
+  if (!apiKey) warnMissingKey("relay");
+  else warnKeyKind(apiKey);
   function handleParsed(raw, res) {
-    const payload = sanitizeBrowserPayload(raw, redactor);
-    if (!payload) {
-      respond(res, 400, { error: "invalid payload" });
+    const checked = checkBrowserPayload(raw, redactor);
+    if (!("payload" in checked)) {
+      respond(res, 400, { error: "invalid payload", issues: checked.issues });
       return;
     }
-    forward(payload, opts);
+    forward(checked.payload, opts, apiKey);
     respond(res, 202);
   }
   return (req, res) => {
@@ -505,6 +594,10 @@ function createBrowserRelayHandler(opts) {
       respond(res, 405);
       return;
     }
+    if (!apiKey) {
+      respond(res, 500, NO_KEY_BODY);
+      return;
+    }
     if (limiter) {
       const ip = nodeClientKey(req, opts);
       if (!limiter.allow(ip)) {
@@ -554,13 +647,13 @@ function createBrowserRelayHandler(opts) {
 
 // src/server.ts
 import { errorMonitor } from "events";
-import { createRequire } from "module";
-import { join } from "path";
+import { createRequire as createRequire2 } from "module";
+import { join as join2 } from "path";
 import { ServerResponse } from "http";
 import { randomUUID } from "crypto";
 import {
-  context as context2,
-  trace as trace2,
+  context as context3,
+  trace as trace3,
   SpanKind,
   SpanStatusCode,
   TraceFlags
@@ -806,6 +899,73 @@ var RedactingMetricExporter = class {
   }
 };
 
+// src/ingest-exporters.ts
+import { ExportResultCode as ExportResultCode2 } from "@opentelemetry/core";
+import {
+  AggregationTemporality as AggregationTemporality2
+} from "@opentelemetry/sdk-metrics";
+function refusalOf(result) {
+  if (result.code === ExportResultCode2.SUCCESS) return null;
+  const error = result.error;
+  return typeof error?.code === "number" ? { status: error.code, body: error.data } : null;
+}
+var NO_KEY = {
+  code: ExportResultCode2.FAILED,
+  error: new Error("no Autter ingest key: not sent (set AUTTER_RUNTIME_KEY)")
+};
+function observe(endpoint, route, callback) {
+  return (result) => {
+    const refusal = refusalOf(result);
+    if (refusal) noteIngestRefusal({ ...refusal, endpoint, route });
+    callback(result);
+  };
+}
+var IngestSpanExporter = class {
+  constructor(inner, target) {
+    this.inner = inner;
+    this.target = target;
+  }
+  inner;
+  target;
+  export(spans, resultCallback) {
+    if (!this.target.hasKey) {
+      resultCallback(NO_KEY);
+      return;
+    }
+    this.inner.export(spans, observe(this.target.endpoint, "/v1/traces", resultCallback));
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+  forceFlush() {
+    return this.inner.forceFlush?.() ?? Promise.resolve();
+  }
+};
+var IngestMetricExporter = class {
+  constructor(inner, target) {
+    this.inner = inner;
+    this.target = target;
+  }
+  inner;
+  target;
+  export(metrics2, resultCallback) {
+    if (!this.target.hasKey) {
+      resultCallback(NO_KEY);
+      return;
+    }
+    this.inner.export(metrics2, observe(this.target.endpoint, "/v1/metrics", resultCallback));
+  }
+  forceFlush() {
+    return this.inner.forceFlush();
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+  selectAggregationTemporality(instrumentType) {
+    return this.inner.selectAggregationTemporality ? this.inner.selectAggregationTemporality(instrumentType) : AggregationTemporality2.CUMULATIVE;
+  }
+};
+
 // src/memory.ts
 import { PerformanceObserver } from "perf_hooks";
 import { getHeapStatistics } from "v8";
@@ -914,6 +1074,27 @@ function captureAtBoundary(error, state, rule = void 0, attributes) {
   } catch {
   }
 }
+function requestScopeAttributes() {
+  try {
+    const out = {};
+    const state = local.getStore();
+    const active = context.active();
+    const metadata = getRPCMetadata(active);
+    const http = metadata?.type === RPCType.HTTP ? metadata : void 0;
+    const spanAttributes = http?.span?.attributes;
+    const req = state?.req;
+    const nodeRequest = !!req && typeof req === "object" && typeof req.url === "string" && req.url.startsWith("/");
+    const requestId = state?.requestId ?? spanAttributes?.["autter.request.id"];
+    if (typeof requestId === "string" && requestId) out["autter.request.id"] = requestId;
+    const route = http?.route ?? spanAttributes?.["http.route"] ?? (nodeRequest ? expressRouteOf(req) ?? normalizeRoutePath(pathOf(req)) : void 0);
+    if (typeof route === "string" && route) out["http.route"] = route;
+    const method = (nodeRequest ? req.method : void 0) ?? spanAttributes?.["http.request.method"] ?? spanAttributes?.["http.method"];
+    if (typeof method === "string" && method) out["http.request.method"] = method.toUpperCase();
+    return Object.keys(out).length > 0 ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function requestStateOf(req) {
   if (!req || typeof req !== "object") return void 0;
   return req[REQUEST_STATE];
@@ -1403,6 +1584,173 @@ function installUnhandledRejectionCapture(capture, mode = unhandledRejectionsMod
   };
 }
 
+// src/express-errors.ts
+import { createRequire } from "module";
+import { join } from "path";
+import { context as context2, trace as trace2 } from "@opentelemetry/api";
+import { Hook } from "require-in-the-middle";
+var PATCHED = /* @__PURE__ */ Symbol.for("autter.runtime.express.layer");
+var WRAPPED = /* @__PURE__ */ Symbol.for("autter.runtime.express.next");
+var ERRORS = /* @__PURE__ */ Symbol.for("autter.runtime.express.errors");
+var MAX_ERRORS = 8;
+function noteExpressError(req, error) {
+  if (error === void 0 || error === null || error === false) return;
+  if (error === "route" || error === "router") return;
+  if (!req || typeof req !== "object") return;
+  try {
+    const target = req;
+    let list = target[ERRORS];
+    if (!list) {
+      list = [];
+      target[ERRORS] = list;
+    }
+    if (list.length < MAX_ERRORS && !list.includes(error)) list.push(error);
+  } catch {
+  }
+}
+function wrapNext(req, next) {
+  if (typeof next !== "function") return next;
+  const fn = next;
+  const existing = fn[WRAPPED];
+  if (existing) return existing;
+  const wrapped = function autterExpressNext(...args) {
+    if (args.length > 0) noteExpressError(req, args[0]);
+    return fn.apply(this, args);
+  };
+  try {
+    fn[WRAPPED] = wrapped;
+  } catch {
+  }
+  return wrapped;
+}
+function patchLayerPrototype(proto) {
+  if (!proto || typeof proto !== "object") return false;
+  const target = proto;
+  if (target[PATCHED]) return true;
+  const requestName = typeof target.handleRequest === "function" ? "handleRequest" : typeof target.handle_request === "function" ? "handle_request" : null;
+  const errorName = typeof target.handleError === "function" ? "handleError" : typeof target.handle_error === "function" ? "handle_error" : null;
+  if (!requestName || !errorName) return false;
+  const handleRequest = target[requestName];
+  const handleError = target[errorName];
+  target[requestName] = function autterHandleRequest(req, res, next) {
+    let wrapped = next;
+    try {
+      wrapped = wrapNext(req, next);
+    } catch {
+      wrapped = next;
+    }
+    return handleRequest.call(this, req, res, wrapped);
+  };
+  target[errorName] = function autterHandleError(error, req, res, next) {
+    let wrapped = next;
+    try {
+      noteExpressError(req, error);
+      wrapped = wrapNext(req, next);
+    } catch {
+      wrapped = next;
+    }
+    return handleError.call(this, error, req, res, wrapped);
+  };
+  try {
+    Object.defineProperty(target, PATCHED, { value: true });
+  } catch {
+    target[PATCHED] = true;
+  }
+  return true;
+}
+var LAYER_FILES = ["express/lib/router/layer.js", "router/lib/layer.js"];
+function patchLayerModule(exports) {
+  try {
+    const Layer = exports;
+    if (typeof Layer === "function" && patchLayerPrototype(Layer.prototype))
+      debugLog("express: error capture installed");
+  } catch {
+  }
+}
+function scanModuleCache() {
+  try {
+    const cache = createRequire(join(process.cwd(), "autter-runtime-express.cjs")).cache;
+    for (const [key, entry] of Object.entries(cache)) {
+      const path = key.replace(/\\/g, "/");
+      if (LAYER_FILES.some((file) => path.endsWith(`/node_modules/${file}`)))
+        patchLayerModule(entry?.exports);
+    }
+  } catch {
+  }
+}
+var installed = false;
+function installExpressErrorCapture() {
+  if (installed) return;
+  installed = true;
+  scanModuleCache();
+  try {
+    new Hook(["express", "router"], { internals: true }, (exports, name) => {
+      const file = name.replace(/\\/g, "/");
+      if (LAYER_FILES.includes(file)) patchLayerModule(exports);
+      return exports;
+    });
+  } catch {
+  }
+}
+function patchFromRequest(req) {
+  try {
+    const app = req?.app;
+    if (!app || typeof app !== "function" && typeof app !== "object") return;
+    const router = app._router ?? app.router;
+    const layer = router?.stack?.[0];
+    if (layer && typeof layer === "object" && patchLayerPrototype(Object.getPrototypeOf(layer)))
+      debugLog("express: error capture installed (from a request)");
+  } catch {
+  }
+}
+function declaredStatus(error) {
+  if (!error || typeof error !== "object") return void 0;
+  try {
+    const value = error.status ?? error.statusCode;
+    const status = typeof value === "string" ? Number(value) : value;
+    return typeof status === "number" && Number.isInteger(status) && status >= 400 && status < 600 ? status : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function watchExpressResponse(span, res, enabled) {
+  const req = res.req;
+  if (!req) return;
+  const ctx = context2.active();
+  let done = false;
+  const settle = (finished) => {
+    if (done) return;
+    done = true;
+    try {
+      const errors = req[ERRORS];
+      if (!errors?.length) {
+        patchFromRequest(req);
+        return;
+      }
+      req[ERRORS] = void 0;
+      if (!enabled()) return;
+      if (finished && !(res.statusCode >= 500)) return;
+      if (errors.some((error2) => isCaptured(error2))) return;
+      const error = errors.find((candidate) => {
+        const status = declaredStatus(candidate);
+        return status === void 0 || status >= 500;
+      });
+      if (error === void 0) return;
+      const state = requestStateOf(req);
+      if (state && !state.sealed) noteOperationError(error, false, state);
+      const run = () => captureAtBoundary(error, state, true);
+      if (span.isRecording()) context2.with(trace2.setSpan(ctx, span), run);
+      else context2.with(ctx, run);
+    } catch {
+    }
+  };
+  try {
+    res.prependListener("finish", () => settle(true));
+    res.prependListener("close", () => settle(false));
+  } catch {
+  }
+}
+
 // src/route-label.ts
 import { getRPCMetadata as getRPCMetadata2, RPCType as RPCType2 } from "@opentelemetry/core";
 var ours = /* @__PURE__ */ new WeakMap();
@@ -1574,7 +1922,7 @@ var ErrorTraceRetentionProcessor = class {
   }
   /** Promote the active trace, if any — called on captured errors. */
   retainActiveTrace() {
-    const active = trace2.getActiveSpan()?.spanContext();
+    const active = trace3.getActiveSpan()?.spanContext();
     if (!active || (active.traceFlags & TraceFlags.SAMPLED) !== 0) return;
     const entry = this.entryFor(active.traceId);
     if (entry.retained) return;
@@ -1687,8 +2035,8 @@ async function runLlmSpan(tracer, info, fn) {
     setAttributes: (attributes) => span.setAttributes(S.redactor(attributes))
   };
   try {
-    const result = await context2.with(
-      trace2.setSpan(context2.active(), span),
+    const result = await context3.with(
+      trace3.setSpan(context3.active(), span),
       () => fn(handle)
     );
     span.setStatus({ code: SpanStatusCode.OK });
@@ -1731,8 +2079,8 @@ async function runWithSpan(tracer, name, fn, attributes, links) {
     ...links?.length ? { links } : {}
   });
   try {
-    const result = await context2.with(
-      trace2.setSpan(context2.active(), span),
+    const result = await context3.with(
+      trace3.setSpan(context3.active(), span),
       fn
     );
     span.setStatus({ code: SpanStatusCode.OK });
@@ -1762,7 +2110,7 @@ function redactWithActive(attributes) {
 }
 function patchLoadedHttpModules() {
   try {
-    const load = createRequire(join(process.cwd(), "autter-runtime-http.cjs"));
+    const load = createRequire2(join2(process.cwd(), "autter-runtime-http.cjs"));
     load("http");
     load("https");
   } catch {
@@ -1771,7 +2119,7 @@ function patchLoadedHttpModules() {
 var METRIC_ROUTE_ATTR = "autter.metric_has_route";
 function captureRequestRoute(span, response) {
   if (!(response instanceof ServerResponse)) return;
-  const rpcMetadata = getRPCMetadata3(context2.active());
+  const rpcMetadata = getRPCMetadata3(context3.active());
   if (rpcMetadata?.type !== RPCType3.HTTP) return;
   let failed = false;
   response.on(errorMonitor, () => {
@@ -1787,6 +2135,7 @@ function captureRequestRoute(span, response) {
     setRoute();
     if (rpcMetadata.route && !failed) span.setAttribute(METRIC_ROUTE_ATTR, true);
   });
+  if (S.expressErrors) watchExpressResponse(span, response, () => S.expressErrors === true);
   if (S.hookRequests) startHookRequest(response);
 }
 function structuredErrorAttributes(error) {
@@ -1808,12 +2157,14 @@ function initAutterServer(options) {
     /\/$/,
     ""
   );
-  const headers = { authorization: `Bearer ${options.apiKey}` };
+  const apiKey = resolveIngestKey(options.apiKey);
+  const headers = authHeaders(apiKey);
+  const ingestTarget = { endpoint, hasKey: apiKey !== null };
   const redactor = makeRedactor(options.redactAttributes ?? true);
   const queryPolicy = makeUrlQueryPolicy(options.keepQueryParams);
   const traceExporter = () => new CountingExporter(
     new RedactingSpanExporter(
-      new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers }),
+      new IngestSpanExporter(new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers }), ingestTarget),
       () => redactor,
       queryPolicy
     )
@@ -1821,6 +2172,8 @@ function initAutterServer(options) {
   const environment = options.environment ?? process.env.NODE_ENV ?? "production";
   if (isDebugEnabled() || options.debug === true) setDebugMode(true);
   debugLog(`initialising service=${options.service} endpoint=${endpoint}`);
+  if (apiKey === null) warnMissingKey("server", options.service);
+  else warnKeyKind(apiKey);
   S.redactor = redactor;
   const distro = options.distro ?? SDK_IDENTITY;
   configureCompatCheck({ endpoint, enabled: options.compatCheck !== false, sdk: distro });
@@ -1869,7 +2222,7 @@ function initAutterServer(options) {
   const mainSpanProcessor = new BatchSpanProcessor(traceExporter());
   const metricReader = new PeriodicExportingMetricReader({
     exporter: new RedactingMetricExporter(
-      new OTLPMetricExporter({
+      new IngestMetricExporter(new OTLPMetricExporter({
         url: `${endpoint}/v1/metrics`,
         headers,
         // Deltas, not lifetime totals: the ingester SUMs data points
@@ -1877,7 +2230,7 @@ function initAutterServer(options) {
         // temporality would re-count every past request on each
         // 60 s export.
         temporalityPreference: AggregationTemporalityPreference.DELTA
-      }),
+      }), ingestTarget),
       () => redactor
     ),
     exportIntervalMillis: options.metricIntervalMs ?? 6e4
@@ -1939,9 +2292,11 @@ function initAutterServer(options) {
     const fingerprint = fingerprintEventAttributes(split.fingerprint, redactor.text);
     if (fingerprint["autter.fingerprint"]) noteCompatFeature("fingerprint_override");
     const redacted = redactor(split.attributes);
-    const activeSpan = trace2.getActiveSpan();
-    const reuseActive = activeSpan?.isRecording() === true;
+    const crash = attributes?.["autter.unhandled"] === true;
+    const activeSpan = trace3.getActiveSpan();
+    const reuseActive = !crash && activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isErr ? error.name : "Error");
+    const scope = reuseActive ? void 0 : requestScopeAttributes();
     const structured = structuredErrorAttributes(error);
     const causes = errorAttributes(error);
     const declared = {
@@ -1950,6 +2305,7 @@ function initAutterServer(options) {
     };
     const requestId = currentOperation()?.requestId;
     span.setAttributes({
+      ...scope,
       "autter.severity": "error",
       ...redacted,
       ...structured,
@@ -2006,7 +2362,7 @@ function initAutterServer(options) {
     if (!errorFilter({ type: "OutcomeFailure", message: `${name}: ${message}` })) return;
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
-    const activeSpan = trace2.getActiveSpan();
+    const activeSpan = trace3.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan("OutcomeFailure");
     const safeOutcome = redactor({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
@@ -2035,7 +2391,7 @@ function initAutterServer(options) {
     const split = splitFingerprint(attributes);
     const fingerprint = fingerprintEventAttributes(split.fingerprint, redactor.text);
     const redacted = redactor(split.attributes);
-    const activeSpan = trace2.getActiveSpan();
+    const activeSpan = trace3.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isErr ? error.name : "Error");
     markCaptured(error);
@@ -2054,7 +2410,7 @@ function initAutterServer(options) {
   }
   configureRuntimeLogger({
     endpoint,
-    apiKey: options.apiKey,
+    apiKey: apiKey ?? "",
     service: options.service,
     environment,
     distro,
@@ -2065,6 +2421,8 @@ function initAutterServer(options) {
     reportOutcome: reportOutcome2
   });
   S.hookRequests = options.logging?.requests === true;
+  S.expressErrors = options.captureExpressErrors !== false;
+  if (S.expressErrors) installExpressErrorCapture();
   S.handled = captureHandled;
   startLoggedErrorCapture(options.captureLoggedErrors);
   let onCrash = null;
@@ -2123,6 +2481,7 @@ function initAutterServer(options) {
         S.alwaysOnProvider = null;
         S.handled = null;
         S.hookRequests = false;
+        S.expressErrors = false;
         S.redactor = makeRedactor(true);
       }
       autoFlushHandle?.dispose();
@@ -2151,7 +2510,7 @@ function captureException(error, attributes) {
   const split = splitFingerprint(attributes);
   const fingerprint = fingerprintEventAttributes(split.fingerprint, S.redactor.text);
   notifyException(error, { ...split.attributes, ...fingerprint });
-  const span = trace2.getTracer("autter-errors").startSpan(isError(error) ? error.name : "Error", {
+  const span = trace3.getTracer("autter-errors").startSpan(isError(error) ? error.name : "Error", {
     attributes: { ...S.redactor(split.attributes), ...fingerprint }
   });
   recordError(span, error);
@@ -2173,7 +2532,7 @@ function captureHandledError(error, attributes, severity) {
   markCaptured(error);
   const split = splitFingerprint(attributes);
   notifyException(error, { ...split.attributes, "autter.severity": severity });
-  const span = trace2.getTracer("autter-errors").startSpan(isError(error) ? error.name : "Error");
+  const span = trace3.getTracer("autter-errors").startSpan(isError(error) ? error.name : "Error");
   span.addEvent("exception", {
     ...S.redactor(split.attributes),
     "exception.type": isError(error) ? error.name : "Error",
@@ -2191,13 +2550,13 @@ function serverActive() {
 setRequestExceptionCapturer((error, attributes) => captureException(error, attributes));
 setHandledCapture(captureHandledError);
 setRequestSpanAnnotator((attributes) => {
-  const span = trace2.getActiveSpan();
+  const span = trace3.getActiveSpan();
   if (span?.isRecording()) span.setAttributes(S.redactor(splitFingerprint(attributes).attributes));
 });
 function withProcessSpan(name, fn, attributes) {
   if (S.active) return S.active.withProcessSpan(name, fn, attributes);
   return runWithSpan(
-    trace2.getTracer("autter-processes"),
+    trace3.getTracer("autter-processes"),
     name,
     fn,
     S.redactor(attributes)
@@ -2205,14 +2564,14 @@ function withProcessSpan(name, fn, attributes) {
 }
 function withLlmCall(info, fn) {
   if (S.active) return S.active.withLlmCall(info, fn);
-  return runLlmSpan(trace2.getTracer("autter-llm"), info, fn);
+  return runLlmSpan(trace3.getTracer("autter-llm"), info, fn);
 }
 function trackLlmCall(call) {
   if (S.active) {
     S.active.trackLlmCall(call);
     return;
   }
-  recordLlmCall(trace2.getTracer("autter-llm"), call);
+  recordLlmCall(trace3.getTracer("autter-llm"), call);
 }
 function captureMessage(message, severity = "warning", attributes) {
   if (S.active) {
@@ -2220,7 +2579,7 @@ function captureMessage(message, severity = "warning", attributes) {
     return;
   }
   const safeMessage = S.redactor.text(message);
-  const span = trace2.getTracer("autter-errors").startSpan("Message", {
+  const span = trace3.getTracer("autter-errors").startSpan("Message", {
     attributes: { "autter.severity": severity, ...S.redactor(attributes) }
   });
   span.addEvent("exception", {
@@ -2234,7 +2593,7 @@ function captureMessage(message, severity = "warning", attributes) {
 }
 function reportOutcome(name, message, attributes) {
   if (S.active) return S.active.reportOutcome(name, message, attributes);
-  const span = trace2.getTracer("autter-outcomes").startSpan("OutcomeFailure");
+  const span = trace3.getTracer("autter-outcomes").startSpan("OutcomeFailure");
   const safeOutcome = redactAttributes({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
   const safeName = String(safeOutcome["autter.outcome.name"] ?? "operation");
   const safeMessage = String(safeOutcome["autter.outcome.message"] ?? "failed");
@@ -2255,7 +2614,7 @@ function makeSafeCapture(options) {
   };
 }
 function alwaysOnTracer(name) {
-  return S.alwaysOnProvider ? S.alwaysOnProvider.getTracer(name) : trace2.getTracer(name);
+  return S.alwaysOnProvider ? S.alwaysOnProvider.getTracer(name) : trace3.getTracer(name);
 }
 function autterLlmTracer() {
   return alwaysOnTracer("autter-llm");
@@ -2275,7 +2634,7 @@ async function emitLlmSelftestTrace() {
       attributes: { "autter.selftest": true }
     },
     (llm) => {
-      traceId = trace2.getActiveSpan()?.spanContext().traceId ?? "";
+      traceId = trace3.getActiveSpan()?.spanContext().traceId ?? "";
       llm.setUsage({ inputTokens: 1, outputTokens: 1 });
       llm.setCost(0);
     }
@@ -2596,7 +2955,7 @@ function autterKoa(options = {}) {
 // src/logging-only.ts
 import {
   SpanStatusCode as SpanStatusCode3,
-  trace as trace3
+  trace as trace4
 } from "@opentelemetry/api";
 var L = sharedSlot("logging", () => ({ active: null }));
 function initAutterLogging(options) {
@@ -2631,7 +2990,7 @@ function initAutterLogging(options) {
     const split = splitFingerprint(attributes);
     const fingerprint = fingerprintEventAttributes(split.fingerprint, redact.text);
     const redacted = redact(split.attributes);
-    const span = trace3.getActiveSpan();
+    const span = trace4.getActiveSpan();
     if (mode === "auto" && span?.isRecording()) {
       noteOperationError(error);
       notifyException(error, { ...redacted, ...fingerprint });
@@ -2672,7 +3031,7 @@ function initAutterLogging(options) {
     const fingerprint = fingerprintEventAttributes(split.fingerprint, redact.text);
     const redacted = redact(split.attributes);
     notifyException(error, { ...redacted, ...fingerprint, "autter.severity": severity });
-    const span = trace3.getActiveSpan();
+    const span = trace4.getActiveSpan();
     if (mode === "auto" && span?.isRecording()) {
       span.addEvent("exception", {
         ...redacted,
@@ -2690,7 +3049,9 @@ function initAutterLogging(options) {
   const captured = /* @__PURE__ */ new WeakSet();
   configureRuntimeLogger({
     endpoint,
-    apiKey: options.apiKey ?? "",
+    // Normalised ("undefined"/empty is no key), no env fallback: without
+    // an apiKey this mode logs locally only, by design.
+    apiKey: resolveIngestKey(options.apiKey, {}) ?? "",
     service: options.service,
     environment,
     ...options.release ? { release: options.release } : {},
@@ -2850,6 +3211,7 @@ export {
   captureException,
   captureMessage,
   captureRequestError,
+  checkBrowserPayload,
   consoleSink,
   createBrowserRelayFetchHandler,
   createBrowserRelayHandler,
@@ -2877,6 +3239,7 @@ export {
   reportOutcome,
   runDoctor,
   runInBackground,
+  runVerify,
   runtimeContext,
   runtimeLogStats,
   runtimeLogger,