@autter/otlp-ingester 1.6.1 → 1.8.0

package/dist/sink.d.ts

@@ -26,6 +26,17 @@ export interface SinkTuning {
     /** Deliveries run concurrently while healthy, serially while failing. */
     healthyConcurrency: number;
 }
+/** A batch the sink gave up on (counted in runtime_ingest_drops, route "sink"). */
+export interface SinkDrop {
+    orgId: string;
+    repositoryId: string;
+    /** sink_overflow: buffer overflow, or a batch bigger than the buffer;
+     * sink_rejected: the consumer answered a permanent 4xx;
+     * sink_gave_up: SINK_MAX_ATTEMPTS deliveries failed. */
+    reason: "sink_overflow" | "sink_rejected" | "sink_gave_up";
+    /** Occurrences in the batch. */
+    occurrences: number;
+}
 /**
  * Operational counters for /healthz. Failure detail is reduced to a fixed
  * category (`timeout`, `connection_error`, `http_<status>`, `error`) — the
@@ -72,10 +83,13 @@ export declare class SinkForwarder {
     private lastFailureAt;
     private lastFailureReason;
     private readonly tuning;
+    /** Called for every batch given up on; must not throw (errors are swallowed). */
+    onDrop: ((drop: SinkDrop) => void) | null;
     constructor(config: IngesterConfig, fetchImpl?: typeof fetch, tuning?: Partial<SinkTuning>);
     /** Queue a batch for delivery. No-op when there is nothing to send. */
     enqueue(ctx: IngestContext, occurrences: RuntimeOccurrence[], metricPoints?: RuntimeMetricPoint[], llmCalls?: RuntimeLlmCall[]): void;
     stats(): SinkStats;
+    private noteDrop;
     pendingCount(): number;
     /** Stop scheduling new deliveries (shutdown). Queued batches are logged
      * by the caller — they are recoverable from ClickHouse, not from here. */

package/dist/sink.js

