@autter/runtime-node 1.6.0 → 1.7.0

package/README.md

@@ -184,6 +184,7 @@ Defaults (cheap by construction):
 | Request metrics | exported every 60 s |
 | Logs | not collected |
 | PII in custom attributes | redacted before export (`redactAttributes`) |
+| Query strings in span URLs | parameter names only (`keepQueryParams`) |
 | Forgotten `shutdown()` | exporters still flushed on exit (`autoFlush`) |
 
 **Error-linked trace retention.** Errors export at 100% while traces are
@@ -316,11 +317,21 @@ silent loss. While wiring things up, set `debug: true` (or `AUTTER_DEBUG=1`)
 to see `[autter] exported N span(s)` lines on stderr as batches leave.
 
 Note on usage rollups: requests are counted from the `http.server.duration`
-metric (100% accurate) and additionally from sampled server spans. At the
-default 1% sampling the span contribution is negligible; if you set
-`traceSampleRate: 1` in development, expect request counts roughly doubled.
-Tail-retained error traces don't distort this: their spans carry
-`autter.tail_retained` and the ingester keeps them out of span-fed rollups.
+metric (100% accurate), under their route template: Express routes and,
+from 1.7.0, Next.js routes (`/blog/[slug]`, from the `next.route` Next puts
+on its own spans). The SDK marks its resource `autter.metrics_wired` and
+`autter.metrics_routes`, and each request span whose metric got a route
+`autter.metric_has_route`; an up-to-date ingester then counts that request
+from the metric alone, whatever `traceSampleRate` is. A request whose
+metric has no route (Koa, Fastify or plain `http` without a router
+instrumentation) is also counted from its sampled spans, which keep its
+path. Ingesters up to 1.7.0 count every sampled server span on top of the
+metric (at `traceSampleRate: 1`, about twice the requests), except
+tail-retained error traces (`autter.tail_retained`). Since 1.7.0 the SDK
+also applies the HTTP instrumentation to servers created before
+`initAutterServer` (Next.js creates its server before `instrumentation.ts`
+runs): until then a Next.js app got request spans and metrics only from
+the first request that happened to load `http` again, if ever.
 
 ### Privacy: secrets and PII are scrubbed before they leave the process
 
@@ -383,6 +394,48 @@ This closes the server-side gap to match the browser relay's payload
 whitelist; it is best-effort scrubbing of obvious PII shapes, not a DLP
 engine — keep secrets out of attributes in the first place.
 
+**Query strings (1.6.1+).** Query strings carry what a path never should:
+emails, one-time codes, API keys, session ids, search terms. So no span
+leaves the process with query values, whichever instrumentation made it
+(HTTP server and client spans, undici/fetch, Express, Fastify, Next.js's own
+spans):
+
+- `http.target`, `http.url`, `url.full` and `url.original` are cut at the `?`
+  (and `#`): `/search?email=jane@example.com&page=2` becomes `/search`;
+- `url.query` keeps only the parameter names, `email=[redacted]&page=[redacted]`.
+  It is added from the URL when the instrumentation did not set it, so you
+  still see which parameters a request used. A parameter without `=`
+  (`/verify?<token>`) may itself be the secret and is masked whole;
+- span names lose their query too (Next.js names a request span
+  `GET /search?q=…` until it knows the route).
+
+List the parameters whose values are safe to keep, such as pagination or
+sorting (exact names, after percent-decoding; kept values are still scrubbed
+by `redactAttributes`):
+
+```ts
+initAutterServer({ ..., keepQueryParams: ["page", "sort"] });
+// url.query: "email=[redacted]&page=2"
+```
+
+This runs at export, like the scrubbing above, and also with
+`redactAttributes: false`. Route templates (`http.route`) and request
+summaries never contained a query.
+
+### One SDK per process, however many copies are loaded
+
+Bundlers can load this package more than once: Next.js bundles one copy
+into `instrumentation.ts` and another into each route (unless it is in
+`serverExternalPackages`), and a process can load both the ESM and the CJS
+build. Since 1.6.1 every copy shares one process-wide state
+(`globalThis[Symbol.for("@autter/runtime-node")]`): the copy that ran
+`initAutterServer` (or `initAutterLogging`) is the SDK for all of them, so
+`withRuntimeRequest`, `captureException`, `runtimeLogger` and the rest export
+through it from any copy, and an error one copy reported is never reported
+again by another. Before any copy starts, and after `shutdown()`, every copy
+behaves as before: records go to the console. The shared object is
+versioned; a copy that finds a layout it does not know keeps its own state.
+
 ## 3. LLM tracing
 
 For the field contract, manual reporting patterns, and provider-agnostic

