@autter/runtime-node 1.6.0 → 1.7.0

package/dist/index.js

@@ -45,10 +45,10 @@ import {
   splitFingerprint,
   toClientError,
   withRuntimeOperation
-} from "./chunk-FBKYOHU2.js";
+} from "./chunk-KA4AOZX2.js";
 import {
   runDoctor
-} from "./chunk-Y4T7SQMO.js";
+} from "./chunk-QUC6OUE7.js";
 import {
   COMPAT_MANIFEST,
   CountingExporter,
@@ -67,9 +67,10 @@ import {
   observeIngesterResponse,
   registerFlushTarget,
   setDebugMode,
+  sharedSlot,
   telemetryStats,
   unregisterFlushTargets
-} from "./chunk-OY2HTUWY.js";
+} from "./chunk-LG52CW3V.js";
 
 // src/relay.ts
 var IpWindow = class {
@@ -440,6 +441,9 @@ function createBrowserRelayHandler(opts) {
 }
 
 // src/server.ts
+import { errorMonitor } from "events";
+import { createRequire } from "module";
+import { join } from "path";
 import { ServerResponse } from "http";
 import { randomUUID } from "crypto";
 import {
@@ -449,7 +453,7 @@ import {
   SpanStatusCode,
   TraceFlags
 } from "@opentelemetry/api";
-import { getRPCMetadata as getRPCMetadata2, RPCType as RPCType2 } from "@opentelemetry/core";
+import { getRPCMetadata as getRPCMetadata3, RPCType as RPCType3 } from "@opentelemetry/core";
 import {
   AggregationTemporalityPreference,
   OTLPMetricExporter
@@ -478,6 +482,89 @@ import { Resource } from "@opentelemetry/resources";
 import {
   AggregationTemporality
 } from "@opentelemetry/sdk-metrics";
+
+// src/url-query.ts
+var URL_KEYS = ["http.target", "http.url", "url.full", "url.original", "url.path"];
+var QUERY_KEY = "url.query";
+var NAME_KEYS = ["next.span_name"];
+var MASK = "[redacted]";
+var SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+function splitUrl(value) {
+  const from = SCHEME.test(value) ? value.indexOf("://") + 3 : 0;
+  const question = value.indexOf("?", from);
+  const hash = value.indexOf("#", from);
+  const at = question < 0 ? hash : hash < 0 ? question : Math.min(question, hash);
+  if (at < 0) return null;
+  const query = at === question ? value.slice(at + 1, hash > at ? hash : void 0) : null;
+  return { base: value.slice(0, at), query };
+}
+function decodeName(raw) {
+  try {
+    return decodeURIComponent(raw.replace(/\+/g, " "));
+  } catch {
+    return raw;
+  }
+}
+function makeUrlQueryPolicy(keepQueryParams = []) {
+  const keep = new Set(keepQueryParams.filter((name) => typeof name === "string"));
+  const maskQuery = (query) => {
+    const out = [];
+    for (const part of query.split("&")) {
+      if (!part) continue;
+      const eq = part.indexOf("=");
+      const name = eq < 0 ? part : part.slice(0, eq);
+      if (keep.size && keep.has(decodeName(name))) out.push(part);
+      else if (eq < 0) out.push(MASK);
+      else out.push(eq === part.length - 1 ? part : `${name}=${MASK}`);
+    }
+    return out.join("&");
+  };
+  const stripName = (name) => {
+    if (!name.includes("?") && !name.includes("#")) return name;
+    return name.split(" ").map((token) => {
+      if (!token.startsWith("/") && !SCHEME.test(token)) return token;
+      return splitUrl(token)?.base ?? token;
+    }).join(" ");
+  };
+  return {
+    attributes(attributes) {
+      let out = null;
+      const set = (key, value) => {
+        out ??= { ...attributes };
+        out[key] = value;
+      };
+      let dropped = null;
+      for (const key of URL_KEYS) {
+        const value = attributes[key];
+        if (typeof value !== "string") continue;
+        const split = splitUrl(value);
+        if (!split) continue;
+        set(key, split.base);
+        if (split.query) dropped ??= split.query;
+      }
+      for (const key of NAME_KEYS) {
+        const value = attributes[key];
+        if (typeof value !== "string") continue;
+        const stripped = stripName(value);
+        if (stripped !== value) set(key, stripped);
+      }
+      const current = attributes[QUERY_KEY];
+      if (typeof current === "string") {
+        const masked = maskQuery(current.startsWith("?") ? current.slice(1) : current);
+        if (masked !== current) set(QUERY_KEY, masked);
+      } else if (current !== void 0) {
+        set(QUERY_KEY, MASK);
+      } else if (dropped !== null) {
+        const masked = maskQuery(dropped);
+        if (masked) set(QUERY_KEY, masked);
+      }
+      return out ?? attributes;
+    },
+    name: stripName
+  };
+}
+
+// src/redact-exporter.ts
 var scrubbedResources = /* @__PURE__ */ new WeakMap();
 function redactResource(resource, redactor) {
   const cached = scrubbedResources.get(resource);
@@ -486,17 +573,41 @@ function redactResource(resource, redactor) {
   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;
+var DEFAULT_QUERY_POLICY = makeUrlQueryPolicy();
+function stripQueries(span, query) {
+  const name = query.name(span.name);
+  const attributes = query.attributes(span.attributes);
+  if (name === span.name && attributes === span.attributes) return span;
+  return wrap(span, { name, attributes });
+}
+function wrap(span, fields) {
   return {
-    name: redactor.text(span.name),
+    name: fields.name,
     kind: span.kind,
     spanContext: () => span.spanContext(),
     parentSpanId: span.parentSpanId,
     startTime: span.startTime,
     endTime: span.endTime,
+    status: fields.status ?? span.status,
+    attributes: fields.attributes,
+    links: fields.links ?? span.links,
+    events: fields.events ?? span.events,
+    duration: span.duration,
+    ended: span.ended,
+    resource: fields.resource ?? span.resource,
+    instrumentationLibrary: span.instrumentationLibrary,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
+}
+function redactSpan(span, redactor, query = DEFAULT_QUERY_POLICY) {
+  if (!redactor.enabled) return stripQueries(span, query);
+  const status = span.status.message ? { ...span.status, message: redactor.text(span.status.message) } : span.status;
+  return wrap(span, {
+    name: query.name(redactor.text(span.name)),
     status,
-    attributes: redactor.exported(span.attributes),
+    attributes: query.attributes(redactor.exported(span.attributes)),
     links: span.links.map(
       (link) => link.attributes ? { ...link, attributes: redactor.exported(link.attributes) } : link
     ),
@@ -505,34 +616,27 @@ function redactSpan(span, redactor) {
       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
-  };
+    resource: redactResource(span.resource, redactor)
+  });
 }
 var RedactingSpanExporter = class {
-  constructor(inner, redactor) {
+  constructor(inner, redactor, query = DEFAULT_QUERY_POLICY) {
     this.inner = inner;
     this.redactor = redactor;
+    this.query = query;
   }
   inner;
   redactor;
+  query;
   export(spans, resultCallback) {
     const redactor = this.redactor();
-    let scrubbed = spans;
+    const scrubbed = [];
     let failed = 0;
-    if (redactor.enabled) {
-      scrubbed = [];
-      for (const span of spans) {
-        try {
-          scrubbed.push(redactSpan(span, redactor));
-        } catch {
-          failed++;
-        }
+    for (const span of spans) {
+      try {
+        scrubbed.push(redactSpan(span, redactor, this.query));
+      } catch {
+        failed++;
       }
     }
     if (!failed) {
@@ -641,7 +745,7 @@ 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 CAPTURED = sharedSlot("requests", () => ({ captured: /* @__PURE__ */ new WeakSet() })).captured;
 var capturer = () => {
 };
 function setRequestExceptionCapturer(fn) {
@@ -667,14 +771,14 @@ 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 active = context.active();
+  const metadata = getRPCMetadata(active);
   const span = metadata?.type === RPCType.HTTP ? metadata.span : void 0;
-  if (!span || !span.isRecording() || trace.getSpan(active2) === span) {
+  if (!span || !span.isRecording() || trace.getSpan(active) === span) {
     fn();
     return;
   }
-  context.with(trace.setSpan(active2, span), fn);
+  context.with(trace.setSpan(active, span), fn);
 }
 function captureAtBoundary(error, state, rule = void 0, attributes) {
   let wanted;
@@ -713,7 +817,7 @@ function bindEmitter(emitter, state) {
   if (!target || typeof target !== "object" || target[BOUND]) return;
   target[BOUND] = true;
   const wrappers = /* @__PURE__ */ new WeakMap();
-  const wrap = (listener) => {
+  const wrap2 = (listener) => {
     if (typeof listener !== "function") return listener;
     let wrapped = wrappers.get(listener);
     if (!wrapped) {
@@ -737,7 +841,7 @@ function bindEmitter(emitter, state) {
     const original = target[method];
     if (typeof original !== "function") continue;
     target[method] = function(event, listener) {
-      return original.call(this, event, wrap(listener));
+      return original.call(this, event, wrap2(listener));
     };
   }
   for (const method of ["removeListener", "off"]) {
@@ -1175,7 +1279,48 @@ function installUnhandledRejectionCapture(capture, mode = unhandledRejectionsMod
   };
 }
 
+// src/route-label.ts
+import { getRPCMetadata as getRPCMetadata2, RPCType as RPCType2 } from "@opentelemetry/core";
+var ours = /* @__PURE__ */ new WeakMap();
+var RAW_PATH_SPAN_TYPES = /* @__PURE__ */ new Set(["BaseServer.renderToResponse"]);
+function noteFrameworkRoute(parent, attributes) {
+  const route = attributes?.["next.route"];
+  if (typeof route !== "string" || !route.startsWith("/")) return;
+  if (RAW_PATH_SPAN_TYPES.has(String(attributes?.["next.span_type"] ?? ""))) return;
+  const rpc = getRPCMetadata2(parent);
+  if (!rpc || rpc.type !== RPCType2.HTTP) return;
+  const mine = ours.get(rpc);
+  if (rpc.route !== void 0 && rpc.route !== mine) return;
+  if (mine !== void 0 && mine.includes("[") && !route.includes("[")) return;
+  if (mine !== void 0 && (route === `${mine}/route` || route === `${mine}/page`)) return;
+  rpc.route = route;
+  ours.set(rpc, route);
+}
+var RouteLabelSampler = class {
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  delegate;
+  shouldSample(ctx, traceId, spanName, spanKind, attributes, links) {
+    try {
+      noteFrameworkRoute(ctx, attributes);
+    } catch {
+    }
+    return this.delegate.shouldSample(ctx, traceId, spanName, spanKind, attributes, links);
+  }
+  toString() {
+    return `RouteLabel(${this.delegate.toString()})`;
+  }
+};
+
 // src/server.ts
+var S = sharedSlot("server", () => ({
+  active: null,
+  alwaysOnProvider: null,
+  redactor: makeRedactor(true),
+  loggerOnlyCapture: null,
+  hookRequests: false
+}));
 var LLM_MARKER_ATTRIBUTES = [
   "gen_ai.operation.name",
   "gen_ai.system",
@@ -1303,9 +1448,9 @@ var ErrorTraceRetentionProcessor = class {
   }
   /** Promote the active trace, if any — called on captured errors. */
   retainActiveTrace() {
-    const active2 = trace2.getActiveSpan()?.spanContext();
-    if (!active2 || (active2.traceFlags & TraceFlags.SAMPLED) !== 0) return;
-    const entry = this.entryFor(active2.traceId);
+    const active = trace2.getActiveSpan()?.spanContext();
+    if (!active || (active.traceFlags & TraceFlags.SAMPLED) !== 0) return;
+    const entry = this.entryFor(active.traceId);
     if (entry.retained) return;
     entry.retained = true;
     this.flush(entry);
@@ -1372,7 +1517,7 @@ function llmBaseAttributes(info) {
     ...info.sessionId ? { "autter.session_id": info.sessionId } : {},
     // Caller-supplied extras go through redaction like every other
     // custom attribute family (prompts can contain emails/keys).
-    ...info.attributes ? activeRedactor(info.attributes) : {}
+    ...info.attributes ? S.redactor(info.attributes) : {}
   };
 }
 function usageAttributes(usage) {
@@ -1413,7 +1558,7 @@ async function runLlmSpan(tracer, info, fn) {
     },
     setResponseModel,
     setModel: setResponseModel,
-    setAttributes: (attributes) => span.setAttributes(activeRedactor(attributes))
+    setAttributes: (attributes) => span.setAttributes(S.redactor(attributes))
   };
   try {
     const result = await context2.with(
@@ -1475,67 +1620,82 @@ async function runWithSpan(tracer, name, fn, attributes, links) {
 }
 function recordError(span, err) {
   const isErr = isError(err);
-  const message = activeRedactor.text(isErr ? err.message : String(err));
+  const message = S.redactor.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)
+      ...err.stack ? { "exception.stacktrace": S.redactor.text(err.stack) } : {},
+      ...breadcrumbEventAttributes(S.redactor.text, err)
     });
   }
   span.setStatus({ code: SpanStatusCode.ERROR, message });
 }
 function redactWithActive(attributes) {
-  return activeRedactor(attributes);
+  return S.redactor(attributes);
 }
-function captureExpressRoute(_span, response) {
+function patchLoadedHttpModules() {
+  try {
+    const load = createRequire(join(process.cwd(), "autter-runtime-http.cjs"));
+    load("http");
+    load("https");
+  } catch {
+  }
+}
+var METRIC_ROUTE_ATTR = "autter.metric_has_route";
+function captureRequestRoute(span, response) {
   if (!(response instanceof ServerResponse)) return;
-  const rpcMetadata = getRPCMetadata2(context2.active());
-  if (rpcMetadata?.type !== RPCType2.HTTP) return;
+  const rpcMetadata = getRPCMetadata3(context2.active());
+  if (rpcMetadata?.type !== RPCType3.HTTP) return;
+  let failed = false;
+  response.on(errorMonitor, () => {
+    failed = true;
+  });
   const setRoute = () => {
     if (rpcMetadata.route) return;
     const route = expressRouteOf(response.req);
     if (route) rpcMetadata.route = route;
   };
   response.prependListener("finish", setRoute);
-  response.prependListener("close", setRoute);
-  if (hookRequests) startHookRequest(response);
+  response.prependListener("close", () => {
+    setRoute();
+    if (rpcMetadata.route && !failed) span.setAttribute(METRIC_ROUTE_ATTR, true);
+  });
+  if (S.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)
+        S.redactor(internal)
       ).slice(0, 4e3);
     } catch {
     }
   }
   return attrs;
 }
-var active = null;
-var activeAlwaysOnProvider = null;
-var activeRedactor = makeRedactor(true);
 function initAutterServer(options) {
-  if (active) return active;
+  if (S.active) return S.active;
   const endpoint = (options.endpoint ?? "https://otlp.autter.dev").replace(
     /\/$/,
     ""
   );
   const headers = { authorization: `Bearer ${options.apiKey}` };
+  const redactor = makeRedactor(options.redactAttributes ?? true);
+  const queryPolicy = makeUrlQueryPolicy(options.keepQueryParams);
   const traceExporter = () => new CountingExporter(
     new RedactingSpanExporter(
       new OTLPTraceExporter({ url: `${endpoint}/v1/traces`, headers }),
-      () => activeRedactor
+      () => redactor,
+      queryPolicy
     )
   );
   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);
+  S.redactor = redactor;
   const distro = options.distro ?? SDK_IDENTITY;
   configureCompatCheck({ endpoint, enabled: options.compatCheck !== false, sdk: distro });
   const resource = new Resource2({
@@ -1549,8 +1709,14 @@ function initAutterServer(options) {
     "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
+    // would double-count every sampled request)...
+    "autter.metrics_wired": true,
+    // ...for the requests whose metric carries their route: those
+    // request spans say so (`autter.metric_has_route`, see
+    // captureRequestRoute). Ingesters honour metrics_wired only with
+    // this, so an older SDK, whose Next.js metrics have no route, keeps
+    // its span-fed per-route counts.
+    "autter.metrics_routes": true
   });
   const rootSampler = new TraceIdRatioBasedSampler(options.traceSampleRate ?? 0.01);
   const headSampler = new ParentBasedSampler({
@@ -1567,6 +1733,7 @@ function initAutterServer(options) {
   const retainTraces = retainOnError || slowThresholdMs > 0;
   let sampler = retainTraces ? new RecordUnsampledSampler(headSampler) : headSampler;
   if (options.llmTracing !== false) sampler = new LlmAwareSampler(sampler);
+  sampler = new RouteLabelSampler(sampler);
   const errorTraceBuffer = retainTraces ? new ErrorTraceRetentionProcessor(
     new BatchSpanProcessor(traceExporter(), { scheduledDelayMillis: 2e3 }),
     retainOnError,
@@ -1584,7 +1751,7 @@ function initAutterServer(options) {
         // 60 s export.
         temporalityPreference: AggregationTemporalityPreference.DELTA
       }),
-      () => activeRedactor
+      () => redactor
     ),
     exportIntervalMillis: options.metricIntervalMs ?? 6e4
   });
@@ -1605,11 +1772,12 @@ function initAutterServer(options) {
       ) })
     ],
     instrumentations: [
-      new HttpInstrumentation({ responseHook: captureExpressRoute }),
+      new HttpInstrumentation({ responseHook: captureRequestRoute }),
       ...options.instrumentations ?? []
     ]
   });
   sdk.start();
+  patchLoadedHttpModules();
   const stopMemoryMetrics = options.memoryMetrics === false ? null : startMemoryMetrics();
   noteCompatFeature("endpoint_latency");
   if (stopMemoryMetrics) noteCompatFeature("memory_metrics");
@@ -1628,12 +1796,12 @@ function initAutterServer(options) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
     const isErr = isError(error);
-    const message = activeRedactor.text(isErr ? error.message : String(error));
-    const stackText = isErr && error.stack ? activeRedactor.text(error.stack) : "";
+    const message = redactor.text(isErr ? error.message : String(error));
+    const stackText = isErr && error.stack ? redactor.text(error.stack) : "";
     const split = splitFingerprint(attributes);
-    const fingerprint = fingerprintEventAttributes(split.fingerprint, activeRedactor.text);
+    const fingerprint = fingerprintEventAttributes(split.fingerprint, redactor.text);
     if (fingerprint["autter.fingerprint"]) noteCompatFeature("fingerprint_override");
-    const redacted = activeRedactor(split.attributes);
+    const redacted = redactor(split.attributes);
     const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isErr ? error.name : "Error");
@@ -1660,17 +1828,17 @@ function initAutterServer(options) {
         "exception.stacktrace": stackText,
         ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
         ...declared,
-        ...breadcrumbEventAttributes(activeRedactor.text, error)
+        ...breadcrumbEventAttributes(redactor.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": isErr ? error.name : "Error",
         "exception.message": message,
-        ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+        ...stack ? { "exception.stacktrace": redactor.text(stack) } : {},
         ...redacted["autter.handled"] === true ? { "autter.handled": true, "autter.sampled": redacted["autter.sampled"] === true } : {},
         ...declared,
-        ...breadcrumbEventAttributes(activeRedactor.text, error)
+        ...breadcrumbEventAttributes(redactor.text, error)
       });
     }
     span.setStatus({ code: SpanStatusCode.ERROR, message });
@@ -1682,16 +1850,16 @@ function initAutterServer(options) {
     }
     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 safeMessage = redactor.text(message);
     const span = errorTracer.startSpan("Message", {
-      attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
+      attributes: { "autter.severity": severity, ...redactor(attributes) }
     });
     span.addEvent("exception", {
       "exception.type": "Message",
       "exception.message": safeMessage,
-      ...stack ? { "exception.stacktrace": activeRedactor.text(stack) } : {},
+      ...stack ? { "exception.stacktrace": redactor.text(stack) } : {},
       "autter.severity": severity,
-      ...breadcrumbEventAttributes(activeRedactor.text)
+      ...breadcrumbEventAttributes(redactor.text)
     });
     span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     span.end();
@@ -1702,11 +1870,11 @@ function initAutterServer(options) {
     const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan("OutcomeFailure");
-    const safeOutcome = activeRedactor({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
+    const safeOutcome = redactor({ "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");
     span.addEvent("autter.outcome", {
-      ...activeRedactor(attributes),
+      ...redactor(attributes),
       "autter.outcome.status": "error",
       "autter.outcome.name": safeName,
       "autter.outcome.message": safeMessage
@@ -1722,11 +1890,11 @@ function initAutterServer(options) {
     distro,
     release: options.release,
     options: options.logging,
-    redact: activeRedactor,
-    run: (name, fn, attributes, links) => runWithSpan(processTracer, name, fn, activeRedactor(attributes), links),
+    redact: redactor,
+    run: (name, fn, attributes, links) => runWithSpan(processTracer, name, fn, redactor(attributes), links),
     reportOutcome: reportOutcome2
   });
-  hookRequests = options.logging?.requests === true;
+  S.hookRequests = options.logging?.requests === true;
   let onCrash = null;
   let uninstallRejections = null;
   if (options.captureGlobalErrors !== false) {
@@ -1769,17 +1937,20 @@ function initAutterServer(options) {
     captureException: captureException2,
     captureMessage: captureMessage2,
     reportOutcome: reportOutcome2,
-    withProcessSpan: (name, fn, attributes) => runWithSpan(processTracer, name, fn, activeRedactor(attributes)),
+    withProcessSpan: (name, fn, attributes) => runWithSpan(processTracer, name, fn, redactor(attributes)),
     withLlmCall: (info, fn) => runLlmSpan(llmTracer, info, fn),
     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;
+      if (S.active === server) {
+        S.active = null;
+        S.alwaysOnProvider = null;
+        S.hookRequests = false;
+        S.redactor = makeRedactor(true);
+      }
       autoFlushHandle?.dispose();
       autoFlushHandle = null;
       unregisterFlushTargets();
@@ -1788,82 +1959,81 @@ function initAutterServer(options) {
       if (logShutdown[0]?.status === "rejected") throw logShutdown[0].reason;
     }
   };
-  active = server;
-  activeAlwaysOnProvider = alwaysOnProvider;
+  S.active = server;
+  S.alwaysOnProvider = alwaysOnProvider;
   return server;
 }
 function captureException(error, attributes) {
-  if (active) {
-    active.captureException(error, attributes);
+  if (S.active) {
+    S.active.captureException(error, attributes);
     return;
   }
-  if (loggerOnlyCapture) {
-    loggerOnlyCapture(error, attributes);
+  if (S.loggerOnlyCapture) {
+    S.loggerOnlyCapture(error, attributes);
     return;
   }
   markCaptured(error);
   noteOperationError(error);
   const split = splitFingerprint(attributes);
-  const fingerprint = fingerprintEventAttributes(split.fingerprint, activeRedactor.text);
+  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", {
-    attributes: { ...activeRedactor(split.attributes), ...fingerprint }
+    attributes: { ...S.redactor(split.attributes), ...fingerprint }
   });
   recordError(span, error);
   span.end();
 }
-var loggerOnlyCapture = null;
 function setLoggerOnlyCapture(fn) {
-  loggerOnlyCapture = fn;
+  S.loggerOnlyCapture = fn;
 }
 function serverActive() {
-  return active !== null;
+  return S.active !== null;
 }
 setRequestExceptionCapturer((error, attributes) => captureException(error, attributes));
 setRequestSpanAnnotator((attributes) => {
   const span = trace2.getActiveSpan();
-  if (span?.isRecording()) span.setAttributes(activeRedactor(splitFingerprint(attributes).attributes));
+  if (span?.isRecording()) span.setAttributes(S.redactor(splitFingerprint(attributes).attributes));
 });
 function withProcessSpan(name, fn, attributes) {
-  if (active) return active.withProcessSpan(name, fn, attributes);
+  if (S.active) return S.active.withProcessSpan(name, fn, attributes);
   return runWithSpan(
     trace2.getTracer("autter-processes"),
     name,
     fn,
-    activeRedactor(attributes)
+    S.redactor(attributes)
   );
 }
 function withLlmCall(info, fn) {
-  if (active) return active.withLlmCall(info, fn);
+  if (S.active) return S.active.withLlmCall(info, fn);
   return runLlmSpan(trace2.getTracer("autter-llm"), info, fn);
 }
 function trackLlmCall(call) {
-  if (active) {
-    active.trackLlmCall(call);
+  if (S.active) {
+    S.active.trackLlmCall(call);
     return;
   }
   recordLlmCall(trace2.getTracer("autter-llm"), call);
 }
 function captureMessage(message, severity = "warning", attributes) {
-  if (active) {
-    active.captureMessage(message, severity, attributes);
+  if (S.active) {
+    S.active.captureMessage(message, severity, attributes);
     return;
   }
-  const safeMessage = activeRedactor.text(message);
+  const safeMessage = S.redactor.text(message);
   const span = trace2.getTracer("autter-errors").startSpan("Message", {
-    attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
+    attributes: { "autter.severity": severity, ...S.redactor(attributes) }
   });
   span.addEvent("exception", {
     "exception.type": "Message",
     "exception.message": safeMessage,
     "autter.severity": severity,
-    ...breadcrumbEventAttributes(activeRedactor.text)
+    ...breadcrumbEventAttributes(S.redactor.text)
   });
   span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
   span.end();
 }
 function reportOutcome(name, message, attributes) {
-  if (active) return active.reportOutcome(name, message, attributes);
+  if (S.active) return S.active.reportOutcome(name, message, attributes);
   const span = trace2.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");
@@ -1885,13 +2055,13 @@ function makeSafeCapture(options) {
   };
 }
 function alwaysOnTracer(name) {
-  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : trace2.getTracer(name);
+  return S.alwaysOnProvider ? S.alwaysOnProvider.getTracer(name) : trace2.getTracer(name);
 }
 function autterLlmTracer() {
   return alwaysOnTracer("autter-llm");
 }
 async function emitLlmSelftestTrace() {
-  const provider = activeAlwaysOnProvider;
+  const provider = S.alwaysOnProvider;
   if (!provider) {
     throw new Error(
       "emitLlmSelftestTrace() requires initAutterServer() to have been called"
@@ -2149,14 +2319,14 @@ function startCaughtExceptionSampler(options = {}) {
   const rate = Math.max(0, Math.min(1, options.sampleRate ?? 0.01));
   const cap = Math.max(1, Math.min(100, options.maxPerMinute ?? 10));
   const session = new inspector.Session();
-  let active2 = true;
+  let active = true;
   let minute = 0;
   let sent = 0;
   session.connect();
   session.on("Debugger.paused", (message) => {
     session.post("Debugger.resume", () => {
     });
-    if (!active2 || message.params.reason !== "exception") return;
+    if (!active || message.params.reason !== "exception") return;
     const nowMinute = Math.floor(Date.now() / 6e4);
     if (nowMinute !== minute) {
       minute = nowMinute;
@@ -2171,16 +2341,16 @@ function startCaughtExceptionSampler(options = {}) {
     error.stack = `${error.name}: ${error.message}
 ${frames.join("\n")}`;
     queueMicrotask(() => {
-      if (active2) captureException(error, { "autter.handled": true, "autter.sampled": true });
+      if (active) captureException(error, { "autter.handled": true, "autter.sampled": true });
     });
   });
   session.post("Debugger.enable", (error) => {
-    if (!error && active2) session.post("Debugger.setPauseOnExceptions", { state: "all" }, () => {
+    if (!error && active) session.post("Debugger.setPauseOnExceptions", { state: "all" }, () => {
     });
   });
   return { stop() {
-    if (!active2) return;
-    active2 = false;
+    if (!active) return;
+    active = false;
     session.post("Debugger.setPauseOnExceptions", { state: "none" }, () => {
       session.post("Debugger.disable", () => session.disconnect());
     });
@@ -2228,9 +2398,9 @@ import {
   SpanStatusCode as SpanStatusCode3,
   trace as trace3
 } from "@opentelemetry/api";
-var activeLogging = null;
+var L = sharedSlot("logging", () => ({ active: null }));
 function initAutterLogging(options) {
-  if (activeLogging) return activeLogging;
+  if (L.active) return L.active;
   if (serverActive()) {
     console.warn(
       "[autter-runtime] initAutterLogging() ignored: initAutterServer() is already active and includes logging"
@@ -2332,11 +2502,11 @@ function initAutterLogging(options) {
       autoFlushHandle?.dispose();
       autoFlushHandle = null;
       unregisterFlushTargets();
-      activeLogging = null;
+      if (L.active === handle) L.active = null;
       await shutdownRuntimeLogger();
     }
   };
-  activeLogging = handle;
+  L.active = handle;
   return handle;
 }