@autter/otlp-ingester 1.10.0 → 1.11.0

package/README.md

@@ -121,7 +121,7 @@ Autter dashboard reads both. See [docs/COMPATIBILITY.md](../../docs/COMPATIBILIT
 | `SINK_MAX_ATTEMPTS` | `12` | Delivery attempts per batch (1–60 s backoff) |
 | `SINK_MAX_BUFFERED_BATCHES` | `1000` | Retry buffer cap; oldest drops are logged |
 | `SINK_MAX_BUFFERED_MB` | `64` | Sink retry buffer cap (memory) |
-| `SOURCE_MAP_CACHE_MB` | `64` | Memory budget (decoded size, function scope tables included) for parsed source maps used to symbolicate browser frames at ingest; least recently used maps are evicted, and a map that needs more than half of it is used without being kept |
+| `SOURCE_MAP_CACHE_MB` | `64` | Memory budget (decoded size, function scope tables included) for parsed source maps used to symbolicate browser, Node and edge frames at ingest; least recently used maps are evicted, and a map that needs more than half of it is used without being kept. The source contents of cached maps (context lines) are kept apart, one file per entry, under a budget of the same size, so they never change which maps are cached |
 | `MAX_BODY_BYTES` | `1048576` | Request body cap |
 | `LOOP_COLLAPSE_AFTER` | `10` | Identical occurrences stored per minute before the rest of the minute is collapsed into one sample with an exact count; `0` turns loop collapse off |
 | `RATE_LIMIT_PER_MINUTE` | `300` | Per-key fixed window (server keys) |

package/dist/cause-chain.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The causes of a reported exception (RF-06), for the `cause-v1`
+ * fingerprint (fingerprint-v3.ts): its direct cause first, the root cause
+ * last, each with its type and the stack text its frames are parsed from.
+ *
+ * Where the chain comes from:
+ * - JVM: the `Caused by:` blocks of the stack (top level only; a
+ *   `Suppressed:` block and the causes inside it are not part of the chain).
+ * - .NET: `Outer ---> Inner ---> Root` in the header and the frame segments
+ *   between `--- End of inner exception stack trace ---` markers, innermost
+ *   exception first.
+ * - Python: every top-level traceback block of a chained exception ("The
+ *   above exception was the direct cause…", "During handling of the above
+ *   exception…"); the first block is the root cause, the last the reported
+ *   exception.
+ * - Otherwise (JavaScript `cause`, and any SDK that sends them): the
+ *   `exception.cause.N.type` / `exception.cause.N.stacktrace` attributes
+ *   (runtime-core errorAttributes), N = 1, 2, … until one is missing.
+ *
+ * The reported exception's own frames are the ones parseStackFrames reads
+ * from the whole stack (the first JVM block, the last .NET segment, the last
+ * Python block), so a cause never repeats them. Shared parity vectors: the
+ * `causes` of stack-parse-vectors.json.
+ */
+export interface CauseText {
+    /** The cause's error type as written (`java.lang.IllegalStateException`, `TypeError`). */
+    type: string;
+    /** Its stack text (frames parse with parseStackFrames), or null when none was sent. */
+    stack: string | null;
+}
+/** The causes of an exception, nearest first; [] when it has none. */
+export declare function causeTexts(stack: string | null | undefined, attributes: Record<string, unknown> | null | undefined): CauseText[];

package/dist/cause-chain.js

@@ -0,0 +1,122 @@
+import { detectFrameLanguage } from "./stack-frames.js";
+/** The causes of an exception, nearest first; [] when it has none. */
+export function causeTexts(stack, attributes) {
+    const fromStack = stack ? stackCauses(stack) : [];
+    return fromStack.length > 0 ? fromStack : attributeCauses(attributes);
+}
+function stackCauses(stack) {
+    const lines = stack.split(/\r?\n/);
+    switch (detectFrameLanguage(lines)) {
+        case "jvm":
+            return jvmCauses(lines);
+        case "dotnet":
+            return dotnetCauses(lines);
+        case "python":
+            return pythonCauses(lines);
+        default:
+            return [];
+    }
+}
+// ── JVM ───────────────────────────────────────────────────────────────────
+const JVM_CAUSED_BY_RE = /^(\s*)Caused by:\s*([^\s:]+)/;
+function jvmCauses(lines) {
+    // The chain's "Caused by:" lines are indented no deeper than the header;
+    // those of a suppressed exception are indented one level more.
+    const header = lines.find((line) => line.trim() !== "") ?? "";
+    const indent = header.length - header.trimStart().length;
+    const starts = [];
+    lines.forEach((line, index) => {
+        const match = JVM_CAUSED_BY_RE.exec(line);
+        if (match && match[1].length <= indent)
+            starts.push({ index, type: match[2] });
+    });
+    return starts.map((start, k) => ({
+        type: start.type,
+        stack: lines.slice(start.index, starts[k + 1]?.index ?? lines.length).join("\n"),
+    }));
+}
+// ── .NET ──────────────────────────────────────────────────────────────────
+const DOTNET_FRAME_LINE_RE = /^\s*at\s/;
+const DOTNET_END_INNER_RE = /---\s*End of inner exception stack trace\s*---/i;
+function dotnetCauses(lines) {
+    const firstFrame = lines.findIndex((line) => DOTNET_FRAME_LINE_RE.test(line));
+    if (firstFrame <= 0)
+        return [];
+    // "Outer: msg ---> Inner: msg ---> Root: msg" (an arrow may start a line).
+    const types = lines
+        .slice(0, firstFrame)
+        .join("\n")
+        .split(/\s*--->\s*/)
+        .map((part) => /^\s*([^\s:]+)/.exec(part)?.[1] ?? "");
+    if (types.length < 2)
+        return [];
+    // Frame segments: the innermost exception's first, the reported one's last.
+    const segments = [[]];
+    for (const line of lines.slice(firstFrame)) {
+        if (DOTNET_END_INNER_RE.test(line))
+            segments.push([]);
+        else
+            segments[segments.length - 1].push(line);
+    }
+    const causes = [];
+    for (let k = 1; k < types.length; k++) {
+        const segment = segments[segments.length - 1 - k];
+        causes.push({ type: types[k], stack: segment && segment.length > 0 ? segment.join("\n") : null });
+    }
+    return causes;
+}
+// ── Python ────────────────────────────────────────────────────────────────
+const PY_TRACEBACK_RE = /^\s*Traceback \(most recent call last\):\s*$/;
+const PY_GROUP_TRACEBACK_RE = /^\s*\+ Exception Group Traceback \(most recent call last\):\s*$/;
+const PY_CHAIN_RE = /^(?:During handling of the above exception, another exception occurred|The above exception was the direct cause of the following exception):\s*$/;
+const PY_GROUP_MARGIN_RE = /^\s*\| ?/;
+const PY_GROUP_SUBEXCEPTIONS_RE = /^\s*\+-/;
+const PY_TYPE_RE = /^([A-Za-z_][\w.]*)(?::|\s*$)/;
+function pythonCauses(lines) {
+    const starts = [];
+    lines.forEach((line, index) => {
+        if (PY_TRACEBACK_RE.test(line))
+            starts.push({ index, group: false });
+        else if (PY_GROUP_TRACEBACK_RE.test(line))
+            starts.push({ index, group: true });
+    });
+    if (starts.length < 2)
+        return [];
+    const blocks = starts.map((start, k) => {
+        const body = lines.slice(start.index, starts[k + 1]?.index ?? lines.length);
+        return { type: pythonExceptionType(body.slice(1), start.group), stack: body.join("\n") };
+    });
+    // Printed root cause first and the reported exception last.
+    return blocks.slice(0, -1).reverse();
+}
+/** The exception line of one traceback block: its first unindented line. */
+function pythonExceptionType(body, group) {
+    for (const raw of body) {
+        let line = raw;
+        if (group) {
+            if (PY_GROUP_SUBEXCEPTIONS_RE.test(line))
+                break;
+            line = line.replace(PY_GROUP_MARGIN_RE, "");
+        }
+        if (line.trim() === "" || /^\s/.test(line))
+            continue;
+        if (PY_CHAIN_RE.test(line.trim()))
+            break;
+        return PY_TYPE_RE.exec(line)?.[1] ?? "";
+    }
+    return "";
+}
+// ── Attributes (JavaScript and any SDK that sends them) ───────────────────
+function attributeCauses(attributes) {
+    if (!attributes)
+        return [];
+    const causes = [];
+    for (let n = 1;; n++) {
+        const type = attributes[`exception.cause.${n}.type`];
+        if (typeof type !== "string")
+            break;
+        const stack = attributes[`exception.cause.${n}.stacktrace`];
+        causes.push({ type, stack: typeof stack === "string" && stack !== "" ? stack : null });
+    }
+    return causes;
+}

package/dist/clickhouse.js

@@ -1,5 +1,5 @@
 import { createClient, } from "@clickhouse/client";
-import { latencyTableDDL } from "./latency.js";
+import { latencyTableDDL, routeLatencyInputDDL, routeLatencyTableDDL, routeLatencyViewDDL, } from "./latency.js";
 import { profileTableDDL } from "./profiles.js";
 import { memoryTableDDL, platformEventTableDDL } from "./memory.js";
 import { sourceMapTableDDL } from "./source-maps.js";
@@ -24,7 +24,12 @@ const INSERT_SETTINGS = {
 /** Source maps above this go in with a plain insert (below ClickHouse's
  * default async_insert_max_data_size of 10 MiB). */
 const ASYNC_INSERT_MAX_MAP_CHARS = 8 * 1024 * 1024;
-/** Migration 0020 columns: browser occurrences only (server frames are not symbolicated). */
+/**
+ * Migration 0020 columns: browser occurrences only. Server frames are
+ * symbolicated too since RF-05, but an unresolved server `.js` frame is
+ * usually readable code (an unbundled Node app), so it would make the EI-14
+ * "needs source maps" ratio cry wolf.
+ */
 function occurrenceFrameResolution(o) {
     const counts = o.source === "browser" ? inAppFrameResolution(o.frames) : { resolved: 0, unresolved: 0 };
     return {
@@ -73,6 +78,10 @@ export class ClickHouseStore {
         return [
             `CREATE DATABASE IF NOT EXISTS ${db}`,
             latencyTableDDL(db, metricsTtlDays),
+            // Per-route p50/p95/p99 (IP-02): input, rollup, then its view.
+            routeLatencyInputDDL(db),
+            routeLatencyTableDDL(db, metricsTtlDays),
+            routeLatencyViewDDL(db),
             profileTableDDL(db),
             memoryTableDDL(db),
             platformEventTableDDL(db),
@@ -598,6 +607,26 @@ export class ClickHouseStore {
                 session_count: Math.max(0, Math.round(p.sessionCount)),
             })),
         });
+        // Their percentiles: the view folds these into runtime_route_latency_1m.
+        const latency = points.filter((p) => p.latency && p.latency.valuesMs.length > 0);
+        if (latency.length === 0)
+            return;
+        await this.getClient().insert({
+            table: this.table("runtime_route_latency_input"),
+            format: "JSONEachRow",
+            clickhouse_settings: INSERT_SETTINGS,
+            values: latency.map((p) => ({
+                org_id: ctx.orgId,
+                repository_id: ctx.repositoryId,
+                service: p.service,
+                environment: p.environment,
+                release: p.release ?? "",
+                route: p.route,
+                bucket_at: p.bucketAt.toISOString(),
+                values_ms: p.latency.valuesMs,
+                weights: p.latency.weights.map((weight) => Math.max(0, Math.round(weight))),
+            })),
+        });
     }
     async insertLatencyHistograms(ctx, points) {
         if (points.length === 0 || !this.configured)

package/dist/compat-manifest.json

@@ -177,6 +177,35 @@
             "migrations": [],
             "route": "/v1/logs",
             "sdks": { "@autter/runtime-edge": "1.3.0" }
+        },
+        {
+            "id": "caught_errors",
+            "title": "Caught errors and deliberate fallbacks recorded as handled occurrences",
+            "ingester": "1.11.0",
+            "migrations": [],
+            "sdks": { "@autter/runtime-node": "1.9.0", "@autter/runtime-edge": "1.4.0", "@autter/runtime-next": "1.9.0", "@autter/runtime-browser": "1.8.0" }
+        },
+        {
+            "id": "route_percentiles",
+            "title": "Per-route p95 and p99 latency in the 1-minute rollups",
+            "ingester": "1.11.0",
+            "migrations": ["0022-route-latency-1m"],
+            "sdks": {}
+        },
+        {
+            "id": "server_source_maps",
+            "title": "Server bundles symbolicated, with source context lines",
+            "ingester": "1.11.0",
+            "migrations": [],
+            "route": "/v1/sourcemaps",
+            "sdks": { "@autter/runtime-cli": "1.3.0", "@autter/runtime-node": "1.9.0", "@autter/runtime-edge": "1.4.0", "@autter/runtime-next": "1.9.0" }
+        },
+        {
+            "id": "cause_fingerprint",
+            "title": "Wrapped errors grouped with their root cause (cause-v1)",
+            "ingester": "1.11.0",
+            "migrations": [],
+            "sdks": { "@autter/runtime-node": "1.9.0", "@autter/runtime-edge": "1.4.0", "@autter/runtime-next": "1.9.0" }
         }
     ]
 }

