@autter/runtime-node 1.7.0 → 1.9.0

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

@@ -2,7 +2,7 @@ import {
   noteCompatFeature,
   observeIngesterResponse,
   sharedSlot
-} from "./chunk-LG52CW3V.js";
+} from "./chunk-ZKM76SDP.js";
 
 // ../runtime-core/dist/index.js
 var SENSITIVE_KEY_PATTERNS = [
@@ -132,8 +132,8 @@ function redactArray(value, r, state, depth) {
     state.ancestors.delete(value);
     return r.mask;
   }
-  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
-  for (let i = 0; i < limit; i += 1) {
+  const limit2 = Math.min(length, MAX_COLLECTION_ENTRIES);
+  for (let i = 0; i < limit2; i += 1) {
     let item;
     try {
       item = value[i];
@@ -143,7 +143,7 @@ function redactArray(value, r, state, depth) {
     }
     out.push(redactValue(item, r, state, depth + 1));
   }
-  if (length > limit) {
+  if (length > limit2) {
     out.push(r.mask);
   }
   state.ancestors.delete(value);
@@ -392,6 +392,53 @@ function toSpanAttributes(context) {
     ])
   );
 }
+var DEBUG_IDS_ATTRIBUTE = "autter.debug_ids";
+var REGISTRY = "_autterDebugIds";
+var pathOfKey = /* @__PURE__ */ new Map();
+function withoutPosition(location) {
+  const match = /^(.*?):\d+:\d+$/.exec(location.trim());
+  return match?.[1] ? match[1] : null;
+}
+function firstFramePath(stack) {
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("at ")) {
+      const body = line.slice(3).trim();
+      const withFn = /^(.*?)\s+\((.*)\)$/.exec(body);
+      const path = withoutPosition(withFn ? withFn[2] : body.replace(/^async /, ""));
+      if (path) return path;
+      continue;
+    }
+    const at = line.lastIndexOf("@");
+    if (at >= 0) {
+      const path = withoutPosition(line.slice(at + 1));
+      if (path) return path;
+    }
+  }
+  return null;
+}
+function debugIdsForStacks(stacks) {
+  try {
+    const registry = globalThis[REGISTRY];
+    if (!registry || typeof registry !== "object") return void 0;
+    const texts = stacks.filter((stack) => typeof stack === "string" && stack !== "");
+    if (texts.length === 0) return void 0;
+    let found;
+    for (const key of Object.keys(registry)) {
+      const id = registry[key];
+      if (typeof id !== "string" || !id) continue;
+      let path = pathOfKey.get(key);
+      if (path === void 0) {
+        path = firstFramePath(key);
+        pathOfKey.set(key, path);
+      }
+      if (path && texts.some((stack) => stack.includes(path))) (found ??= {})[path] = id;
+    }
+    return found;
+  } catch {
+    return void 0;
+  }
+}
 var CODE_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+){0,3}$/;
 var CODE_MAX_LENGTH = 80;
 var WHY_MAX = 1e3;