@@ -44,6 +44,8 @@ export class SinkForwarder {
     lastFailureAt = null;
     lastFailureReason = null;
     tuning;
+    /** Called for every batch given up on; must not throw (errors are swallowed). */
+    onDrop = null;
     constructor(config, fetchImpl = fetch, tuning = {}) {
         this.config = config;
         this.fetchImpl = fetchImpl;
@@ -65,6 +67,7 @@ export class SinkForwarder {
         if (batch.bytes > this.maxBufferedBytes()) {
             this.droppedOverflow += 1;
             console.warn(`sink batch ${batch.batchId} (org ${batch.orgId}) exceeds the buffer cap (${batch.bytes} bytes) — dropped; replay signals ${batch.signalsFrom ?? "?"} .. ${batch.signalsTo ?? "?"} from ClickHouse`);
+            this.noteDrop(batch, "sink_overflow");
             return;
         }
         this.queue.push(batch);
@@ -88,6 +91,14 @@ export class SinkForwarder {
             oldestQueuedSince: oldest ? new Date(oldest).toISOString() : null,
         };
     }
+    noteDrop(batch, reason) {
+        try {
+            this.onDrop?.({ orgId: batch.orgId, repositoryId: batch.repositoryId, reason, occurrences: batch.occurrences });
+        }
+        catch {
+            // Drop accounting must never affect delivery.
+        }
+    }
     pendingCount() {
         return this.queue.length + this.inFlight;
     }
@@ -122,6 +133,8 @@ export class SinkForwarder {
         return {
             batchId,
             orgId: ctx.orgId,
+            repositoryId: ctx.repositoryId,
+            occurrences: occurrences.length,
             body,
             bytes: Buffer.byteLength(body),
             seq: ++this.seqCounter,
@@ -170,6 +183,7 @@ export class SinkForwarder {
                 break;
             this.droppedOverflow += 1;
             console.warn(`sink buffer overflow: dropped batch ${dropped.batchId} (org ${dropped.orgId}, signals ${dropped.signalsFrom ?? "?"} .. ${dropped.signalsTo ?? "?"}) — replay this range from ClickHouse`);
+            this.noteDrop(dropped, "sink_overflow");
         }
     }
     /** The oldest batch of the org holding the most buffered bytes. */
@@ -280,6 +294,7 @@ export class SinkForwarder {
         if (permanent || batch.attempts >= this.config.sinkMaxAttempts) {
             this.droppedPermanent += 1;
             console.error(`sink delivery gave up after ${batch.attempts} attempt(s) (${detail}): batch ${batch.batchId} (signals ${batch.signalsFrom ?? "?"} .. ${batch.signalsTo ?? "?"}) — replay this range from ClickHouse`);
+            this.noteDrop(batch, permanent ? "sink_rejected" : "sink_gave_up");
             return;
         }
         this.retried += 1;

package/dist/source-maps-lookup.d.ts

@@ -21,9 +21,12 @@ export declare function lookupSourceMap(client: ClickHouseClient, database: stri
  */
 export declare const SOURCE_MAP_FRESH_DAYS = 7;
 /**
- * Which check entries the tenant already has: same release, path, debug id
- * and content hash, uploaded in the last SOURCE_MAP_FRESH_DAYS. Returns the
- * indexes of `check.entries` that need no upload.
+ * Which check entries the tenant already has. An entry with a hash: same
+ * release, path, debug id and content hash, uploaded in the last
+ * SOURCE_MAP_FRESH_DAYS (the upload skips those). An entry with only a
+ * debug id: any stored map with that id, whatever its release and path —
+ * exactly what lookupSourceMap would find for a stack from that bundle.
+ * Returns the indexes of `check.entries` that are present.
  */
 export declare function presentSourceMaps(client: ClickHouseClient, database: string, tenant: {
     orgId: string;

package/dist/source-maps-lookup.js

@@ -34,13 +34,41 @@ export async function lookupSourceMap(client, database, key) {
  */
 export const SOURCE_MAP_FRESH_DAYS = 7;
 /**
- * Which check entries the tenant already has: same release, path, debug id
- * and content hash, uploaded in the last SOURCE_MAP_FRESH_DAYS. Returns the
- * indexes of `check.entries` that need no upload.
+ * Which check entries the tenant already has. An entry with a hash: same
+ * release, path, debug id and content hash, uploaded in the last
+ * SOURCE_MAP_FRESH_DAYS (the upload skips those). An entry with only a
+ * debug id: any stored map with that id, whatever its release and path —
+ * exactly what lookupSourceMap would find for a stack from that bundle.
+ * Returns the indexes of `check.entries` that are present.
  */
 export async function presentSourceMaps(client, database, tenant, check) {
-    if (check.entries.length === 0)
-        return [];
+    const hashed = check.entries.some((entry) => entry.hash);
+    const byId = check.entries.filter((entry) => !entry.hash).map((entry) => entry.debugId);
+    const [withHash, ids] = await Promise.all([
+        hashed ? presentByHash(client, database, tenant, check) : new Set(),
+        byId.length ? presentDebugIds(client, database, tenant, byId) : new Set(),
+    ]);
+    const present = [];
+    check.entries.forEach((entry, index) => {
+        const found = entry.hash
+            ? withHash.has(`${entry.filename}\u0000${entry.debugId}\u0000${entry.hash}`)
+            : ids.has(entry.debugId);
+        if (found)
+            present.push(index);
+    });
+    return present;
+}
+async function presentDebugIds(client, database, tenant, debugIds) {
+    const rows = await client.query({
+        query: `SELECT DISTINCT debug_id FROM ${database}.runtime_source_maps
+			WHERE org_id = {org:String} AND repository_id = {repo:String}
+				AND has({debugIds:Array(String)}, debug_id)`,
+        query_params: { org: tenant.orgId, repo: tenant.repositoryId, debugIds: [...new Set(debugIds)] },
+        format: "JSONEachRow",
+    });
+    return new Set((await rows.json()).map((row) => row.debug_id));
+}
+async function presentByHash(client, database, tenant, check) {
     const rows = await client.query({
         query: `SELECT DISTINCT filename, debug_id, content_hash FROM ${database}.runtime_source_maps
 			WHERE org_id = {org:String} AND repository_id = {repo:String} AND release = {release:String}
@@ -50,15 +78,9 @@ export async function presentSourceMaps(client, database, tenant, check) {
             org: tenant.orgId,
             repo: tenant.repositoryId,
             release: check.release,
-            hashes: [...new Set(check.entries.map((entry) => entry.hash))],
+            hashes: [...new Set(check.entries.filter((entry) => entry.hash).map((entry) => entry.hash))],
         },
         format: "JSONEachRow",
     });
-    const stored = new Set((await rows.json()).map((row) => `${row.filename}\u0000${row.debug_id}\u0000${row.content_hash}`));
-    const present = [];
-    check.entries.forEach((entry, index) => {
-        if (stored.has(`${entry.filename}\u0000${entry.debugId}\u0000${entry.hash}`))
-            present.push(index);
-    });
-    return present;
+    return new Set((await rows.json()).map((row) => `${row.filename}\u0000${row.debug_id}\u0000${row.content_hash}`));
 }

package/dist/source-maps.d.ts

@@ -49,6 +49,7 @@ export declare function validateSourceMap(body: unknown): ValidSourceMap | null;
 export interface SourceMapCheckEntry {
     filename: string;
     debugId: string;
+    /** sha256 of the stored map, or "" for a check by debug id alone (1.7.0+). */
     hash: string;
 }
 export interface SourceMapCheck {
@@ -59,9 +60,12 @@ export interface SourceMapCheck {
 export declare const SOURCE_MAP_CHECK_MAX = 500;
 /**
  * Validate a `/v1/sourcemaps/check` request:
- * `{ release, files: [{ filename, debugId?, hash }] }` (≤ 500 files). The
+ * `{ release, files: [{ filename, debugId?, hash? }] }` (≤ 500 files). The
  * filenames and debug ids are normalised exactly as an upload would store
- * them. Null when invalid.
+ * them. Each file needs a hash (is this exact map stored? — what `upload`
+ * asks to skip maps) or, from 1.7.0, a debug id alone (is any map stored
+ * for this bundle? — what `sourcemaps verify` asks after the maps were
+ * deleted). Null when invalid.
  */
 export declare function validateSourceMapCheck(body: unknown): SourceMapCheck | null;
 /** Most scripts one browser event may name in `debugIds`. */

package/dist/source-maps.js

@@ -106,9 +106,12 @@ export function validateSourceMap(body) {
 export const SOURCE_MAP_CHECK_MAX = 500;
 /**
  * Validate a `/v1/sourcemaps/check` request:
- * `{ release, files: [{ filename, debugId?, hash }] }` (≤ 500 files). The
+ * `{ release, files: [{ filename, debugId?, hash? }] }` (≤ 500 files). The
  * filenames and debug ids are normalised exactly as an upload would store
- * them. Null when invalid.
+ * them. Each file needs a hash (is this exact map stored? — what `upload`
+ * asks to skip maps) or, from 1.7.0, a debug id alone (is any map stored
+ * for this bundle? — what `sourcemaps verify` asks after the maps were
+ * deleted). Null when invalid.
  */
 export function validateSourceMapCheck(body) {
     if (!body || typeof body !== "object")
@@ -123,7 +126,10 @@ export function validateSourceMapCheck(body) {
         if (!raw || typeof raw !== "object")
             return null;
         const file = raw;
-        if (typeof file.filename !== "string" || typeof file.hash !== "string" || !/^[0-9a-f]{64}$/.test(file.hash))
+        if (typeof file.filename !== "string")
+            return null;
+        const hash = file.hash === undefined || file.hash === null || file.hash === "" ? "" : file.hash;
+        if (typeof hash !== "string" || (hash !== "" && !/^[0-9a-f]{64}$/.test(hash)))
             return null;
         const filename = sourceMapPath(file.filename);
         if (!filename)
@@ -131,7 +137,9 @@ export function validateSourceMapCheck(body) {
         const debugId = file.debugId === undefined || file.debugId === null || file.debugId === "" ? "" : normalizeDebugId(file.debugId);
         if (debugId === null)
             return null;
-        entries.push({ filename, debugId, hash: file.hash });
+        if (!hash && !debugId)
+            return null;
+        entries.push({ filename, debugId, hash });
     }
     return { release: input.release, entries };
 }

package/dist/stack-frames.d.ts

@@ -11,8 +11,10 @@ import type { StackFrame } from "./types.js";
  * - V8 (Node, Chrome, Edge): `at fn (file:line:col)` / `at file:line:col`
  * - Firefox / Safari: `fn@url:line:col` / `@url:line:col`
  * - Python: `File "…", line N, in fn` — tracebacks list the OUTERMOST frame
- *   first, so the frames are reversed; only the last (reported) traceback
- *   of a chained exception is used
+ *   first, so the frames are reversed; only the reported exception's own
+ *   frames are used: the last top-level block of a chained exception, and
+ *   for an exception group (3.11+) its own `| `-margined block, never its
+ *   sub-exceptions
  * - Go: function line + `\t<file>.go:<line> +0x…`, first goroutine only
  * - JVM: `at pkg.Class.method(File.java:N)`, first exception block only
  *   (before `Caused by:`)
@@ -34,6 +36,7 @@ export type FrameLanguage = "javascript" | "python" | "go" | "jvm" | "dotnet" |
  * `C:\app\node_modules\x.js` counts too. A frame with no path is in-app.
  */
 export declare function isInAppPath(path: string | null): boolean;
+export declare function isPythonStdlibPath(path: string | null): boolean;
 /**
  * Contract §3. Source-map ignore lists are applied by symbolicate.ts; the
  * language rules apply only to frames of that language, so a JS object

package/dist/stack-frames.js

@@ -11,8 +11,10 @@ import { detectStackLanguage } from "./fingerprint.js";
  * - V8 (Node, Chrome, Edge): `at fn (file:line:col)` / `at file:line:col`
  * - Firefox / Safari: `fn@url:line:col` / `@url:line:col`
  * - Python: `File "…", line N, in fn` — tracebacks list the OUTERMOST frame
- *   first, so the frames are reversed; only the last (reported) traceback
- *   of a chained exception is used
+ *   first, so the frames are reversed; only the reported exception's own
+ *   frames are used: the last top-level block of a chained exception, and
+ *   for an exception group (3.11+) its own `| `-margined block, never its
+ *   sub-exceptions
  * - Go: function line + `\t<file>.go:<line> +0x…`, first goroutine only
  * - JVM: `at pkg.Class.method(File.java:N)`, first exception block only
  *   (before `Caused by:`)
@@ -63,6 +65,22 @@ export function isInAppPath(path) {
         return false;
     return true;
 }
+/**
+ * Python's standard library: frozen modules (`<frozen runpy>`) and the
+ * version directory of an installation (`/usr/local/lib/python3.12/`,
+ * `…/Versions/3.14/lib/python3.14/`, `C:\Python312\Lib\`); a
+ * virtualenv's packages are `site-packages`, covered by the path rule. Like
+ * Go's `/usr/local/go/`, they are the runtime, not the app: an asyncio or
+ * socket error's first five frames would otherwise all be stdlib frames.
+ */
+const PY_STDLIB_RE = /\/lib\/(?:python|pypy)\d\.\d+t?\/|\/python\d{2,3}t?\/lib\//i;
+export function isPythonStdlibPath(path) {
+    if (!path)
+        return false;
+    if (path.startsWith("<frozen "))
+        return true;
+    return PY_STDLIB_RE.test(path.replace(/\\/g, "/"));
+}
 /** Fully qualified name for the language rules (`module.function`). */
 function qualifiedName(frame) {
     if (frame.module && frame.function)
@@ -84,6 +102,8 @@ export function isInAppFrame(frame, language) {
         if ((frame.filename ?? "").replace(/\\/g, "/").includes("/usr/local/go/"))
             return false;
     }
+    if (language === "python" && isPythonStdlibPath(frame.filename))
+        return false;
     if (language === "jvm" && /^(?:java|javax|kotlin|jdk)\./.test(qualified))
         return false;
     if (language === "dotnet" && /^(?:System|Microsoft)\./.test(qualified))
@@ -225,15 +245,41 @@ function parseGecko(lines) {
 // ── Python ────────────────────────────────────────────────────────────────
 const PY_FILE_RE = /^\s*File "(.+)", line (\d+)(?:, in (.+?))?\s*$/;
 const PY_TRACEBACK_RE = /^\s*Traceback \(most recent call last\):\s*$/;
+// 3.11+: an exception group prints its own frames behind a "| " margin,
+// under this header (nested groups' headers carry the margin instead of "+"),
+// then its sub-exceptions after a "+-+---- 1 ----" separator.
+const PY_GROUP_TRACEBACK_RE = /^\s*\+ Exception Group Traceback \(most recent call last\):\s*$/;
+const PY_GROUP_MARGIN_RE = /^\s*\|/;
+const PY_GROUP_SUBEXCEPTIONS_RE = /^\s*\+-/;
+function isPythonFrameLine(line) {
+    return PY_FILE_RE.test(line) || PY_FILE_RE.test(line.replace(PY_GROUP_MARGIN_RE, ""));
+}
 function parsePython(lines) {
-    // A chained exception prints one traceback per exception; the reported
-    // (final) exception's frames are the last block.
-    let start = 0;
-    for (let i = 0; i < lines.length; i++)
-        if (PY_TRACEBACK_RE.test(lines[i]))
+    // A chained exception prints one block per exception, the reported
+    // (final) one last, whether the chain says "During handling of the above
+    // exception" or "The above exception was the direct cause". Blocks of
+    // sub-exceptions and of groups in the chain carry a margin, so the last
+    // unmargined header starts the reported exception's own frames.
+    let start = -1;
+    let group = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (PY_TRACEBACK_RE.test(lines[i])) {
+            start = i;
+            group = false;
+        }
+        else if (PY_GROUP_TRACEBACK_RE.test(lines[i])) {
             start = i;
+            group = true;
+        }
+    }
     const outermostFirst = [];
-    for (const line of lines.slice(start)) {
+    for (const raw of lines.slice(start + 1)) {
+        let line = raw;
+        if (group) {
+            if (PY_GROUP_SUBEXCEPTIONS_RE.test(line))
+                break;
+            line = line.replace(PY_GROUP_MARGIN_RE, "");
+        }
         const m = PY_FILE_RE.exec(line);
         if (!m)
             continue;
@@ -391,7 +437,7 @@ export function detectFrameLanguage(lines) {
             return "dotnet";
         default:
     }
-    if (lines.some((line) => PY_FILE_RE.test(line)))
+    if (lines.some(isPythonFrameLine))
         return "python";
     if (lines.some((line) => DOTNET_BARE_RE.test(line)) &&
         !lines.some((line) => /:\d+(?::\d+)?\)?\s*$/.test(line))) {

package/dist/symbolicate.d.ts

@@ -40,6 +40,19 @@ export interface SymbolicationScope {
     /** Script URL → debug id (EI-13), when the browser sent them. */
     debugIds?: Record<string, string> | null;
 }
+/**
+ * In-app browser frames a source map could resolve, counted after
+ * symbolication (EI-27): `resolved` ones, and `unresolved` .js/.mjs/.cjs
+ * frames left as parsed (no map uploaded, no release or debug id, no
+ * mapping at that position). Frames a map moved out of the app
+ * (node_modules, ignoreList) and non-JS frames count in neither. Stored per
+ * occurrence (`in_app_frames_resolved` / `in_app_frames_unresolved`) for the
+ * EI-14 rule: over 30% unresolved means the release needs source maps.
+ */
+export declare function inAppFrameResolution(frames: readonly StackFrame[] | undefined): {
+    resolved: number;
+    unresolved: number;
+};
 /** Path-only form of a script URL — the key uploads are stored under. */
 export declare function scriptPath(filename: string): string | null;
 export interface SourceMapCacheOptions {

package/dist/symbolicate.js

@@ -5,6 +5,28 @@ import { isInAppPath, stripQueryAndHash } from "./stack-frames.js";
 const JS_FILE_RE = /\.[cm]?js$/i;
 const MAX_CONTEXT_CHARS = 300;
 const CONTEXT_LINES = 3;
+/**
+ * In-app browser frames a source map could resolve, counted after
+ * symbolication (EI-27): `resolved` ones, and `unresolved` .js/.mjs/.cjs
+ * frames left as parsed (no map uploaded, no release or debug id, no
+ * mapping at that position). Frames a map moved out of the app
+ * (node_modules, ignoreList) and non-JS frames count in neither. Stored per
+ * occurrence (`in_app_frames_resolved` / `in_app_frames_unresolved`) for the
+ * EI-14 rule: over 30% unresolved means the release needs source maps.
+ */
+export function inAppFrameResolution(frames) {
+    let resolved = 0;
+    let unresolved = 0;
+    for (const frame of frames ?? []) {
+        if (!frame.inApp)
+            continue;
+        if (frame.resolved)
+            resolved += 1;
+        else if (frame.filename && JS_FILE_RE.test(frame.filename))
+            unresolved += 1;
+    }
+    return { resolved, unresolved };
+}
 /** Path-only form of a script URL — the key uploads are stored under. */
 export function scriptPath(filename) {
     try {

package/dist/trace-dedupe.d.ts

@@ -0,0 +1,98 @@
+import type { RuntimeOccurrenceInput } from "./types.js";
+/**
+ * One error can be recorded on several spans of a trace. In a Next.js app a
+ * route handler's error is recorded by @autter/runtime-node on the request's
+ * HTTP server span AND by Next's own "executing api route" / render span
+ * (OpenTelemetry `recordException`); Express, Fastify, NestJS and gRPC
+ * instrumentations do the same, and errored ancestor spans with no event
+ * would add a stackless `HttpServerError` / `SpanError` on top. Each of
+ * those used to become its own occurrence, so one thrown error was counted
+ * two or three times. This pass, run on one export batch, keeps one
+ * occurrence per thrown error.
+ *
+ * Rule 1, duplicate recordings. Two exception occurrences are recordings of
+ * the same thrown error when ALL of these hold:
+ *   - same trace, service, environment and release (a thrown error lives in
+ *     one process);
+ *   - on DIFFERENT spans, one an ancestor of the other through parent links
+ *     present in the batch (an error propagating outward through nested
+ *     spans). Two events on one span are two recordings made on purpose (a
+ *     retry loop capturing each attempt on the request span) and are never
+ *     merged; nor are errors on sibling spans (one span per attempt);
+ *   - the same error type, or the OpenTelemetry JS `recordException`
+ *     convention: a third-party recording (no `autter.*` on its event) of an
+ *     error with a `code` reports the code as `exception.type` ("P2002",
+ *     "ECONNREFUSED"), so its type may instead equal the other's declared
+ *     `autter.error.code`, or its stack header may name the other's type;
+ *   - the same message after scrubbing and `normalizeMessage`;
+ *   - the same stack: the parsed in-app frames (function, file, line) are
+ *     equal or one list is a prefix (truncated) or suffix (captured at record
+ *     time, higher up) of the other. A side without a stack is no evidence
+ *     against; without in-app frames all frames are compared;
+ *   - recorded within DUPLICATE_WINDOW_MS of the group's latest recording.
+ * Recordings are grouped greedily in time order: each joins the eligible
+ * group (no member on its span, every member on its ancestor/descendant
+ * chain and matching it) whose latest recording is the most recent, so when
+ * every attempt of a retry loop is recorded on a child span and again on the
+ * parent, each attempt pairs with its own parent recording.
+ *
+ * The group keeps the occurrence with the most information: the one the
+ * Autter SDK recorded (`autter.*` on the event, or `autter.severity` on the
+ * span), then the one carrying runtime-next's `onRequestError` context, then
+ * the one on the span closest to the root. It keeps that occurrence's type,
+ * message, severity, time and batch position (so its deterministic id), and
+ * takes from the others what it lacks: attributes (its own win), stack,
+ * route, method, status, request id, declared error fields, fingerprint
+ * override and breadcrumbs. `autter.merged_recordings` counts the merged
+ * recordings.
+ *
+ * Rule 2, redundant status-only occurrences. A status-only `HttpServerError`
+ * / `SpanError` (an errored span without exception or failed-outcome events)
+ * is dropped when the same trace and service in this batch has an exception
+ * or failed outcome of severity error or fatal, not `autter.handled`, on an
+ * ancestor or descendant of its span: the span failed because of that
+ * error. It is kept when it is the trace's only signal, when the only
+ * errors are warnings or handled ones, or when no ancestor/descendant link
+ * is visible in the batch (sibling branches, a parent exported elsewhere).
+ *
+ * Scope: one export batch. A request's spans normally end, and are
+ * exported, together; when the exporter's timer splits them across batches,
+ * the recordings in different batches are still counted separately.
+ */
+/** Two recordings of one thrown error happen as it propagates outward:
+ * milliseconds apart, seconds at most for an error handler that awaits. */
+export declare const DUPLICATE_WINDOW_MS = 5000;
+export interface TraceSignal {
+    occurrence: RuntimeOccurrenceInput;
+    traceId: string;
+    spanId: string;
+    /** What produced it: an `exception` event, a failed `autter.outcome`
+     * event, or the span's error status alone. */
+    signal: "exception" | "outcome" | "status";
+    /** The Autter SDK recorded it: `autter.*` on the event, or
+     * `autter.severity` (captureException's marker) on the span. */
+    autterCapture: boolean;
+    /** `autter.*` attributes on the event itself. */
+    eventAutter: boolean;
+    /** runtime-next's `onRequestError` context on the span or event. */
+    nextContext: boolean;
+    /** `autter.handled` on the event: handled on purpose, not why a span failed. */
+    handled: boolean;
+}
+export interface SpanLink {
+    traceId: string;
+    spanId: string;
+    parentSpanId: string | null;
+}
+export interface DedupedSignals {
+    /** The surviving occurrences, in batch order (merged where rule 1 applied). */
+    occurrences: RuntimeOccurrenceInput[];
+    /** Input index of each survivor: its position in the batch, which its
+     * deterministic occurrence id is derived from. */
+    sourceIndexes: number[];
+    /** Input indexes each survivor stands for (itself first). */
+    members: number[][];
+}
+export declare function hasNextContext(...sources: Array<Map<string, string>>): boolean;
+export declare function hasAutterKey(attrs: Map<string, string>): boolean;
+export declare function dedupeTraceSignals(signals: TraceSignal[], spans: SpanLink[]): DedupedSignals;