package/dist/fingerprint-v3.d.ts

@@ -30,25 +30,81 @@ export interface FramesV3Result {
     record: FingerprintRecord;
 }
 export declare function framesV3Fingerprint(input: FramesV3Input): FramesV3Result;
+/**
+ * `cause-v1` — the root-cause identity (RF-06). Byte-for-byte shared with
+ * the platform mirror (`runtime-frames-fingerprint.ts`); the `cause` of the
+ * entries in fingerprint-v3-vectors.json pins both.
+ *
+ * It hashes service + the root cause's error type + ONE frame: the
+ * innermost in-app frame across the cause chain, looked for from the root
+ * cause outward (the root's own innermost in-app frame when it has one,
+ * else its nearest wrapper's, …). So `new Error("checkout failed", { cause:
+ * fetchError })` and the unwrapped `TypeError: fetch failed` hash alike, as
+ * do JVM `Caused by:` chains, .NET inner exceptions and Python chained
+ * exceptions with their root. An error without a cause is its own root, so
+ * the raw form carries the same candidate. No in-app frame anywhere in the
+ * chain: no candidate.
+ *
+ * It is a lookup candidate only: frames-v3 stays the identity issues are
+ * created under (see occurrenceIdentity), and frames-v3 itself is unchanged,
+ * so no existing issue regroups.
+ */
+export declare const CAUSE_V1 = "cause-v1";
+/** One exception of a chain: its error type and frames, innermost first. */
+export interface CauseLink {
+    type: string;
+    frames: StackFrame[];
+}
+export interface CauseV1Input {
+    service: string;
+    /** The reported exception first, then its cause, …, the root cause last. */
+    chain: CauseLink[];
+}
+/**
+ * The type half of cause-v1: the last segment of a qualified name, so the
+ * same class written `java.lang.IllegalStateException` in a JVM `Caused by:`
+ * line and in `exception.type`, or `requests.exceptions.ConnectionError` in a
+ * Python traceback and `ConnectionError` in OTel's `exception.type`, match.
+ */
+export declare function causeTypeToken(type: string): string;
+export declare function causeV1Fingerprint(input: CauseV1Input): FramesV3Result | null;
+/** The causes of an occurrence with their frames as parsed (not symbolicated). */
+export declare function parsedCauseLinks(input: Pick<RuntimeOccurrenceInput, "stack" | "attributes">): CauseLink[];
 export interface OccurrenceIdentity {
     /** Legacy identity, unchanged: what `fingerprint`/`fingerprintScheme` carry. */
     legacy: {
         fingerprint: string;
         scheme: "message-v1" | "code-v1";
     };
-    /** Every applicable scheme, highest precedence first; ends with the legacy one. */
+    /** Every applicable scheme, in precedence order (see occurrenceIdentity). */
     candidates: FingerprintCandidate[];
     /** What went into the frames-v3 fingerprint, when one was computed. */
     record: FingerprintRecord | null;
+    /** What went into the cause-v1 fingerprint, when one was computed. */
+    causeRecord: FingerprintRecord | null;
 }
 /**
- * The candidate list the sink carries (contract §1/§4), highest precedence
- * first:
+ * The candidate list the sink carries (contract §1/§4), in precedence order:
  *   manual-v1 (SDK override) → code-v1 (valid error code) → frames-v3 →
- *   message-v1 (legacy).
+ *   message-v1 (legacy) → cause-v1 (RF-06).
  * A coded error's legacy identity IS code-v1, which outranks every auto
  * scheme, so its list is [manual-v1?, code-v1]; an uncoded one is
- * [manual-v1?, frames-v3, message-v1]. Either way the list ends with the
- * legacy fingerprint, so the platform can always fall back to it.
+ * [manual-v1?, frames-v3, message-v1, cause-v1?].
+ *
+ * The consumer takes, among the auto schemes, the first one that already
+ * has an issue, else creates the issue under the highest. cause-v1 comes
+ * after every existing scheme, so an occurrence of an issue that already
+ * exists keeps finding it by frames-v3 or message-v1 first and nothing
+ * regroups; cause-v1 is only reached when neither has an issue — which, for
+ * a wrapped error whose root cause already has an issue, is exactly when it
+ * should join that issue. (Issues are still created under frames-v3: the
+ * platform must also key new issues by their cause-v1 fingerprint, or merge
+ * it as an alias, for that lookup to find anything. Until it does, cause-v1
+ * is carried in shadow and changes no grouping.) The legacy fingerprint is
+ * still always in the list, so the platform can fall back to it.
+ *
+ * `causes` are the reported exception's causes with their (symbolicated)
+ * frames, nearest first; omitted, they are read from the stack and
+ * attributes and parsed without symbolication.
  */