@@ -514,6 +561,13 @@ function errorStatusOf(err) {
 function isExpectedError(err) {
   return field(err, "expected") === true;
 }
+var STACK_ATTRIBUTE_RE = /^exception\.cause\.\d+\.stacktrace$|^autter\.debug_ids$/;
+function stackAttributesLast(attributes) {
+  const head = {};
+  const tail = {};
+  for (const [key, value] of Object.entries(attributes)) (STACK_ATTRIBUTE_RE.test(key) ? tail : head)[key] = value;
+  return { ...head, ...tail };
+}
 function errorAttributes(err, options = {}) {
   const out = {};
   if (!err || typeof err !== "object") return out;
@@ -530,6 +584,9 @@ function errorAttributes(err, options = {}) {
   const expected = field(err, "expected");
   if (typeof expected === "boolean") out["autter.error.expected"] = expected;
   if (options.causes !== false) {
+    const stacks = options.stacks !== false;
+    const ownStack = field(err, "stack");
+    const allStacks = typeof ownStack === "string" && ownStack ? [ownStack] : [];
     let cause = field(err, "cause");
     const seen = /* @__PURE__ */ new Set([err]);
     for (let n = 1; n <= CAUSE_DEPTH && cause !== void 0 && cause !== null; n++) {
@@ -543,8 +600,17 @@ function errorAttributes(err, options = {}) {
       const causeCode = field(cause, "code");
       if (typeof causeCode === "string" && causeCode)
         out[`exception.cause.${n}.code`] = causeCode.slice(0, CODE_MAX_LENGTH);
+      const causeStack = isError2 ? field(cause, "stack") : void 0;
+      if (stacks && typeof causeStack === "string" && causeStack) {
+        out[`exception.cause.${n}.stacktrace`] = causeStack;
+        allStacks.push(causeStack);
+      }
       cause = isError2 ? field(cause, "cause") : void 0;
     }
+    if (stacks) {
+      const ids = debugIdsForStacks(allStacks);
+      if (ids) out[DEBUG_IDS_ATTRIBUTE] = JSON.stringify(ids);
+    }
   }
   return out;
 }
@@ -758,6 +824,7 @@ function requestOutcome(input) {
   if (input.error !== void 0 && isExpectedError(input.error)) return "degraded";
   if (input.thrown || input.status !== void 0 && input.status >= 500)
     return "failed";
+  if (input.degraded) return "degraded";
   if (input.aborted) return "cancelled";
   return "succeeded";
 }
@@ -974,6 +1041,169 @@ function splitFingerprint(attributes) {
   const { fingerprint, ...rest } = attributes;
   return { attributes: rest, fingerprint };
 }
+var HANDLED_ATTRIBUTE = "autter.handled";
+var HANDLING_ATTRIBUTE = "autter.handling";
+var LOG_SOURCE_ATTRIBUTE = "autter.log.source";
+var LOG_MESSAGE_ATTRIBUTE = "autter.log.message";
+var DEGRADED_REASON_ATTRIBUTE = "autter.degraded.reason";
+var CAUGHT_DROPPED_ATTRIBUTE = "autter.caught.dropped";
+var LOG_MESSAGE_MAX = 1e3;
+var DEGRADED_REASON_MAX = 500;
+var CAUGHT_BURST = 10;
+var CAUGHT_REFILL_MS = 1e4;
+var SOURCES = ["console", "pino", "winston", "bunyan", "runtimeLogger"];
+function loggedErrorSources(option) {
+  const out = {};
+  for (const source of SOURCES)
+    out[source] = option === false ? false : option === void 0 || option === true || typeof option !== "object" ? true : option[source] !== false;
+  return out;
+}
+function handledErrorKind(error) {
+  let type = "Error";
+  let site = "";
+  try {
+    if (isError(error)) {
+      type = String(error.name || "Error").slice(0, 200);
+      const lines = String(error.stack ?? "").split("\n");
+      site = (lines.find((line) => /^\s*at\s/.test(line)) ?? lines[1] ?? "").trim().slice(0, 300);
+    }
+  } catch {
+  }
+  return { key: `${type}
+${site}`, type };
+}
+function caughtErrorAttributes(source, message, dropped = 0) {
+  return {
+    [HANDLED_ATTRIBUTE]: true,
+    [HANDLING_ATTRIBUTE]: "caught",
+    [LOG_SOURCE_ATTRIBUTE]: source,
+    ...message ? { [LOG_MESSAGE_ATTRIBUTE]: message.slice(0, LOG_MESSAGE_MAX) } : {},
+    ...dropped > 0 ? { [CAUGHT_DROPPED_ATTRIBUTE]: dropped } : {}
+  };
+}
+function degradedAttributes(reason, dropped = 0) {
+  let text = "";
+  try {
+    text = String(reason ?? "");
+  } catch {
+  }
+  return {
+    [HANDLED_ATTRIBUTE]: true,
+    [HANDLING_ATTRIBUTE]: "deliberate",
+    [DEGRADED_REASON_ATTRIBUTE]: text.slice(0, DEGRADED_REASON_MAX) || "degraded",
+    ...dropped > 0 ? { [CAUGHT_DROPPED_ATTRIBUTE]: dropped } : {}
+  };
+}
+var BurstLimiter = class {
+  constructor(burst = CAUGHT_BURST, refillMs = CAUGHT_REFILL_MS, maxKeys = 1e3) {
+    this.burst = burst;
+    this.refillMs = refillMs;
+    this.maxKeys = maxKeys;
+  }
+  burst;
+  refillMs;
+  maxKeys;
+  buckets = /* @__PURE__ */ new Map();
+  evicted = [];
+  /**
+   * -1 when the record is left out (and counted). Otherwise it is sent,
+   * and the number of its kind left out since the last one sent is
+   * returned, to report with it.
+   */
+  take(key, type, now = Date.now()) {
+    const bucket = this.buckets.get(key) ?? { tokens: this.burst, at: now, dropped: 0, type };
+    this.buckets.delete(key);
+    this.buckets.set(key, bucket);
+    this.refill(bucket, now);
+    let result;
+    if (bucket.tokens < 1) {
+      bucket.dropped += 1;
+      result = -1;
+    } else {
+      bucket.tokens -= 1;
+      result = bucket.dropped;
+      bucket.dropped = 0;
+    }
+    while (this.buckets.size > this.maxKeys) {
+      const oldest = this.buckets.keys().next().value;
+      const gone = this.buckets.get(oldest);
+      this.buckets.delete(oldest);
+      if (gone.dropped > 0) this.evicted.push({ key: oldest, type: gone.type, dropped: gone.dropped });
+    }
+    return result;
+  }
+  /**
+   * Counts no sent record carried: kinds that have a token again (nothing
+   * of theirs came along to carry the count) or, with `all`, every kind
+   * with a count. The counts returned are reset.
+   */
+  drain(now = Date.now(), all = false) {
+    const out = this.evicted;
+    this.evicted = [];
+    for (const [key, bucket] of this.buckets) {
+      if (bucket.dropped === 0) continue;
+      this.refill(bucket, now);
+      if (!all && bucket.tokens < 1) continue;
+      out.push({ key, type: bucket.type, dropped: bucket.dropped });
+      bucket.dropped = 0;
+    }
+    return out;
+  }
+  /** When the next uncarried count can be drained, or null when none is pending. */
+  nextDrainAt() {
+    if (this.evicted.length) return 0;
+    let next = null;
+    for (const bucket of this.buckets.values()) {
+      if (bucket.dropped === 0) continue;
+      const at = bucket.at + Math.max(0, 1 - bucket.tokens) * this.refillMs;
+      if (next === null || at < next) next = at;
+    }
+    return next;
+  }
+  refill(bucket, now) {
+    if (now > bucket.at) {
+      bucket.tokens = Math.min(this.burst, bucket.tokens + (now - bucket.at) / this.refillMs);
+      bucket.at = now;
+    }
+  }
+};
+function testPattern(pattern, type, message) {
+  if (typeof pattern === "string") {
+    return pattern !== "" && (message.includes(pattern) || type.includes(pattern));
+  }
+  if (!(pattern instanceof RegExp)) return false;
+  const re = pattern.global || pattern.sticky ? new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, "")) : pattern;
+  return re.test(message) || type !== "" && (re.test(type) || re.test(`${type}: ${message}`));
+}
+function isIgnoredError(patterns, type, message) {
+  if (!patterns?.length) return false;
+  for (const pattern of patterns) {
+    try {
+      if (testPattern(pattern, type, message)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function effectiveSampleRate(rate) {
+  return typeof rate === "number" && Number.isFinite(rate) && rate >= 0 && rate < 1 ? rate : null;
+}
+function createErrorFilter(options = {}, random = Math.random) {
+  const patterns = Array.isArray(options.ignoreErrors) ? options.ignoreErrors.slice() : [];
+  const rate = effectiveSampleRate(options.sampleRate);
+  if (!patterns.length && rate === null) return () => true;
+  return (input) => {
+    try {
+      if (isIgnoredError(patterns, input.type ?? "", input.message ?? "")) return false;
+      if (rate === null || input.crash) return true;
+      const severity = input.severity ?? "error";
+      if (severity !== "error") return true;
+      return random() < rate;
+    } catch {
+      return true;
+    }
+  };
+}
 
 // src/breadcrumbs.ts
 import { trace as trace2 } from "@opentelemetry/api";
@@ -985,6 +1215,267 @@ import {
   trace
 } from "@opentelemetry/api";
 
+// src/caught-errors.ts
+import { createRequire } from "module";
+import { join } from "path";
+import { format } from "util";
+import { Hook } from "require-in-the-middle";
+
+// src/captured.ts
+var CAPTURED = sharedSlot("requests", () => ({ captured: /* @__PURE__ */ new WeakSet() })).captured;
+function markCaptured(error) {
+  if (error && typeof error === "object") CAPTURED.add(error);
+}
+function isCaptured(error) {
+  return !!error && typeof error === "object" && CAPTURED.has(error);
+}
+
+// src/caught-errors.ts
+var S = sharedSlot("handled", () => ({
+  sources: null,
+  capture: null,
+  tail: null,
+  limiter: new BurstLimiter(),
+  decided: /* @__PURE__ */ new WeakSet(),
+  timer: null,
+  hooked: false
+}));
+var PATCHED = /* @__PURE__ */ Symbol.for("autter.runtime.logged-errors");
+function setHandledCapture(capture) {
+  S.capture = capture;
+}
+function setHandledTail(tail) {
+  S.tail = tail;
+}
+function scheduleTail() {
+  if (S.timer) return;
+  const at = S.limiter.nextDrainAt();
+  if (at === null) return;
+  S.timer = setTimeout(() => sendTails(false), Math.max(0, at - Date.now()) + 5);
+  S.timer.unref?.();
+}
+function sendTails(all) {
+  if (S.timer) clearTimeout(S.timer);
+  S.timer = null;
+  for (const tail of S.limiter.drain(Date.now(), all)) {
+    try {
+      S.tail?.(tail.type, tail.dropped);
+    } catch {
+    }
+  }
+  if (!all) scheduleTail();
+}
+function limit(prefix, error) {
+  const kind = handledErrorKind(error);
+  const dropped = S.limiter.take(`${prefix}
+${kind.key}`, kind.type);
+  if (dropped < 0) scheduleTail();
+  return dropped;
+}
+function reportLoggedError(error, source, message, attributes) {
+  if (!S.sources?.[source] || !isError(error)) return;
+  if (S.decided.has(error) || isCaptured(error)) return;
+  S.decided.add(error);
+  const run = () => {
+    try {
+      if (isCaptured(error) || !S.capture || !S.sources) return;
+      const dropped = limit("caught", error);
+      if (dropped < 0) return;
+      markCaptured(error);
+      S.capture(error, { ...attributes, ...caughtErrorAttributes(source, message, dropped) }, "error");
+    } catch {
+    }
+  };
+  try {
+    setImmediate(run);
+  } catch {
+  }
+}
+function reportDegraded(error, reason, attributes) {
+  if (!S.capture) return;
+  if (error && typeof error === "object") S.decided.add(error);
+  const dropped = limit("deliberate", error);
+  if (dropped < 0) return;
+  markCaptured(error);
+  S.capture(error, { ...attributes, ...degradedAttributes(reason, dropped) }, "warning");
+}
+function onConsoleError(args) {
+  if (!S.sources?.console) return;
+  if (typeof args[0] === "string" && args[0].startsWith("[autter")) return;
+  for (const arg of args) {
+    if (!isError(arg)) continue;
+    let message = "";
+    try {
+      message = format(...args.filter((other) => other !== arg));
+    } catch {
+    }
+    reportLoggedError(arg, "console", message);
+  }
+}
+function patchConsole() {
+  const target = console;
+  try {
+    if (target[PATCHED]) return;
+    const original = target.error;
+    if (typeof original !== "function") return;
+    target.error = function(...args) {
+      try {
+        onConsoleError(args);
+      } catch {
+      }
+      return original.apply(this, args);
+    };
+    Object.defineProperty(target, PATCHED, { value: true });
+  } catch {
+  }
+}
+function errorField(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  for (const key of ["err", "error"]) if (isError(record[key])) return record[key];
+  let seen = 0;
+  for (const key of Object.keys(record)) {
+    if (++seen > 20) break;
+    if (isError(record[key])) return record[key];
+  }
+  return void 0;
+}
+function wrapMethod(target, key, inspect) {
+  const original = target[key];
+  if (typeof original !== "function") return;
+  target[key] = function(...args) {
+    try {
+      inspect(this, args);
+    } catch {
+    }
+    return original.apply(this, args);
+  };
+}
+function markPatched(target) {
+  const record = target;
+  if (record[PATCHED]) return false;
+  try {
+    Object.defineProperty(target, PATCHED, { value: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function patchPino(protoFactory) {
+  if (typeof protoFactory !== "function") return;
+  const proto = Object.getPrototypeOf(protoFactory());
+  if (!proto) return;
+  const write = Object.getOwnPropertySymbols(proto).find((symbol) => symbol.description === "pino.write");
+  if (!write || typeof proto[write] !== "function" || !markPatched(proto)) return;
+  wrapMethod(proto, write, (_self, [obj, msg, level]) => {
+    if (!S.sources?.pino || typeof level !== "number" || level < 50) return;
+    const error = isError(obj) ? obj : errorField(obj);
+    if (error) reportLoggedError(error, "pino", typeof msg === "string" ? msg : void 0);
+  });
+}
+var WINSTON_ERROR_LEVELS = /^(?:error|fatal|crit|alert|emerg)$/;
+function winstonErrorLevel(logger, level) {
+  if (typeof level !== "string") return false;
+  const levels = logger?.levels;
+  if (levels && typeof levels[level] === "number" && typeof levels.error === "number")
+    return levels[level] <= levels.error;
+  return WINSTON_ERROR_LEVELS.test(level);
+}
+function patchWinston(Logger) {
+  const proto = Logger?.prototype;
+  if (!proto || typeof proto.log !== "function" || !markPatched(proto)) return;
+  wrapMethod(proto, "log", (self, [level, msg, ...meta]) => {
+    if (!S.sources?.winston || !winstonErrorLevel(self, level)) return;
+    for (const arg of [msg, ...meta]) {
+      const error = isError(arg) ? arg : errorField(arg);
+      if (error) reportLoggedError(error, "winston", typeof msg === "string" ? msg : void 0);
+    }
+  });
+  wrapMethod(proto, "_addDefaultMeta", (self, [info]) => {
+    if (!S.sources?.winston || !info || typeof info !== "object") return;
+    if (!winstonErrorLevel(self, info.level)) return;
+    if (isError(info)) reportLoggedError(info, "winston");
+    else {
+      const error = errorField(info);
+      const message = info.message;
+      if (error) reportLoggedError(error, "winston", typeof message === "string" ? message : void 0);
+    }
+  });
+}
+function patchBunyan(Logger) {
+  const proto = Logger?.prototype;
+  if (!proto || typeof proto.error !== "function" || !markPatched(proto)) return;
+  for (const [method, level] of [["error", 50], ["fatal", 60]]) {
+    wrapMethod(proto, method, (self, args) => {
+      if (!S.sources?.bunyan || args.length === 0) return;
+      const min = self?._level;
+      if (typeof min === "number" && min > level) return;
+      const error = isError(args[0]) ? args[0] : errorField(args[0]);
+      if (!error) return;
+      let message = "";
+      try {
+        message = format(...args.slice(1));
+      } catch {
+      }
+      reportLoggedError(error, "bunyan", message);
+    });
+  }
+}
+var TARGETS = [
+  { file: "pino/lib/proto.js", patch: patchPino },
+  { file: "winston/lib/winston/logger.js", patch: patchWinston },
+  { file: "bunyan/lib/bunyan.js", patch: patchBunyan }
+];
+function patchModule(file, exports) {
+  const target = TARGETS.find((entry) => entry.file === file);
+  if (!target) return;
+  try {
+    target.patch(exports);
+  } catch {
+  }
+}
+function scanModuleCache() {
+  try {
+    const cache = createRequire(join(process.cwd(), "autter-runtime-loggers.cjs")).cache;
+    for (const [key, entry] of Object.entries(cache)) {
+      const path = key.replace(/\\/g, "/");
+      for (const target of TARGETS)
+        if (path.endsWith(`/node_modules/${target.file}`)) patchModule(target.file, entry?.exports);
+    }
+  } catch {
+  }
+}
+function hookLaterLoads() {
+  if (S.hooked) return;
+  S.hooked = true;
+  try {
+    new Hook(["pino", "winston", "bunyan"], { internals: true }, (exports, name) => {
+      const file = name.replace(/\\/g, "/");
+      patchModule(file === "bunyan" ? "bunyan/lib/bunyan.js" : file, exports);
+      return exports;
+    });
+  } catch {
+  }
+  for (const delay of [0, 1e3, 1e4]) {
+    const timer = setTimeout(scanModuleCache, delay);
+    timer.unref?.();
+  }
+}
+function startLoggedErrorCapture(option) {
+  const sources = loggedErrorSources(option);
+  S.sources = sources;
+  if (!Object.values(sources).some(Boolean)) return;
+  if (sources.console) patchConsole();
+  if (sources.pino || sources.winston || sources.bunyan) {
+    scanModuleCache();
+    hookLaterLoads();
+  }
+}
+function stopLoggedErrorCapture() {
+  S.sources = null;
+  sendTails(true);
+}
+
 // src/sinks.ts
 import {
   appendFileSync,
@@ -993,7 +1484,7 @@ import {
   statSync,
   unlinkSync
 } from "fs";
-import { join, resolve } from "path";
+import { join as join2, resolve } from "path";
 var sinkStats = sharedSlot("sinks", () => ({ dropped: 0 }));
 function otlpSink(options = {}) {
   let context = null;
@@ -1247,14 +1738,14 @@ function formatPretty(event, color = false) {
   return lines.join("\n");
 }
 function consoleSink(options = {}) {
-  const format = options.format ?? (process.env.NODE_ENV === "production" ? "json" : "pretty");
+  const format2 = options.format ?? (process.env.NODE_ENV === "production" ? "json" : "pretty");
   const color = options.color ?? (process.stdout?.isTTY === true && !process.env.NO_COLOR);
   const write = options.write ?? ((line) => console.log(line));
   return {
     name: "console",
     write(event) {
       write(
-        format === "json" ? JSON.stringify({
+        format2 === "json" ? JSON.stringify({
           ...event.attributes,
           level: event.level,
           message: event.message
@@ -1284,7 +1775,7 @@ function fileSink(options = {}) {
     const existing = files().filter((file) => file.name !== current);
     const excess = existing.length + 1 - maxFiles;
     for (const file of existing.slice(0, Math.max(0, excess)))
-      unlinkSync(join(dir, file.name));
+      unlinkSync(join2(dir, file.name));
   };
   const open = (nextDay) => {
     mkdirSync(dir, { recursive: true });
@@ -1292,7 +1783,7 @@ function fileSink(options = {}) {
     const sameDay = files().filter((file) => file.day === day);
     index = sameDay.length ? sameDay[sameDay.length - 1].index : 0;
     try {
-      currentBytes = statSync(join(dir, fileName(day, index))).size;
+      currentBytes = statSync(join2(dir, fileName(day, index))).size;
     } catch {
       currentBytes = 0;
     }
@@ -1334,7 +1825,7 @@ function fileSink(options = {}) {
           currentBytes = 0;
           prune();
         }
-        appendFileSync(join(dir, fileName(day, index)), line);
+        appendFileSync(join2(dir, fileName(day, index)), line);
         currentBytes += bytes;
       } catch (error) {
         disable(error);
@@ -1430,13 +1921,13 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   const exceptions = Object.fromEntries(
     Object.entries(user).filter(([key]) => key.startsWith("exception."))
   );
-  const raw = {
+  const raw = stackAttributesLast({
     "autter.event.id": randomUUID(),
     ...extra,
     ...exceptions,
     ...operationAttributes(state),
     ...user
-  };
+  });
   const enrichers = shared.config?.options?.enrich;
   if (summary && state && enrichers?.length) {
     const event2 = { level, message, attributes: raw };
@@ -1546,29 +2037,32 @@ function createRuntimeLogger(attributes = {}) {
     debug: (message, extra) => emit("debug", message, merge(attrs, extra)),
     info: (message, extra) => emit("info", message, merge(attrs, extra)),
     warn: (message, extra) => emit("warning", message, merge(attrs, extra)),
-    error: (error, extra) => emit(
-      "error",
-      isError(error) ? error.message : String(error),
-      {
-        ...attrs,
-        ...extra,
-        ...isError(error) ? {
-          "exception.type": error.name,
-          "exception.stacktrace": error.stack ?? ""
-        } : {}
-      },
-      errorAttributes(error)
-    )
+    error: (error, extra) => {
+      emit(
+        "error",
+        isError(error) ? error.message : String(error),
+        {
+          ...attrs,
+          ...extra,
+          ...isError(error) ? {
+            "exception.type": error.name,
+            "exception.stacktrace": error.stack ?? ""
+          } : {}
+        },
+        errorAttributes(error)
+      );
+      if (isError(error)) reportLoggedError(error, "runtimeLogger", void 0, toSpanAttributes(merge(attrs, extra)));
+    }
   };
 }
 var runtimeLogger = createRuntimeLogger();
-function captureExceptionAsLog(error, attributes = {}) {
+function captureExceptionAsLog(error, attributes = {}, level = "error") {
   const isErr = isError(error);
   const message = isErr ? error.message : String(error);
   const stack = isErr && error.stack ? error.stack : new Error().stack?.split("\n").filter((line, i) => i === 0 || !/captureException/.test(line)).join("\n") ?? "";
-  noteOperationError(error);
+  if (level === "error") noteOperationError(error);
   emit(
-    "error",
+    level,
     message,
     {
       ...attributes,
@@ -1653,13 +2147,15 @@ function summaryExtra(state, level, http = {}) {
     "autter.operation.level": maxLevel(state.inline.level, level),
     ...state.ai ? { "autter.operation.ai": state.ai } : {},
     ...http,
-    ...err !== void 0 ? errorAttributes(err) : {},
+    // A summary is no occurrence: no cause stacks or debug ids.
+    ...err !== void 0 ? errorAttributes(err, { stacks: false }) : {},
     ...state.inline.logsTruncated ? { "autter.operation.logs_truncated": true } : {},
     ...state.inline.logs.length ? { "autter.operation.logs": state.inline.logs } : {}
   };
 }
 function emitSummary(state, options = {}) {
   if (state.sealed) return;
+  settleDegraded(state);
   const err = state.error;
   const level = state.outcome === "failed" ? "error" : "info";
   emit(
@@ -1677,6 +2173,10 @@ function emitSummary(state, options = {}) {
   );
   state.sealed = true;
 }
+function settleDegraded(state) {
+  if (state.degraded && state.outcome === "succeeded" && !state.explicitOutcome)
+    state.outcome = "degraded";
+}
 function reportExplicitFailure(state) {
   if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
     shared.config?.reportOutcome(state.name, state.message ?? "Operation failed", {
@@ -1716,6 +2216,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       shared.config?.captureThrown?.(error);
       throw error;
     } finally {
+      settleDegraded(state);
       trace.getActiveSpan()?.setAttributes({
         ...traceAttributes(state),
         "autter.operation.outcome": state.outcome,
@@ -1787,6 +2288,30 @@ var runtimeContext = {
     noteOperationError(error);
     runtimeLogger.error(error, attributes);
   },
+  /**
+   * The app caught `error` and chose to continue on a fallback (RF-02):
+   *
+   *   } catch (err) {
+   *     runtimeContext.degraded(err, "pricing service down, using cached prices");
+   *   }
+   *
+   * Recorded as an occurrence at `warning` severity, marked
+   * `autter.handling = "deliberate"` with the reason (grouped by its code
+   * when the error has one), never an incident. The current request or
+   * operation ends "degraded" unless it failed or set its outcome.
+   */
+  degraded(error, reason, attributes) {
+    try {
+      const state = currentOperation();
+      if (state) {
+        state.degraded = true;
+        noteOperationError(error, false, state);
+        appendInlineLog(state.inline, "warning", `degraded: ${String(reason)}`, void 0, redact);
+      }
+      reportDegraded(error, reason, toSpanAttributes(userContext(attributes, redact)));
+    } catch {
+    }
+  },
   /** Current operation id. */
   get id() {
     return local.getStore()?.id;
@@ -1816,6 +2341,15 @@ var runtimeContext = {
     });
   }
 };
+setHandledTail(
+  (type, dropped) => emit(
+    "warning",
+    `${dropped} caught ${type} error(s) left out by the burst limit`,
+    { "autter.caught.dropped": dropped, "autter.caught.type": type },
+    {},
+    { state: null }
+  )
+);
 
 // src/breadcrumbs.ts
 var INVALID_TRACE_ID = "00000000000000000000000000000000";
@@ -1878,10 +2412,10 @@ function recordLogBreadcrumb(level, message, attributes, state) {
   }
 }
 function attributeBudget() {
-  const limit = Number(
+  const limit2 = Number(
     process.env.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT ?? process.env.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT
   );
-  return Number.isFinite(limit) && limit > 0 ? Math.min(BREADCRUMBS_ATTRIBUTE_MAX_CHARS, limit) : BREADCRUMBS_ATTRIBUTE_MAX_CHARS;
+  return Number.isFinite(limit2) && limit2 > 0 ? Math.min(BREADCRUMBS_ATTRIBUTE_MAX_CHARS, limit2) : BREADCRUMBS_ATTRIBUTE_MAX_CHARS;
 }
 function rememberThrownBreadcrumbs(error, state) {
   if (state.breadcrumbs && error !== null && (typeof error === "object" || typeof error === "function"))
@@ -1924,8 +2458,14 @@ export {
   fingerprintValues,
   fingerprintEventAttributes,
   splitFingerprint,
+  createErrorFilter,
   addBreadcrumb,
   breadcrumbEventAttributes,
+  markCaptured,
+  isCaptured,
+  setHandledCapture,
+  startLoggedErrorCapture,
+  stopLoggedErrorCapture,
   otlpSink,
   consoleSink,
   fileSink,