package/dist/{chunk-ARN26OK6.cjs → chunk-GYTQLITW.cjs}

@@ -119,6 +119,43 @@ var compat_manifest_default = {
       ingester: "1.6.0",
       migrations: [],
       sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-next": "1.6.0", "@autter/runtime-node": "1.6.0" }
+    },
+    {
+      id: "sourcemap_upload_keys",
+      title: "Upload-only keys for source maps (autter_rtu_)",
+      ingester: "1.7.0",
+      migrations: [],
+      route: "/v1/sourcemaps",
+      sdks: {}
+    },
+    {
+      id: "source_map_verify",
+      title: "Source map check by debug id (autter-runtime sourcemaps verify)",
+      ingester: "1.7.0",
+      migrations: ["0017-source-maps-debug-id"],
+      route: "/v1/sourcemaps/check",
+      sdks: {}
+    },
+    {
+      id: "ingest_drop_counts",
+      title: "Rejected and dropped records per repository",
+      ingester: "1.8.0",
+      migrations: ["0018-runtime-ingest-drops"],
+      sdks: {}
+    },
+    {
+      id: "telemetry_sender_via",
+      title: "How each service's telemetry arrives (SDK, OpenTelemetry Collector or browser relay)",
+      ingester: "1.8.0",
+      migrations: ["0019-sdk-versions-via"],
+      sdks: {}
+    },
+    {
+      id: "frame_resolution_counts",
+      title: "Resolved and unresolved browser frames per occurrence",
+      ingester: "1.8.0",
+      migrations: ["0020-occurrence-frame-resolution"],
+      sdks: {}
     }
   ]
 };
@@ -464,7 +501,7 @@ var _https = require('https');
 // package.json
 var package_default = {
   name: "@autter/runtime-node",
-  version: "1.6.0",
+  version: "1.7.0",
   description: "Autter Runtime for Node.js: request wide events, coded errors, operation logging, same-origin browser relay and a curated OpenTelemetry server tracker",
   license: "MIT",
   type: "module",
@@ -539,6 +576,55 @@ var package_default = {
   ]
 };
 
+// src/shared.ts
+var SHARED_STATE_KEY = /* @__PURE__ */ Symbol.for("@autter/runtime-node");
+var SHARED_STATE_LAYOUT = 1;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+var VERSION = package_default.version;
+function resolveShared() {
+  const fresh = { v: SHARED_STATE_LAYOUT, sdk: VERSION };
+  const host = globalThis;
+  let existing;
+  try {
+    existing = host[SHARED_STATE_KEY];
+    if (existing === void 0) {
+      Object.defineProperty(host, SHARED_STATE_KEY, {
+        value: fresh,
+        configurable: true,
+        enumerable: false,
+        writable: false
+      });
+      return fresh;
+    }
+  } catch (e) {
+    return fresh;
+  }
+  if (isObject(existing) && existing.v === SHARED_STATE_LAYOUT) return existing;
+  debugLog(
+    `another copy of @autter/runtime-node uses shared state layout ${String(isObject(existing) ? existing.v : typeof existing)}; this copy (${VERSION}, layout ${SHARED_STATE_LAYOUT}) keeps its own state`
+  );
+  return fresh;
+}
+var shared = resolveShared();
+function sharedSlot(name, init) {
+  const fresh = init();
+  try {
+    const existing = shared[name];
+    if (!isObject(existing)) {
+      shared[name] = fresh;
+      return fresh;
+    }
+    for (const [key, value] of Object.entries(fresh)) {
+      if (existing[key] === void 0) existing[key] = value;
+    }
+    return existing;
+  } catch (e2) {
+    return fresh;
+  }
+}
+
 // src/compat.ts
 var SDK_IDENTITY = {
   name: "@autter/runtime-node",
@@ -587,7 +673,7 @@ function compatRequest(method, url, options = {}) {
       if (options.unref !== false) req.on("socket", (socket) => socket.unref());
       req.on("error", () => done(null));
       req.end(options.body);
-    } catch (e) {
+    } catch (e3) {
       done(null);
     }
   });