-export declare function occurrenceIdentity(input: RuntimeOccurrenceInput, frames: StackFrame[]): OccurrenceIdentity;
+export declare function occurrenceIdentity(input: RuntimeOccurrenceInput, frames: StackFrame[], causes?: CauseLink[]): OccurrenceIdentity;

package/dist/fingerprint-v3.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
+import { causeTexts } from "./cause-chain.js";
 import { normalizeMessage, occurrenceFingerprint } from "./fingerprint.js";
 import { manualFingerprint } from "./fingerprint-override.js";
+import { parseStackFrames } from "./stack-frames.js";
 /**
  * `frames-v3` — the structural issue identity (contract §2). Byte-for-byte
  * shared with the platform mirror (`runtime-frames-fingerprint.ts`); the
@@ -61,23 +63,102 @@ export function framesV3Fingerprint(input) {
         },
     };
 }
+// ── cause-v1: a wrapped error groups with its root cause (RF-06) ──────────
 /**
- * The candidate list the sink carries (contract §1/§4), highest precedence
- * first:
+ * `cause-v1` — the root-cause identity (RF-06). Byte-for-byte shared with
+ * the platform mirror (`runtime-frames-fingerprint.ts`); the `cause` of the
+ * entries in fingerprint-v3-vectors.json pins both.
+ *
+ * It hashes service + the root cause's error type + ONE frame: the
+ * innermost in-app frame across the cause chain, looked for from the root
+ * cause outward (the root's own innermost in-app frame when it has one,
+ * else its nearest wrapper's, …). So `new Error("checkout failed", { cause:
+ * fetchError })` and the unwrapped `TypeError: fetch failed` hash alike, as
+ * do JVM `Caused by:` chains, .NET inner exceptions and Python chained
+ * exceptions with their root. An error without a cause is its own root, so
+ * the raw form carries the same candidate. No in-app frame anywhere in the
+ * chain: no candidate.
+ *
+ * It is a lookup candidate only: frames-v3 stays the identity issues are
+ * created under (see occurrenceIdentity), and frames-v3 itself is unchanged,
+ * so no existing issue regroups.
+ */
+export const CAUSE_V1 = "cause-v1";
+/**
+ * The type half of cause-v1: the last segment of a qualified name, so the
+ * same class written `java.lang.IllegalStateException` in a JVM `Caused by:`
+ * line and in `exception.type`, or `requests.exceptions.ConnectionError` in a
+ * Python traceback and `ConnectionError` in OTel's `exception.type`, match.
+ */
+export function causeTypeToken(type) {
+    const segments = type.trim().split(/::|\./);
+    return segments[segments.length - 1] ?? "";
+}
+export function causeV1Fingerprint(input) {
+    const root = input.chain[input.chain.length - 1];
+    if (!root)
+        return null;
+    let token = "";
+    for (let i = input.chain.length - 1; i >= 0 && !token; i--) {
+        for (const frame of input.chain[i].frames) {
+            if (frame.inApp !== true)
+                continue;
+            const candidate = frameToken(frame);
+            // A frame with neither a function nor a file says nothing.
+            if (candidate !== "@") {
+                token = candidate;
+                break;
+            }
+        }
+    }
+    if (!token)
+        return null;
+    const type = causeTypeToken(root.type);
+    const fingerprint = createHash("sha256")
+        .update([CAUSE_V1, input.service, type, token].join("\u0000"))
+        .digest("hex")
+        .slice(0, 32);
+    return { fingerprint, record: { scheme: CAUSE_V1, parts: [type, token].filter((part) => part !== "") } };
+}
+/** The causes of an occurrence with their frames as parsed (not symbolicated). */
+export function parsedCauseLinks(input) {
+    return causeTexts(input.stack, input.attributes).map((cause) => ({
+        type: cause.type,
+        frames: parseStackFrames(cause.stack),
+    }));
+}
+/**
+ * The candidate list the sink carries (contract §1/§4), in precedence order:
  *   manual-v1 (SDK override) → code-v1 (valid error code) → frames-v3 →
- *   message-v1 (legacy).
+ *   message-v1 (legacy) → cause-v1 (RF-06).
  * A coded error's legacy identity IS code-v1, which outranks every auto
  * scheme, so its list is [manual-v1?, code-v1]; an uncoded one is
- * [manual-v1?, frames-v3, message-v1]. Either way the list ends with the
- * legacy fingerprint, so the platform can always fall back to it.
+ * [manual-v1?, frames-v3, message-v1, cause-v1?].
+ *
+ * The consumer takes, among the auto schemes, the first one that already
+ * has an issue, else creates the issue under the highest. cause-v1 comes
+ * after every existing scheme, so an occurrence of an issue that already
+ * exists keeps finding it by frames-v3 or message-v1 first and nothing
+ * regroups; cause-v1 is only reached when neither has an issue — which, for
+ * a wrapped error whose root cause already has an issue, is exactly when it
+ * should join that issue. (Issues are still created under frames-v3: the
+ * platform must also key new issues by their cause-v1 fingerprint, or merge
+ * it as an alias, for that lookup to find anything. Until it does, cause-v1
+ * is carried in shadow and changes no grouping.) The legacy fingerprint is
+ * still always in the list, so the platform can fall back to it.
+ *
+ * `causes` are the reported exception's causes with their (symbolicated)
+ * frames, nearest first; omitted, they are read from the stack and
+ * attributes and parsed without symbolication.
  */
