@autter/otlp-ingester 1.9.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.d.ts

@@ -48,9 +48,40 @@ export interface PromotionLookup {
  */
 export declare function promotionLookups(occurrences: RuntimeOccurrenceInput[], now?: number): PromotionLookup[];
 /**
- * One error per promoted occurrence, in `error_count` only — the same
- * counting the trace path applies to errors outside a request (a log record
- * names no request the rollups count), so error counters for logger-only and
- * edge services don't read 0 and no request is invented.
+ * `autter.request.counted_by = "summary"`: the request this record belongs to
+ * is counted in the usage rollups by its request summary (the record of
+ * `autter.operation.kind = "request"` carrying the same mark), because no
+ * other feed sees it. `@autter/runtime-edge` (1.3.0+) puts it on every
+ * record of a request: an edge function has no trace pipeline and no
+ * `http.server.duration` histogram, so without it edge services had error
+ * counts and no requests. Nothing else sets it: Node and Next.js summaries
+ * never carry it (their requests are counted by the histogram or the spans),
+ * so a request is counted by its summary only when its sender says the
+ * summary is the one count it gets.
  */
-export declare function promotionRollups(occurrences: RuntimeOccurrence[]): RuntimeMetricPoint[];
+export declare 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 declare const ERROR_REPORTED_ATTRIBUTE = "autter.request.error_reported";
+export declare function countedBySummary(attributes: Record<string, unknown> | null | undefined): boolean;
+/**
+ * The usage rollups (`runtime_metrics_1m`) a /v1/logs batch adds, counted the
+ * way the trace path counts (normalize-otlp.ts): `request_count` counts
+ * requests only, `error_count` counts failed requests once and errors outside
+ * a counted request one each.
+ *
+ * - A request summary marked counted (`countedBySummary`) is one request:
+ *   `request_count` 1, its duration, on its route and minute; `error_count` 1
+ *   when it failed — outcome `failed`, a status ≥ 500, or an error reported
+ *   in it (`autter.request.error_reported`), as an error occurrence recorded
+ *   in a request fails it on the trace path.
+ * - A promoted occurrence (logger-only or edge error record) adds
+ *   `error_count` 1 — unless its record is marked counted: its request's
+ *   summary already counts that failure once, however many errors it had.
+ *
+ * The decision is per record, never by matching records across a batch, so
+ * a request whose records an exporter splits over two batches is still
+ * counted once. Unmarked summaries add nothing (they are counted elsewhere,
+ * or by no one, as before).
+ */
+export declare function logRollups(rows: RuntimeLogRecord[], promoted: RuntimeOccurrence[]): RuntimeMetricPoint[];

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.
  *
@@ -81,38 +82,111 @@ export function promotionLookups(occurrences, now = Date.now()) {
     return lookups;
 }
 /**
- * One error per promoted occurrence, in `error_count` only — the same
- * counting the trace path applies to errors outside a request (a log record
- * names no request the rollups count), so error counters for logger-only and
- * edge services don't read 0 and no request is invented.
+ * `autter.request.counted_by = "summary"`: the request this record belongs to
+ * is counted in the usage rollups by its request summary (the record of
+ * `autter.operation.kind = "request"` carrying the same mark), because no
+ * other feed sees it. `@autter/runtime-edge` (1.3.0+) puts it on every
+ * record of a request: an edge function has no trace pipeline and no
+ * `http.server.duration` histogram, so without it edge services had error
+ * counts and no requests. Nothing else sets it: Node and Next.js summaries
+ * never carry it (their requests are counted by the histogram or the spans),
+ * so a request is counted by its summary only when its sender says the
+ * summary is the one count it gets.
  */
-export function promotionRollups(occurrences) {
+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";
+}
+/**
+ * The usage rollups (`runtime_metrics_1m`) a /v1/logs batch adds, counted the
+ * way the trace path counts (normalize-otlp.ts): `request_count` counts
+ * requests only, `error_count` counts failed requests once and errors outside
+ * a counted request one each.
+ *
+ * - A request summary marked counted (`countedBySummary`) is one request:
+ *   `request_count` 1, its duration, on its route and minute; `error_count` 1
+ *   when it failed — outcome `failed`, a status ≥ 500, or an error reported
+ *   in it (`autter.request.error_reported`), as an error occurrence recorded
+ *   in a request fails it on the trace path.
+ * - A promoted occurrence (logger-only or edge error record) adds
+ *   `error_count` 1 — unless its record is marked counted: its request's
+ *   summary already counts that failure once, however many errors it had.
+ *
+ * The decision is per record, never by matching records across a batch, so
+ * a request whose records an exporter splits over two batches is still
+ * counted once. Unmarked summaries add nothing (they are counted elsewhere,
+ * or by no one, as before).
+ */
+export function logRollups(rows, promoted) {
     const rollups = new Map();
-    for (const occ of occurrences) {
-        const bucketAt = new Date(Math.floor(occ.occurredAt.getTime() / 60_000) * 60_000);
-        const route = normalizeRoute(occ.route);
-        const key = [
-            occ.service,
-            occ.environment,
-            occ.release ?? "",
-            route,
-            bucketAt.getTime(),
-        ].join(" ");
+    const add = (point) => {
+        const { at, ...rest } = point;
+        const bucketAt = new Date(Math.floor(at.getTime() / 60_000) * 60_000);
+        const key = [rest.service, rest.environment, rest.release ?? "", rest.route, bucketAt.getTime()].join(" ");
         const existing = rollups.get(key);
         if (existing) {
-            existing.errorCount += 1;
-            continue;
+            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, {
+        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))
+            continue;
+        const failed = row.outcome === "failed" ||
+            row.statusCode >= 500 ||
+            row.attributes[ERROR_REPORTED_ATTRIBUTE] === true;
+        add({
+            service: row.service,
+            environment: row.environment,
+            release: row.release || null,
+            // Already normalized (logs.ts), the key promoted errors use too.
+            route: row.route,
+            at: row.occurredAt,
+            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;
+        // One error of its own, in `error_count` only — what the trace path
+        // does for an error outside a request: the record names no request
+        // the rollups count, so no request is invented.
+        add({
             service: occ.service,
             environment: occ.environment,
             release: occ.release,
-            route,
-            bucketAt,
+            route: normalizeRoute(occ.route),
+            at: occ.occurredAt,
             requestCount: 0,
             errorCount: 1,
             durationSumMs: 0,
-            sessionCount: 0,
         });
     }
     return [...rollups.values()];

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))),
                     });
                 }
             }