@autter/otlp-ingester 1.10.0 → 1.11.0

package/dist/latency.js

@@ -1,5 +1,85 @@
 import { createHash } from "node:crypto";
 import { normalizeRoute } from "./fingerprint.js";
+/** Points one histogram bucket is spread over (uniform within the bucket). */
+const BUCKET_SPREAD = 8;
+/**
+ * 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 function histogramLatency(boundsMs, counts) {
+    if (boundsMs.length === 0 || boundsMs.length > 256 || counts.length !== boundsMs.length + 1)
+        return undefined;
+    if (boundsMs.some((bound, i) => !Number.isFinite(bound) || bound < 0 || (i > 0 && bound <= boundsMs[i - 1])))
+        return undefined;
+    if (counts.some((count) => !Number.isSafeInteger(count) || count < 0))
+        return undefined;
+    const valuesMs = [];
+    const weights = [];
+    counts.forEach((count, i) => {
+        if (count === 0)
+            return;
+        const lower = i === 0 ? 0 : boundsMs[i - 1];
+        if (i === boundsMs.length) {
+            valuesMs.push(lower);
+            weights.push(count);
+            return;
+        }
+        const upper = boundsMs[i];
+        const points = Math.min(count, BUCKET_SPREAD);
+        const base = Math.floor(count / points);
+        for (let j = 0; j < points; j++) {
+            valuesMs.push(lower + ((upper - lower) * (j + 0.5)) / points);
+            weights.push(base + (j < count - base * points ? 1 : 0));
+        }
+    });
+    return valuesMs.length ? { valuesMs, weights } : undefined;
+}
+/** One request's duration as samples. */
+export function requestLatency(durationMs) {
+    return Number.isFinite(durationMs) && durationMs >= 0 ? { valuesMs: [durationMs], weights: [1] } : undefined;
+}
+/** Concatenate samples of points folded into one rollup row. */
+export function mergeLatency(a, b) {
+    if (!a)
+        return b && { valuesMs: [...b.valuesMs], weights: [...b.weights] };
+    if (b) {
+        a.valuesMs.push(...b.valuesMs);
+        a.weights.push(...b.weights);
+    }
+    return a;
+}
+/** Null input table: rows pass to the view, nothing is stored. */
+export function routeLatencyInputDDL(database) {
+    return `CREATE TABLE IF NOT EXISTS ${database}.runtime_route_latency_input (
+		org_id String, repository_id String, service String, environment String,
+		release String, route String, bucket_at DateTime('UTC'),
+		values_ms Array(Float64), weights Array(UInt64)
+	) ENGINE = Null`;
+}
+export function routeLatencyTableDDL(database, ttlDays = 90) {
+    return `CREATE TABLE IF NOT EXISTS ${database}.runtime_route_latency_1m (
+		org_id String, repository_id String,
+		service LowCardinality(String), environment LowCardinality(String),
+		release String DEFAULT '', route String DEFAULT '', bucket_at DateTime('UTC'),
+		request_count SimpleAggregateFunction(sum, UInt64),
+		duration_quantiles AggregateFunction(quantilesTDigestWeighted(0.5, 0.95, 0.99), Float64, UInt64)
+	) ENGINE = AggregatingMergeTree PARTITION BY toYYYYMM(bucket_at)
+	ORDER BY (org_id, repository_id, service, environment, release, route, bucket_at)
+	TTL bucket_at + INTERVAL ${Math.max(1, Math.round(ttlDays))} DAY`;
+}
+/** Needs both tables above; reads nothing older than itself. */
+export function routeLatencyViewDDL(database) {
+    return `CREATE MATERIALIZED VIEW IF NOT EXISTS ${database}.runtime_route_latency_1m_mv
+	TO ${database}.runtime_route_latency_1m AS
+	SELECT
+		org_id, repository_id, service, environment, release, route, bucket_at,
+		sum(weight) AS request_count,
+		quantilesTDigestWeightedState(0.5, 0.95, 0.99)(value_ms, weight) AS duration_quantiles
+	FROM ${database}.runtime_route_latency_input
+	ARRAY JOIN values_ms AS value_ms, weights AS weight
+	GROUP BY org_id, repository_id, service, environment, release, route, bucket_at`;
+}
 export function latencyTableDDL(database, ttlDays = 30) {
     return `CREATE TABLE IF NOT EXISTS ${database}.runtime_latency_histograms (
 		org_id String, repository_id String, point_id String,

package/dist/log-promotion.js

@@ -1,4 +1,5 @@
 import { normalizeRoute } from "./fingerprint.js";
+import { mergeLatency, requestLatency } from "./latency.js";
 /**
  * Log promotion — errors from SDKs running WITHOUT a trace pipeline.
  *
@@ -96,6 +97,10 @@ export const COUNTED_BY_ATTRIBUTE = "autter.request.counted_by";
 /** On a counted summary: an error of the request was reported (an
  * `autter.capture.mode = "log"` record), which makes it a failed request. */
 export const ERROR_REPORTED_ATTRIBUTE = "autter.request.error_reported";
+function withLatency(durationMs) {
+    const latency = requestLatency(durationMs);
+    return latency ? { latency } : {};
+}
 export function countedBySummary(attributes) {
     return attributes?.[COUNTED_BY_ATTRIBUTE] === "summary";
 }
@@ -130,9 +135,14 @@ export function logRollups(rows, promoted) {
             existing.requestCount += rest.requestCount;
             existing.errorCount += rest.errorCount;
             existing.durationSumMs += rest.durationSumMs;
+            const latency = mergeLatency(existing.latency, rest.latency);
+            if (latency)
+                existing.latency = latency;
             return;
         }
-        rollups.set(key, { ...rest, bucketAt, sessionCount: 0 });
+        const { latency, ...counts } = rest;
+        const copy = mergeLatency(undefined, latency);
+        rollups.set(key, { ...counts, bucketAt, sessionCount: 0, ...(copy ? { latency: copy } : {}) });
     };
     for (const row of rows) {
         if (row.kind !== "request" || !countedBySummary(row.attributes))
@@ -150,9 +160,18 @@ export function logRollups(rows, promoted) {
             requestCount: 1,
             errorCount: failed ? 1 : 0,
             durationSumMs: row.durationMs,
+            ...withLatency(row.durationMs),
         });
     }
     for (const occ of promoted) {
+        // A caught error or deliberate fallback is an occurrence, never a
+        // counted failure. (A deliberate fallback is a warning and is already
+        // excluded above; a caught error is kept out here.)
+        if (occ.severity !== "error" && occ.severity !== "fatal")
+            continue;
+        const handling = occ.attributes?.["autter.handling"];
+        if (handling === "caught" || handling === "deliberate")
+            continue;
         // Its request's summary counts this failure.
         if (countedBySummary(occ.attributes))
             continue;

package/dist/logs.d.ts

@@ -33,9 +33,9 @@ export interface RuntimeLogRecord {
     aiCalls: number;
     /**
      * Not persisted on runtime_logs. Set for logger-only/edge error records
-     * (`autter.capture.mode = "log"`, severity ≥ error, `exception.*`
-     * present): the occurrence /v1/logs promotes into issue grouping —
-     * see log-promotion.ts.
+     * (`autter.capture.mode = "log"`, severity ≥ error, or a handled warning
+     * such as `runtimeContext.degraded`, with `exception.*` present): the
+     * occurrence /v1/logs promotes into issue grouping — see log-promotion.ts.
      */
     occurrence?: RuntimeOccurrenceInput;
 }

package/dist/logs.js

@@ -3,6 +3,7 @@ import { decodeOtlpAttributes, sanitizeRuntimeContext, } from "./context.js";
 import { declaredLink, liftErrorFields } from "./error-fields.js";
 import { fingerprintOverrideOf } from "./fingerprint-override.js";
 import { normalizeRoute } from "./fingerprint.js";
+import { DEBUG_IDS_ATTRIBUTE, serverDebugIds, withoutDebugIdsAttribute } from "./source-maps.js";
 /**
  * Log records one request may carry. From 1.8.0 the ones past it are
  * rejected on their own (counted in `stats.overLimit`, answered in the OTLP
@@ -52,11 +53,15 @@ export function normalizeLogs(request, stats) {
                     !Array.isArray(decodedBody))
                     event = sanitizeRuntimeContext(decodedBody);
                 const metadata = Object.fromEntries(Object.entries(attrs).filter(([key]) => /^autter\.(?:operation|event)\./.test(key)));
-                const attributes = sanitizeRuntimeContext({
+                // Server SDKs (runtime-core errorAttributes): the debug ids of the bundles in the
+                // exception's stack (RF-05) locate their source maps; read raw
+                // (the sanitiser cuts long keys) and not kept.
+                const { [DEBUG_IDS_ATTRIBUTE]: rawDebugIds, ...plainAttrs } = attrs;
+                const attributes = withoutDebugIdsAttribute(sanitizeRuntimeContext({
                     ...metadata,
                     ...event,
-                    ...attrs,
-                });
+                    ...plainAttrs,
+                }));
                 const nanos = record.timeUnixNano ?? record.observedTimeUnixNano;
                 const occurredAt = nanos === undefined
                     ? new Date()
@@ -113,8 +118,11 @@ export function normalizeLogs(request, stats) {
                 const aiRollup = ai && typeof ai === "object" && !Array.isArray(ai)
                     ? ai
                     : {};
+                // Warnings too when handled: `runtimeContext.degraded` (a
+                // deliberate fallback) is recorded at warning severity.
                 const occurrence = attributes["autter.capture.mode"] === "log" &&
-                    (severity === "error" || severity === "fatal") &&
+                    (severity === "error" || severity === "fatal" ||
+                        (severity === "warning" && attributes["autter.handled"] === true)) &&
                     hasException(attributes)
                     ? {
                         source: "server",
@@ -138,6 +146,7 @@ export function normalizeLogs(request, stats) {
                         occurredAt,
                         ...declared,
                         ...fingerprintOverrideOf(attributes["autter.fingerprint"]),
+                        ...serverDebugIds(rawDebugIds),
                     }
                     : undefined;
                 rows.push({

package/dist/migrations.d.ts

@@ -39,8 +39,9 @@ export declare const OCCURRENCE_REQUEST_ID_INDEX = "INDEX idx_occ_request_id req
  * Migration 0016 columns — shared with the baseline DDL in clickhouse.ts.
  * `frames`: the structured (symbolicated) frames as JSON, '' when none.
  * `fingerprints`: every identity candidate (manual-v1, code-v1, frames-v3,
- * message-v1 — highest precedence first, ending with the legacy one), so
- * readers find an issue keyed by ANY scheme with
+ * message-v1 — highest precedence first, ending with the legacy one — then
+ * cause-v1 when computed, RF-06), so readers find an issue keyed by ANY
+ * scheme with
  * `(fingerprint = X OR has(fingerprints, X))`; rows written before 0016
  * read `[]` and still match on the legacy `fingerprint`.
  */

package/dist/migrations.js

@@ -32,7 +32,7 @@
  *     ],
  *   },
  */
-import { latencyTableDDL } from "./latency.js";
+import { latencyTableDDL, routeLatencyInputDDL, routeLatencyTableDDL, routeLatencyViewDDL, } from "./latency.js";
 import { profileTableDDL } from "./profiles.js";
 import { SOURCE_MAP_DEBUG_COLUMNS, SOURCE_MAP_DEBUG_ID_INDEX, sourceMapTableDDL, } from "./source-maps.js";
 import { LOG_REQUEST_COLUMNS, LOG_REQUEST_ID_INDEX, logTableDDL, requestRollupTableDDL, requestRollupViewDDL, } from "./logs.js";
@@ -54,8 +54,9 @@ export const OCCURRENCE_REQUEST_ID_INDEX = "INDEX idx_occ_request_id request_id
  * Migration 0016 columns — shared with the baseline DDL in clickhouse.ts.
  * `frames`: the structured (symbolicated) frames as JSON, '' when none.
  * `fingerprints`: every identity candidate (manual-v1, code-v1, frames-v3,
- * message-v1 — highest precedence first, ending with the legacy one), so
- * readers find an issue keyed by ANY scheme with
+ * message-v1 — highest precedence first, ending with the legacy one — then
+ * cause-v1 when computed, RF-06), so readers find an issue keyed by ANY
+ * scheme with
  * `(fingerprint = X OR has(fingerprints, X))`; rows written before 0016
  * read `[]` and still match on the legacy `fingerprint`.
  */
@@ -247,6 +248,14 @@ export const MIGRATIONS = [
         id: "0021-occurrence-collapsed-count",
         statements: OCCURRENCE_COLLAPSE_COLUMNS.map((column) => `ALTER TABLE {db}.runtime_error_occurrences ADD COLUMN IF NOT EXISTS ${column}`),
     },
+    // Per-route p50/p95/p99 in the 1-minute rollups (IP-02, latency.ts): a
+    // Null input table the ingester writes latency samples to, the
+    // AggregatingMergeTree keyed like runtime_metrics_1m, and the view between
+    // them. Additive: runtime_metrics_1m and its readers are unchanged.
+    {
+        id: "0022-route-latency-1m",
+        statements: [routeLatencyInputDDL("{db}"), routeLatencyTableDDL("{db}"), routeLatencyViewDDL("{db}")],
+    },
 ];
 /** The tracking table itself — created by the runner before anything else. */
 export function migrationsTableDDL(db) {

package/dist/normalize-browser.d.ts

@@ -53,38 +53,38 @@ export declare const browserPayloadSchema: z.ZodObject<{
         timestamp: string;
         breadcrumbs?: unknown[] | undefined;
         route?: string | undefined;
-        errorType?: string | undefined;
-        id?: string | undefined;
         severity?: "info" | "warning" | "error" | "fatal" | undefined;
+        errorType?: string | undefined;
         stack?: string | undefined;
         traceId?: string | undefined;
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        id?: string | undefined;
         name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
+        context?: Record<string, unknown> | undefined;
     }, {
         type: "request_failure" | "timing" | "outcome" | "csp_violation" | "message" | "exception" | "unhandled_rejection" | "session_start" | "track_event";
         timestamp: string;
         breadcrumbs?: unknown;
         route?: string | undefined;
         message?: string | undefined;
-        errorType?: string | undefined;
-        id?: string | undefined;
         severity?: "info" | "warning" | "error" | "fatal" | undefined;
+        errorType?: string | undefined;
         stack?: string | undefined;
         traceId?: unknown;
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        id?: string | undefined;
         name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
+        context?: Record<string, unknown> | undefined;
     }>, "many">;
     version: z.ZodLiteral<1>;
     sessionId: z.ZodOptional<z.ZodString>;
@@ -103,19 +103,19 @@ export declare const browserPayloadSchema: z.ZodObject<{
         timestamp: string;
         breadcrumbs?: unknown[] | undefined;
         route?: string | undefined;
-        errorType?: string | undefined;
-        id?: string | undefined;
         severity?: "info" | "warning" | "error" | "fatal" | undefined;
+        errorType?: string | undefined;
         stack?: string | undefined;
         traceId?: string | undefined;
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        id?: string | undefined;
         name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
+        context?: Record<string, unknown> | undefined;
     }[];
     release?: string | undefined;
     sessionId?: string | undefined;
@@ -130,19 +130,19 @@ export declare const browserPayloadSchema: z.ZodObject<{
         breadcrumbs?: unknown;
         route?: string | undefined;
         message?: string | undefined;
-        errorType?: string | undefined;
-        id?: string | undefined;
         severity?: "info" | "warning" | "error" | "fatal" | undefined;
+        errorType?: string | undefined;
         stack?: string | undefined;
         traceId?: unknown;
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        id?: string | undefined;
         name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
+        context?: Record<string, unknown> | undefined;
     }[];
     release?: string | undefined;
     sessionId?: string | undefined;

package/dist/normalize-browser.js

@@ -201,11 +201,17 @@ export function normalizeBrowserPayload(payload) {
             continue;
         }
         const severity = asSeverity(event.severity, TYPE_TO_SEVERITY[event.type] ?? "error");
+        const context = event.context ? scrubContext(event.context) : undefined;
+        // runtime-browser 1.8.0 sends an Error passed to `console.error` with
+        // the log line as `autter.log.message` only (its bundle is size-capped):
+        // mark it the way the server SDKs mark a caught error.
+        const logged = event.type === "exception" && typeof context?.["autter.log.message"] === "string";
         // A browser error belongs to no server request: it counts in
         // `error_count` only (fatal/error severity), never `request_count`,
         // so a page that only reports errors still shows them without
-        // inventing requests. Warnings and info messages count nothing.
-        if (severity === "fatal" || severity === "error") {
+        // inventing requests. A handled (caught) error is an occurrence but
+        // no counted failure; warnings and info count nothing.
+        if ((severity === "fatal" || severity === "error") && !logged) {
             bumpRollup(event.route ? (event.route.split("?")[0] ?? "") : "", occurredAt, { errorCount: 1 });
         }
         occurrences.push({
@@ -228,7 +234,15 @@ export function normalizeBrowserPayload(payload) {
                 ...(event.filename ? { filename: event.filename.split("?")[0] } : {}),
                 ...(event.line !== undefined ? { line: event.line } : {}),
                 ...(event.column !== undefined ? { column: event.column } : {}),
-                ...(event.context ? { context: scrubContext(event.context) } : {}),
+                ...(context ? { context } : {}),
+                ...(logged
+                    ? {
+                        "autter.handled": true,
+                        "autter.handling": "caught",
+                        "autter.log.source": typeof context?.["autter.log.source"] === "string" ? context["autter.log.source"] : "console",
+                        "autter.log.message": context?.["autter.log.message"],
+                    }
+                    : {}),
             },
             occurredAt,
             ...liftErrorFields(event.context),

package/dist/normalize-otlp.js

@@ -7,6 +7,8 @@ import { extractLlmCall } from "./llm.js";
 import { BREADCRUMBS_ATTRIBUTE, breadcrumbsField } from "./breadcrumbs.js";
 import { dedupeTraceSignals, hasAutterKey, hasNextContext } from "./trace-dedupe.js";
 import { requestMembership } from "./request-spans.js";
+import { DEBUG_IDS_ATTRIBUTE, serverDebugIds, withoutDebugIdsAttribute } from "./source-maps.js";
+import { histogramLatency, mergeLatency, requestLatency } from "./latency.js";
 import { asSeverity, } from "./types.js";
 const EMAIL_VALUE_RE = /[A-Z0-9._%+-]{1,64}@[A-Z0-9.-]{1,253}\.[A-Z]{2,63}/gi;
 function attrMap(attributes) {
@@ -40,6 +42,17 @@ function spanDurationMs(span) {
 function isErrorStatus(code) {
     return code === 2 || code === "STATUS_CODE_ERROR";
 }
+/**
+ * An error the app handled on purpose and recorded through Autter: a caught
+ * error (`autter.handling = "caught"`, RF-01) or a deliberate fallback
+ * (`"deliberate"`, RF-02). These are occurrences and issues, but they never
+ * fail their span or request and never count in `error_count`. The bare
+ * `autter.handled` marker (the opt-in V8 sampler) keeps its old meaning and
+ * still counts.
+ */
+function softlyHandled(handling) {
+    return handling === "caught" || handling === "deliberate";
+}
 const SPAN_KINDS = {
     "0": "unspecified",
     "1": "internal",
@@ -137,8 +150,11 @@ export function normalizeTraces(request) {
                 const startedAt = nanosToDate(span.startTimeUnixNano);
                 const durationMs = spanDurationMs(span);
                 const kind = spanKind(span.kind);
-                const hasFailureEvent = (span.events ?? []).some((event) => event.name === "exception" || (event.name === "autter.outcome"
-                    && attrMap(event.attributes).get("autter.outcome.status") === "error"));
+                // An exception the app handled (`autter.handled`: caught and
+                // logged, or a deliberate fallback) never fails its span.
+                const hasFailureEvent = (span.events ?? []).some((event) => (event.name === "exception" && !softlyHandled(attrMap(event.attributes).get("autter.handling")))
+                    || (event.name === "autter.outcome"
+                        && attrMap(event.attributes).get("autter.outcome.status") === "error"));
                 const isError = statusCode !== null && statusCode >= 400 && statusCode < 500
                     ? hasFailureEvent
                     : hasFailureEvent || isErrorStatus(span.status?.code) || (statusCode !== null && statusCode >= 500);
@@ -207,8 +223,11 @@ export function normalizeTraces(request) {
                             statusCode,
                             traceId: span.traceId ?? null,
                             sessionId: null,
-                            attributes: sanitizeRuntimeContext({ ...decodeOtlpAttributes(span.attributes), ...decodeOtlpAttributes(event.attributes),
-                                ...(handled ? { "autter.handled": true, "autter.sampled": eventAttrs.get("autter.sampled") === "true" } : {}) }),
+                            attributes: withoutDebugIdsAttribute(sanitizeRuntimeContext({ ...decodeOtlpAttributes(span.attributes), ...decodeOtlpAttributes(event.attributes),
+                                ...(handled ? { "autter.handled": true, ...(eventAttrs.has("autter.sampled") ? { "autter.sampled": eventAttrs.get("autter.sampled") === "true" } : {}) } : {}) })),
+                            // Server SDKs (runtime-core errorAttributes): the debug ids of the bundles in the
+                            // stack (RF-05), which locate their source maps.
+                            ...serverDebugIds(eventAttrs.get(DEBUG_IDS_ATTRIBUTE)),
                             occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
                             // Event attributes first: one span can carry several
                             // exceptions, each with its own code.
@@ -337,6 +356,11 @@ export function normalizeTraces(request) {
         const occ = occurrences[i];
         if (occ.severity !== "fatal" && occ.severity !== "error")
             return;
+        // A caught error or deliberate fallback is an occurrence and an issue,
+        // but no failure: it never fails its request and never counts in
+        // `error_count`.
+        if (softlyHandled(occ.attributes?.["autter.handling"]))
+            return;
         const request = members.map(requestOfSignal).find((r) => r !== undefined);
         if (request) {
             request.hasErrorOccurrence = true;
@@ -373,6 +397,7 @@ export function normalizeTraces(request) {
                     errorCount: failed ? 1 : 0,
                     // The request's latency is its outermost span's.
                     durationSumMs: span.durationMs,
+                    ...withLatency(requestLatency(span.durationMs)),
                 });
                 break;
             case "metrics": {
@@ -515,6 +540,9 @@ function methodFromSpan(span) {
     const raw = span.attributes?.["http.request.method"];
     return typeof raw === "string" && raw.trim() ? raw.trim().toUpperCase().slice(0, 16) : null;
 }
+function withLatency(latency) {
+    return latency ? { latency } : {};
+}
 function minuteBucket(date) {
     return new Date(Math.floor(date.getTime() / 60_000) * 60_000);
 }
@@ -531,13 +559,17 @@ function addToRollup(rollups, point) {
     const key = rollupKey(point);
     const existing = rollups.get(key);
     if (!existing) {
-        rollups.set(key, { ...point });
+        const latency = mergeLatency(undefined, point.latency);
+        rollups.set(key, { ...point, ...withLatency(latency) });
         return;
     }
     existing.requestCount += point.requestCount;
     existing.errorCount += point.errorCount;
     existing.durationSumMs += point.durationSumMs;
     existing.sessionCount += point.sessionCount;
+    const latency = mergeLatency(existing.latency, point.latency);
+    if (latency)
+        existing.latency = latency;
 }
 // HTTP-server duration instruments we know how to fold into rollups.
 // `http.server.duration` (old semconv) is milliseconds;
@@ -598,6 +630,8 @@ export function normalizeMetrics(request) {
                         errorCount: statusCode !== null && statusCode >= 500 ? count : 0,
                         durationSumMs: (dataPoint.sum ?? 0) * multiplier,
                         sessionCount: 0,
+                        // p50/p95/p99 from the same buckets (IP-02, latency.ts).
+                        ...withLatency(histogramLatency((dataPoint.explicitBounds ?? []).map((bound) => Number(bound) * multiplier), (dataPoint.bucketCounts ?? []).map(Number))),
                     });
                 }
             }

package/dist/server.js

@@ -1,10 +1,11 @@
 import express from "express";
 import { KeyResolver, RateLimiter } from "./auth.js";
 import { countTruncations } from "./context.js";
-import { autterKeyHash, cumulativeHttpHistogramPoints, dataPointsInRequest, dropRoute, IngestDropCounter, PARTIAL_MESSAGES, partialSuccess, recordsInBody, spansInRequest, } from "./ingest-drops.js";
+import { autterKeyHash, caughtLimitedRecords, cumulativeHttpHistogramPoints, dataPointsInRequest, dropRoute, IngestDropCounter, PARTIAL_MESSAGES, partialSuccess, recordsInBody, spansInRequest, } from "./ingest-drops.js";
 import { ClickHouseStore } from "./clickhouse.js";
 import { normalizeLatencyHistograms } from "./latency.js";
 import { deriveFields, occurrenceIdFor } from "./fingerprint.js";
+import { causeTexts } from "./cause-chain.js";
 import { occurrenceIdentity } from "./fingerprint-v3.js";
 import { parseStackFrames } from "./stack-frames.js";
 import { SourceMapCache, Symbolicator } from "./symbolicate.js";
@@ -45,8 +46,9 @@ const INGESTER_INFO_INTERVAL_MS = 6 * 60 * 60 * 1000;
 export function createIngesterApp(config) {
     configureRedaction(config);
     const store = new ClickHouseStore(config);
-    // Browser JS frames are resolved through uploaded source maps before they
-    // are fingerprinted (frames-v3), with parsed maps cached per release+file.
+    // Browser, Node and edge JS frames are resolved through uploaded source
+    // maps before they are fingerprinted (frames-v3), with parsed maps cached
+    // per release+file.
     const symbolicator = new Symbolicator((key) => store.lookupSourceMap(key), new SourceMapCache({ maxBytes: (config.sourceMapCacheMb ?? 64) * 1024 * 1024 }));
     // Fingerprinted occurrences feed the consumer's issue grouping, metric
     // points feed the request/error-rate rollups, LLM calls feed spend
@@ -392,30 +394,63 @@ export function createIngesterApp(config) {
         }
         return ctx;
     }
-    /**
-     * Structured frames for the frames-v3 identity and the platform's stack
-     * view: parsed innermost-first, then — browser only, where bundles are
-     * minified — resolved through the release's source maps. Symbolication
-     * never fails ingest (it falls back to the parsed frames).
-     */
-    async function framesFor(ctx, input) {
-        let frames;
+    /** A stack's frames, innermost first; none when it does not parse. */
+    function parsedFrames(stack) {
         try {
-            frames = parseStackFrames(input.stack);
+            return parseStackFrames(stack);
         }
         catch (err) {
             console.warn("stack parse failed — no frames:", err instanceof Error ? err.message : err);
             return [];
         }
-        if (input.source !== "browser" || frames.length === 0)
-            return frames;
+    }
+    /**
+     * Frames resolved through the release's source maps: minified browser
+     * bundles, and bundled Node and edge code (RF-05: tsup, esbuild, webpack
+     * and Next.js server output) — only JS frames a map was uploaded for
+     * change. Never fails ingest (it falls back to the parsed frames).
+     */
+    function symbolicated(ctx, input, frames) {
+        if (frames.length === 0)
+            return Promise.resolve(frames);
         return symbolicator.symbolicate(frames, {
             orgId: ctx.orgId,
             repositoryId: ctx.repositoryId,
             release: input.release,
             debugIds: input.debugIds ?? null,
+            server: input.source !== "browser",
         });
     }
+    /**
+     * Structured frames for the frames-v3 identity and the platform's stack
+     * view: parsed innermost-first, then resolved through the release's
+     * source maps, with context lines on in-app frames when the map carries
+     * their source.
+     */
+    function framesFor(ctx, input) {
+        return symbolicated(ctx, input, parsedFrames(input.stack));
+    }
+    /**
+     * The reported exception's causes, nearest first, with their frames
+     * resolved like the reported one's (RF-06: the cause-v1 identity hashes
+     * the root cause's innermost in-app frame, which must read the same as
+     * when that error is reported unwrapped). Only used for the identity:
+     * cause frames are not stored.
+     */
+    async function causesFor(ctx, input) {
+        let causes;
+        try {
+            causes = causeTexts(input.stack, input.attributes);
+        }
+        catch (err) {
+            console.warn("cause chain parse failed — no causes:", err instanceof Error ? err.message : err);
+            return [];
+        }
+        return Promise.all(causes.map(async (cause) => ({
+            type: cause.type,
+            frames: await symbolicated(ctx, input, parsedFrames(cause.stack)),
+        })));
+    }
     /** Ids are content-derived (occurrenceIdFor), NOT random: an exporter
      * that retries a batch — after a 503 from a partially-failed ClickHouse
      * write, or when only our 2xx got lost — must produce the same ids, so
@@ -424,8 +459,8 @@ export function createIngesterApp(config) {
      *
      * `fingerprint` / `fingerprintScheme` stay the legacy identity
      * (message-v1 or code-v1) byte-for-byte; `fingerprints` carries every
-     * candidate (manual-v1, code-v1, frames-v3, message-v1) for the platform
-     * to resolve the issue from.
+     * candidate (manual-v1, code-v1, frames-v3, message-v1, cause-v1) for
+     * the platform to resolve the issue from.
      *
      * `batchIndexes` (traces): each occurrence's position among the batch's
      * signals before the per-trace dedupe, so a merged occurrence keeps the
@@ -439,8 +474,8 @@ export function createIngesterApp(config) {
             // through verbatim. Attributes were already sanitised by the
             // normalisers (sanitizeRuntimeContext).
             const input = scrubOccurrence(raw);
-            const frames = await framesFor(ctx, input);
-            const identity = occurrenceIdentity(input, frames);
+            const [frames, causes] = await Promise.all([framesFor(ctx, input), causesFor(ctx, input)]);
+            const identity = occurrenceIdentity(input, frames, causes);
             const { fingerprint, scheme } = identity.legacy;
             // Debug ids only locate source maps; they are not stored or forwarded.
             const { debugIds: _debugIds, ...stored } = input;
@@ -672,6 +707,7 @@ export function createIngesterApp(config) {
         countAccepted(ctx, req, [
             { reason: "spans_over_limit", records: overLimit },
             { reason: "attributes_truncated", records: truncated },
+            { reason: "caught_limited", records: caughtLimitedRecords(occurrences.map((o) => o.attributes)) },
         ]);
     }));
     app.post("/v1/logs", asyncRoute(async (req, res) => {
@@ -723,6 +759,8 @@ export function createIngesterApp(config) {
         countAccepted(ctx, req, [
             { reason: "log_records_over_limit", records: stats.overLimit },
             { reason: "attributes_truncated", records: truncated },
+            // Every record, promoted or not (the SDK's own count records too).
+            { reason: "caught_limited", records: caughtLimitedRecords(logs.map((row) => row.attributes)) },
         ]);
     }));
     app.post("/v1/metrics", asyncRoute(async (req, res) => {

package/dist/sink.d.ts

@@ -127,7 +127,10 @@ export declare class SinkForwarder {
  * keep their legacy meaning. 1.9.0 adds `count`: the occurrences this
  * record stands for, sent only when above 1 (a loop-collapse sample:
  * 1 + collapsedCount, see loop-collapse.ts); consumers add `count ?? 1` to
- * their event counts. Older consumers ignore unknown keys, so the version
- * stays 1.
+ * their event counts. Unreleased (RF-06): `fingerprints` may end with a
+ * `cause-v1` candidate after the legacy one; consumers that do not know the
+ * scheme drop it (the platform validates schemes one by one). RF-05: in-app
+ * frames' context lines are up to 5 on each side (3 before). Older consumers
+ * ignore unknown keys, so the version stays 1.
  */
 export declare function sinkOccurrence(o: RuntimeOccurrence): Record<string, unknown>;