-export function occurrenceIdentity(input, frames) {
+export function occurrenceIdentity(input, frames, causes) {
     const legacy = occurrenceFingerprint(input);
     const candidates = [];
     const manual = manualFingerprint(input);
     if (manual)
         candidates.push({ scheme: "manual-v1", fingerprint: manual });
     let record = null;
+    let causeRecord = null;
     if (legacy.scheme === "code-v1") {
         candidates.push({ scheme: "code-v1", fingerprint: legacy.fingerprint });
     }
@@ -91,6 +172,14 @@ export function occurrenceIdentity(input, frames) {
         record = v3.record;
         candidates.push({ scheme: FRAMES_V3, fingerprint: v3.fingerprint });
         candidates.push({ scheme: "message-v1", fingerprint: legacy.fingerprint });
+        const cause = causeV1Fingerprint({
+            service: input.service,
+            chain: [{ type: input.errorType, frames }, ...(causes ?? parsedCauseLinks(input))],
+        });
+        if (cause) {
+            causeRecord = cause.record;
+            candidates.push({ scheme: CAUSE_V1, fingerprint: cause.fingerprint });
+        }
     }
-    return { legacy, candidates, record };
+    return { legacy, candidates, record, causeRecord };
 }

package/dist/ingest-drops.d.ts

@@ -25,6 +25,9 @@ import type { IngestContext } from "./types.js";
  *   (loop-collapse.ts); its payload was not stored, its count is, on the
  *   minute's collapsed sample (`collapsed_count`). `records` counts payloads
  *   not stored.
+ *   `caught_limited` (1.11.0) is the same kind, counted by the SDK: caught
+ *   errors and deliberate fallbacks its burst limit left out, whose count
+ *   rides on the next record of their kind (`autter.caught.dropped`).
  * - `suppressed`: occurrences a suppression rule set by the user dropped or
  *   sampled out (suppression.ts).
  *
@@ -163,6 +166,10 @@ export declare const DROP_REASONS: {
     readonly collapsed: {
         readonly kind: "collapsed";
     };
+    /** Caught errors / deliberate fallbacks an SDK's burst limit left out (`autter.caught.dropped` on the next record of their kind). */
+    readonly caught_limited: {
+        readonly kind: "collapsed";
+    };
     /** Occurrences a `drop` rule matched, or a `sample` rule sampled out. */
     readonly suppressed: {
         readonly kind: "suppressed";
@@ -185,6 +192,9 @@ export declare function dropStatus(reason: DropReason, route: DropRoute): number
  * password in the wrong field) is never hashed or stored.
  */
 export declare function autterKeyHash(key: string): string;
+/** Records an SDK's burst limit left out, from the `autter.caught.dropped`
+ * the records it did send carry (`caught_limited`). */
+export declare function caughtLimitedRecords(attributes: Array<Record<string, unknown> | null | undefined>): number;
 /**
  * Count the length-delimited fields at a nested path of field numbers
  * (one set per level) without decoding the message: tags are read and

package/dist/ingest-drops.js

@@ -59,6 +59,8 @@ export const DROP_REASONS = {
     // ── collapsed: counted on the minute's sample, payload not stored (1.9.0) ──
     /** Occurrences of a looping error past the first LOOP_COLLAPSE_AFTER of the minute. */
     collapsed: { kind: "collapsed" },
+    /** Caught errors / deliberate fallbacks an SDK's burst limit left out (`autter.caught.dropped` on the next record of their kind). */
+    caught_limited: { kind: "collapsed" },
     // ── suppressed: a suppression rule set by the user left them out (1.9.0) ──
     /** Occurrences a `drop` rule matched, or a `sample` rule sampled out. */
     suppressed: { kind: "suppressed" },
@@ -113,6 +115,17 @@ function countJson(root, path) {
     return level.reduce((sum, node) => sum + arr(field(node, last)).length, 0);
 }
 const METRIC_KINDS = ["gauge", "sum", "histogram", "exponentialHistogram", "summary"];
+/** Records an SDK's burst limit left out, from the `autter.caught.dropped`
+ * the records it did send carry (`caught_limited`). */
+export function caughtLimitedRecords(attributes) {
+    let total = 0;
+    for (const attrs of attributes) {
+        const value = Number(attrs?.["autter.caught.dropped"]);
+        if (Number.isSafeInteger(value) && value > 0)
+            total += Math.min(value, 1_000_000);
+    }
+    return total;
+}
 function countJsonDataPoints(root) {
     let points = 0;
     for (const resource of arr(field(root, "resourceMetrics")))

package/dist/latency.d.ts

@@ -13,5 +13,47 @@ export interface LatencyHistogram {
     boundsMs: number[];
     counts: number[];
 }
+/**
+ * Per-route latency percentiles in the 1-minute rollups (IP-02).
+ *
+ * `runtime_metrics_1m` is a SummingMergeTree with an explicit column list,
+ * so no percentile can be merged there. Every rollup point also carries
+ * latency samples (`RuntimeMetricPoint.latency`): a request's own duration
+ * (span- and summary-fed requests) or a delta histogram's buckets
+ * (metric-fed), spread evenly over each bucket. They are written to
+ * `runtime_route_latency_input` (ENGINE = Null: nothing is stored), whose
+ * materialized view folds them into `runtime_route_latency_1m`, keyed like
+ * `runtime_metrics_1m`, as a mergeable t-digest:
+ *
+ *   SELECT route, sum(request_count) AS requests,
+ *          quantilesTDigestWeightedMerge(0.5, 0.95, 0.99)(duration_quantiles) AS q
+ *   FROM runtime_route_latency_1m
+ *   WHERE org_id = … AND repository_id = … AND bucket_at >= now() - INTERVAL 1 HOUR
+ *   GROUP BY route            -- q[1] p50, q[2] p95, q[3] p99, in ms
+ *
+ * Any window and grouping merge exactly as the t-digest does. Like
+ * `runtime_metrics_1m`, an exporter retry after a lost 2xx counts twice.
+ */
+export interface LatencySamples {
+    /** Durations in ms… */
+    valuesMs: number[];
+    /** …and how many requests each stands for. */
+    weights: number[];
+}
+/**
+ * Samples for a delta histogram: each bucket's count spread evenly over
+ * [previous bound, bound] (at most 8 points), the overflow bucket at the
+ * highest bound. Undefined for a histogram without usable buckets.
+ */
+export declare function histogramLatency(boundsMs: readonly number[], counts: readonly number[]): LatencySamples | undefined;
+/** One request's duration as samples. */
+export declare function requestLatency(durationMs: number): LatencySamples | undefined;
+/** Concatenate samples of points folded into one rollup row. */
+export declare function mergeLatency(a: LatencySamples | undefined, b: LatencySamples | undefined): LatencySamples | undefined;
+/** Null input table: rows pass to the view, nothing is stored. */
+export declare function routeLatencyInputDDL(database: string): string;
+export declare function routeLatencyTableDDL(database: string, ttlDays?: number): string;
+/** Needs both tables above; reads nothing older than itself. */
+export declare function routeLatencyViewDDL(database: string): string;
 export declare function latencyTableDDL(database: string, ttlDays?: number): string;
 export declare function normalizeLatencyHistograms(request: OtlpMetricsRequest): LatencyHistogram[];