@@ -600,7 +686,7 @@ async function fetchIngesterCompat(endpoint, options = {}) {
     let report = null;
     try {
       report = JSON.parse(res.body);
-    } catch (e2) {
+    } catch (e4) {
     }
     const info = _nullishCoalesce(ingesterInfoFromReport(report), () => ( headerInfo(res.headers)));
     return info ? { info, report } : { info: null, report, error: "unrecognised /v1/compat response" };
@@ -631,7 +717,7 @@ function envDisabled() {
   return value === "0" || value === "false" || value === "off";
 }
 var defaultWarn = (message) => console.warn(`[autter-runtime] ${message}`);
-var state = freshState(null, false);
+var compat = sharedSlot("compat", () => ({ state: freshState(null, false) }));
 function freshState(endpoint, enabled, sdk = SDK_IDENTITY, warn = defaultWarn) {
   return {
     endpoint,
@@ -646,7 +732,7 @@ function freshState(endpoint, enabled, sdk = SDK_IDENTITY, warn = defaultWarn) {
   };
 }
 function configureCompatCheck(options) {
-  state = freshState(
+  compat.state = freshState(
     options.endpoint.replace(/\/$/, ""),
     options.enabled !== false && !envDisabled(),
     _nullishCoalesce(options.sdk, () => ( SDK_IDENTITY)),
@@ -654,23 +740,23 @@ function configureCompatCheck(options) {
   );
 }
 function ensureCompatConfigured(endpoint) {
-  if (state.endpoint === null && !envDisabled()) {
-    state = freshState(endpoint.replace(/\/$/, ""), true);
+  if (compat.state.endpoint === null && !envDisabled()) {
+    compat.state = freshState(endpoint.replace(/\/$/, ""), true);
   }
 }
 function noteCompatFeature(id) {
   try {
-    if (!state.enabled || state.features.has(id) || !featureById(id)) return;
-    state.features.add(id);
-    if (state.info) {
+    if (!compat.state.enabled || compat.state.features.has(id) || !featureById(id)) return;
+    compat.state.features.add(id);
+    if (compat.state.info) {
       evaluateAndWarn();
       return;
     }
-    if (state.started) return;
-    state.started = true;
-    const current = state;
+    if (compat.state.started) return;
+    compat.state.started = true;
+    const current = compat.state;
     setTimeout(() => void runCheck(current), 0).unref();
-  } catch (e3) {
+  } catch (e5) {
   }
 }
 async function runCheck(current) {
@@ -679,7 +765,7 @@ async function runCheck(current) {
     const { info, error } = await fetchIngesterCompat(current.endpoint, {
       probeRoutes: routesFor(current.features)
     });
-    if (state !== current) return;
+    if (compat.state !== current) return;
     if (!info) {
       debugLog(`compat check skipped: ${_nullishCoalesce(error, () => ( "ingester version unknown"))}`);
       return;
@@ -703,8 +789,8 @@ function routesFor(features) {
   return routes;
 }
 function mergeInfo(next) {
-  const prev = state.info;
-  state.info = {
+  const prev = compat.state.info;
+  compat.state.info = {
     version: _nullishCoalesce(_nullishCoalesce(next.version, () => ( _optionalChain([prev, 'optionalAccess', _21 => _21.version]))), () => ( null)),
     ...next.legacy || _optionalChain([prev, 'optionalAccess', _22 => _22.legacy]) ? { legacy: true } : {},
     ..._nullishCoalesce(next.schema, () => ( _optionalChain([prev, 'optionalAccess', _23 => _23.schema]))) ? { schema: _nullishCoalesce(next.schema, () => ( _optionalChain([prev, 'optionalAccess', _24 => _24.schema]))) } : {},
@@ -712,17 +798,17 @@ function mergeInfo(next) {
   };
 }
 function evaluateAndWarn() {
-  const info = state.info;
+  const info = compat.state.info;
   if (!info) return;
-  if (info.version === null && state.endpoint) {
-    const unprobed = routesFor(state.features).filter(
-      (route) => _optionalChain([info, 'access', _26 => _26.routes, 'optionalAccess', _27 => _27[route]]) === void 0 && !state.pendingProbes.has(route)
+  if (info.version === null && compat.state.endpoint) {
+    const unprobed = routesFor(compat.state.features).filter(
+      (route) => _optionalChain([info, 'access', _26 => _26.routes, 'optionalAccess', _27 => _27[route]]) === void 0 && !compat.state.pendingProbes.has(route)
     );
     if (unprobed.length) {
-      const current = state;
+      const current = compat.state;
       for (const route of unprobed) current.pendingProbes.add(route);
       void Promise.all(unprobed.map((route) => probeRoute(current.endpoint, route, {}).then((exists) => [route, exists]))).then((results) => {
-        if (state !== current) return;
+        if (compat.state !== current) return;
         const routes = {};
         for (const [route, exists] of results) if (exists !== null) routes[route] = exists;
         mergeInfo({ version: null, legacy: true, routes });
@@ -731,56 +817,56 @@ function evaluateAndWarn() {
       });
     }
   }
-  for (const issue of evaluateCompat({ features: state.features, ingester: info })) {
+  for (const issue of evaluateCompat({ features: compat.state.features, ingester: info })) {
     warnOnce(issue);
   }
 }
 function warnOnce(issue) {
   const key = `${issue.feature}:${issue.kind}`;
-  if (state.warned.has(key)) return;
-  state.warned.add(key);
+  if (compat.state.warned.has(key)) return;
+  compat.state.warned.add(key);
   try {
-    state.warn(issue.message);
-  } catch (e4) {
+    compat.state.warn(issue.message);
+  } catch (e6) {
   }
 }
 function observeIngesterResponse(response) {
   try {
-    if (!state.enabled) return;
+    if (!compat.state.enabled) return;
     const fromHeader = headerInfo(response.headers);
     if (fromHeader) {
-      if (_optionalChain([state, 'access', _28 => _28.info, 'optionalAccess', _29 => _29.version]) !== fromHeader.version) {
+      if (_optionalChain([compat, 'access', _28 => _28.state, 'access', _29 => _29.info, 'optionalAccess', _30 => _30.version]) !== fromHeader.version) {
         mergeInfo(fromHeader);
         evaluateAndWarn();
       }
       return;
     }
-    if (response.status === 404 && response.route && !_optionalChain([state, 'access', _30 => _30.info, 'optionalAccess', _31 => _31.version])) {
+    if (response.status === 404 && response.route && !_optionalChain([compat, 'access', _31 => _31.state, 'access', _32 => _32.info, 'optionalAccess', _33 => _33.version])) {
       mergeInfo({ version: null, legacy: true, routes: { [response.route]: false } });
       evaluateAndWarn();
     }
-  } catch (e5) {
+  } catch (e7) {
   }
 }
 function noteRelayRejection(eventTypes, status, headers) {
   try {
-    if (!state.enabled || status !== 400 || headerInfo(headers)) return [];
+    if (!compat.state.enabled || status !== 400 || headerInfo(headers)) return [];
     const named = [];
     for (const id of featuresForBrowserEvents(eventTypes)) {
       const feature = featureById(id);
       const key = `${id}:relay_rejected`;
-      if (state.warned.has(key)) continue;
-      state.warned.add(key);
+      if (compat.state.warned.has(key)) continue;
+      compat.state.warned.add(key);
       named.push(id);
       try {
-        state.warn(
+        compat.state.warn(
           `The ingester rejected a browser batch containing ${feature.title.toLowerCase()} events. ${feature.title} needs ingester >= ${feature.ingester}; yours is 1.4.0 or older (it predates version reporting), so those batches are dropped. ${ingesterUpgradeHint(COMPAT_MANIFEST)}`
         );
-      } catch (e6) {
+      } catch (e8) {
       }
     }
     return named;
-  } catch (e7) {
+  } catch (e9) {
     return [];
   }
 }
@@ -807,4 +893,5 @@ function noteRelayRejection(eventTypes, status, headers) {
 
 
 
-exports.COMPAT_MANIFEST = COMPAT_MANIFEST; exports.INGESTER_VERSION_HEADER = INGESTER_VERSION_HEADER; exports.versionAtLeast = versionAtLeast; exports.featuresForBrowserEvents = featuresForBrowserEvents; exports.evaluateCompat = evaluateCompat; exports.setDebugMode = setDebugMode; exports.isDebugEnabled = isDebugEnabled; exports.debugLog = debugLog; exports.telemetryStats = telemetryStats; exports.CountingExporter = CountingExporter; exports.registerFlushTarget = registerFlushTarget; exports.unregisterFlushTargets = unregisterFlushTargets; exports.installAutterAutoFlush = installAutterAutoFlush; exports.SDK_IDENTITY = SDK_IDENTITY; exports.compatRequest = compatRequest; exports.fetchIngesterCompat = fetchIngesterCompat; exports.configureCompatCheck = configureCompatCheck; exports.ensureCompatConfigured = ensureCompatConfigured; exports.noteCompatFeature = noteCompatFeature; exports.observeIngesterResponse = observeIngesterResponse; exports.noteRelayRejection = noteRelayRejection;
+
+exports.COMPAT_MANIFEST = COMPAT_MANIFEST; exports.INGESTER_VERSION_HEADER = INGESTER_VERSION_HEADER; exports.versionAtLeast = versionAtLeast; exports.featuresForBrowserEvents = featuresForBrowserEvents; exports.evaluateCompat = evaluateCompat; exports.setDebugMode = setDebugMode; exports.isDebugEnabled = isDebugEnabled; exports.debugLog = debugLog; exports.telemetryStats = telemetryStats; exports.CountingExporter = CountingExporter; exports.registerFlushTarget = registerFlushTarget; exports.unregisterFlushTargets = unregisterFlushTargets; exports.installAutterAutoFlush = installAutterAutoFlush; exports.sharedSlot = sharedSlot; exports.SDK_IDENTITY = SDK_IDENTITY; exports.compatRequest = compatRequest; exports.fetchIngesterCompat = fetchIngesterCompat; exports.configureCompatCheck = configureCompatCheck; exports.ensureCompatConfigured = ensureCompatConfigured; exports.noteCompatFeature = noteCompatFeature; exports.observeIngesterResponse = observeIngesterResponse; exports.noteRelayRejection = noteRelayRejection;

package/dist/{chunk-UGNPCOIW.cjs → chunk-HKVFURYT.cjs}

@@ -5,7 +5,7 @@
 
 
 
-var _chunkARN26OK6cjs = require('./chunk-ARN26OK6.cjs');
+var _chunkGYTQLITWcjs = require('./chunk-GYTQLITW.cjs');
 
 // src/doctor.ts
 var _fs = require('fs');
@@ -30,19 +30,19 @@ function installedSdks(cwd) {
     }
     if (_path.dirname.call(void 0, dir) === dir) break;
   }
-  if (!found.has(_chunkARN26OK6cjs.SDK_IDENTITY.name)) found.set(_chunkARN26OK6cjs.SDK_IDENTITY.name, _chunkARN26OK6cjs.SDK_IDENTITY.version);
+  if (!found.has(_chunkGYTQLITWcjs.SDK_IDENTITY.name)) found.set(_chunkGYTQLITWcjs.SDK_IDENTITY.name, _chunkGYTQLITWcjs.SDK_IDENTITY.version);
   return [...found].map(([name, version]) => ({ name, version }));
 }
 function featuresInUse(sdks) {
-  return _chunkARN26OK6cjs.COMPAT_MANIFEST.features.filter(
+  return _chunkGYTQLITWcjs.COMPAT_MANIFEST.features.filter(
     (feature) => sdks.some((sdk) => {
       const min = feature.sdks[sdk.name];
-      return min !== void 0 && _chunkARN26OK6cjs.versionAtLeast.call(void 0, sdk.version, min) === true;
+      return min !== void 0 && _chunkGYTQLITWcjs.versionAtLeast.call(void 0, sdk.version, min) === true;
     })
   ).map((feature) => feature.id);
 }
 async function checkKey(endpoint, key, timeoutMs) {
-  const res = await _chunkARN26OK6cjs.compatRequest.call(void 0, "POST", `${endpoint}/v1/traces`, {
+  const res = await _chunkGYTQLITWcjs.compatRequest.call(void 0, "POST", `${endpoint}/v1/traces`, {
     body: JSON.stringify({ resourceSpans: [] }),
     headers: { authorization: `Bearer ${key}` },
     unref: false,
@@ -62,10 +62,10 @@ async function runDoctor(options = {}) {
   const features = _optionalChain([options, 'access', _ => _.features, 'optionalAccess', _2 => _2.length]) ? options.features : featuresInUse(sdks);
   const routes = [
     ...new Set(
-      features.map((id) => _optionalChain([_chunkARN26OK6cjs.COMPAT_MANIFEST, 'access', _3 => _3.features, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.id === id), 'optionalAccess', _6 => _6.route])).filter((route) => Boolean(route))
+      features.map((id) => _optionalChain([_chunkGYTQLITWcjs.COMPAT_MANIFEST, 'access', _3 => _3.features, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.id === id), 'optionalAccess', _6 => _6.route])).filter((route) => Boolean(route))
     )
   ];
-  const { info, error } = await _chunkARN26OK6cjs.fetchIngesterCompat.call(void 0, endpoint, { probeRoutes: routes, unref: false, timeoutMs });
+  const { info, error } = await _chunkGYTQLITWcjs.fetchIngesterCompat.call(void 0, endpoint, { probeRoutes: routes, unref: false, timeoutMs });
   const issues = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (issue) => {
@@ -75,15 +75,15 @@ async function runDoctor(options = {}) {
       issues.push(issue);
     }
   };
-  _chunkARN26OK6cjs.evaluateCompat.call(void 0, { features, ingester: info }).forEach(add);
+  _chunkGYTQLITWcjs.evaluateCompat.call(void 0, { features, ingester: info }).forEach(add);
   for (const sdk of sdks) {
     if (_optionalChain([options, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.length])) {
-      _chunkARN26OK6cjs.evaluateCompat.call(void 0, { features: options.features, ingester: null, sdk }).forEach(add);
+      _chunkGYTQLITWcjs.evaluateCompat.call(void 0, { features: options.features, ingester: null, sdk }).forEach(add);
     }
   }
   const key = options.key ? await checkKey(endpoint, options.key, timeoutMs) : void 0;
   const featureRows = features.flatMap((id) => {
-    const feature = _chunkARN26OK6cjs.COMPAT_MANIFEST.features.find((f) => f.id === id);
+    const feature = _chunkGYTQLITWcjs.COMPAT_MANIFEST.features.find((f) => f.id === id);
     if (!feature) return [];
     const bad = issues.some((issue) => issue.feature === id);
     const known = _optionalChain([info, 'optionalAccess', _9 => _9.version]) != null || feature.route !== void 0 && _optionalChain([info, 'optionalAccess', _10 => _10.routes, 'optionalAccess', _11 => _11[feature.route]]) !== void 0;
@@ -153,7 +153,7 @@ Checks that your Autter SDKs, ingester and ClickHouse schema versions match.
 Options:
   --endpoint <url>    Ingester base URL (default: $AUTTER_ENDPOINT, $OTEL_EXPORTER_OTLP_ENDPOINT, or ${DEFAULT_ENDPOINT})
   --key <key>         Also verify an ingest key (default: $AUTTER_RUNTIME_KEY)
-  --features <a,b>    Only check these features (${_chunkARN26OK6cjs.COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
+  --features <a,b>    Only check these features (${_chunkGYTQLITWcjs.COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
   --json              Machine-readable output
   --timeout <ms>      Per-request timeout (default 5000)
 

package/dist/{chunk-FBKYOHU2.js → chunk-KA4AOZX2.js}

@@ -1,7 +1,8 @@
 import {
   noteCompatFeature,
-  observeIngesterResponse
-} from "./chunk-OY2HTUWY.js";
+  observeIngesterResponse,
+  sharedSlot
+} from "./chunk-LG52CW3V.js";
 
 // ../runtime-core/dist/index.js
 var SENSITIVE_KEY_PATTERNS = [
@@ -993,7 +994,7 @@ import {
   unlinkSync
 } from "fs";
 import { join, resolve } from "path";
-var sinkStats = { dropped: 0 };
+var sinkStats = sharedSlot("sinks", () => ({ dropped: 0 }));
 function otlpSink(options = {}) {
   let context = null;
   let queue = [];
@@ -1362,18 +1363,22 @@ function memorySink() {
 }
 
 // src/logger.ts
-var local = new AsyncLocalStorage();
-var config = null;
-var sinks = [];
-var extraSinks = /* @__PURE__ */ new Set();
+var shared = sharedSlot("logger", () => ({
+  local: new AsyncLocalStorage(),
+  config: null,
+  sinks: [],
+  extraSinks: /* @__PURE__ */ new Set()
+}));
+var local = shared.local;
+var extraSinks = shared.extraSinks;
 var fallbackConsole = null;
 function redact(attributes) {
-  return config?.redact(attributes) ?? redactAttributes(attributes);
+  return shared.config?.redact(attributes) ?? redactAttributes(attributes);
 }
 var safe = (attributes = {}) => boundContext(attributes, redact);
 var merge = (current, next) => mergeContext(current, next, redact);
 function activeSinks() {
-  if (config) return extraSinks.size ? [...sinks, ...extraSinks] : sinks;
+  if (shared.config) return extraSinks.size ? [...shared.sinks, ...extraSinks] : shared.sinks;
   if (extraSinks.size) return [...extraSinks];
   fallbackConsole ??= consoleSink();
   return [fallbackConsole];
@@ -1410,9 +1415,9 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   if (state?.sealed) return;
   const summary = extra["autter.event.type"] === "operation";
   if (!summary) recordLogBreadcrumb(level, message, attributes, state);
-  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[config?.options?.minLevel ?? "debug"])
+  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[shared.config?.options?.minLevel ?? "debug"])
     return;
-  if (!summary && state && config?.options?.inline !== false) {
+  if (!summary && state && shared.config?.options?.inline !== false) {
     const { "exception.stacktrace": _stack, ...inlineAttrs } = userContext(
       attributes,
       redact
@@ -1432,7 +1437,7 @@ function emit(level, message, attributes, extra = {}, options = {}) {
     ...operationAttributes(state),
     ...user
   };
-  const enrichers = config?.options?.enrich;
+  const enrichers = shared.config?.options?.enrich;
   if (summary && state && enrichers?.length) {
     const event2 = { level, message, attributes: raw };
     for (const enrich of enrichers) {
@@ -1460,9 +1465,9 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   }
 }
 function configureRuntimeLogger(next) {
-  config = next;
-  sinks = defaultSinks(next);
-  for (const sink of sinks) {
+  shared.config = next;
+  shared.sinks = defaultSinks(next);
+  for (const sink of shared.sinks) {
     try {
       sink.start?.({
         endpoint: next.endpoint,
@@ -1477,14 +1482,14 @@ function configureRuntimeLogger(next) {
   }
 }
 function loggerConfigured() {
-  return config;
+  return shared.config;
 }
 function addRuntimeSink(sink) {
   extraSinks.add(sink);
   return () => extraSinks.delete(sink);
 }
 function notifyException(error, attributes = {}) {
-  if (!extraSinks.size && !sinks.some((sink) => sink.exception)) return;
+  if (!extraSinks.size && !shared.sinks.some((sink) => sink.exception)) return;
   const state = local.getStore();
   const record = {
     time: Date.now(),
@@ -1495,7 +1500,7 @@ function notifyException(error, attributes = {}) {
     ...state ? { operationId: state.id } : {},
     ...state?.requestId ? { requestId: state.requestId } : {}
   };
-  for (const sink of [...sinks, ...extraSinks]) {
+  for (const sink of [...shared.sinks, ...extraSinks]) {
     try {
       sink.exception?.(record);
     } catch {
@@ -1504,25 +1509,25 @@ function notifyException(error, attributes = {}) {
 }
 function runtimeLogStats() {
   return {
-    buffered: sinks.reduce((sum, sink) => sum + (sink.buffered?.() ?? 0), 0),
+    buffered: shared.sinks.reduce((sum, sink) => sum + (sink.buffered?.() ?? 0), 0),
     dropped: sinkStats.dropped
   };
 }
 async function flushRuntimeLogs() {
-  if (!config) return;
+  if (!shared.config) return;
   const results = await Promise.allSettled(
-    sinks.map((sink) => Promise.resolve().then(() => sink.flush?.()))
+    shared.sinks.map((sink) => Promise.resolve().then(() => sink.flush?.()))
   );
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
 async function shutdownRuntimeLogger() {
-  const active = sinks;
+  const active = shared.sinks;
   const results = await Promise.allSettled(
     active.map((sink) => Promise.resolve().then(() => sink.shutdown?.()))
   );
-  config = null;
-  sinks = [];
+  shared.config = null;
+  shared.sinks = [];
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
@@ -1674,7 +1679,7 @@ function emitSummary(state, options = {}) {
 }
 function reportExplicitFailure(state) {
   if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
-    config?.reportOutcome(state.name, state.message ?? "Operation failed", {
+    shared.config?.reportOutcome(state.name, state.message ?? "Operation failed", {
       ...traceAttributes(state),
       "autter.outcome.stack": state.reportingStack ?? ""
     });
@@ -1708,7 +1713,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       thrown = error;
       noteOperationError(error, true, state);
       rememberThrownBreadcrumbs(error, state);
-      config?.captureThrown?.(error);
+      shared.config?.captureThrown?.(error);
       throw error;
     } finally {
       trace.getActiveSpan()?.setAttributes({
@@ -1717,7 +1722,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
         "autter.operation.kind": state.kind
       });
       if (state.outcome === "failed" && !thrown)
-        config?.reportOutcome(
+        shared.config?.reportOutcome(
           state.name,
           state.message ?? "Operation failed",
           {
@@ -1738,7 +1743,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       }
     }
   ] : [];
-  const promise = config?.run ? config.run(state.name, run, traceAttributes(state), links) : run();
+  const promise = shared.config?.run ? shared.config.run(state.name, run, traceAttributes(state), links) : run();
   if (!options.waitUntil) return promise;
   const waitUntil = options.waitUntil;
   return promise.finally(() => {
@@ -1815,9 +1820,14 @@ var runtimeContext = {
 // src/breadcrumbs.ts
 var INVALID_TRACE_ID = "00000000000000000000000000000000";
 var MAX_TRACE_TRAILS = 200;
-var byTrace = /* @__PURE__ */ new Map();
-var processTrail = new BreadcrumbTrail();
-var thrownTrails = /* @__PURE__ */ new WeakMap();
+var trails = sharedSlot("breadcrumbs", () => ({
+  byTrace: /* @__PURE__ */ new Map(),
+  process: new BreadcrumbTrail(),
+  thrown: /* @__PURE__ */ new WeakMap()
+}));
+var byTrace = trails.byTrace;
+var processTrail = trails.process;
+var thrownTrails = trails.thrown;
 function redact2(attributes) {
   return loggerConfigured()?.redact(attributes) ?? redactAttributes(attributes);
 }