@autter/otlp-ingester 1.7.0 → 1.8.0

package/dist/migrations.js

@@ -37,7 +37,8 @@ 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";
 import { memoryTableDDL, platformEventTableDDL } from "./memory.js";
-import { ingesterInfoTableDDL, sdkVersionTableDDL } from "./sdk-versions.js";
+import { ingesterInfoTableDDL, SDK_VERSION_VIA_COLUMN, sdkVersionTableDDL } from "./sdk-versions.js";
+import { ingestDropsTableDDL } from "./ingest-drops.js";
 /** Migration 0013 columns — shared with the baseline DDL in clickhouse.ts. */
 export const OCCURRENCE_CODE_COLUMNS = [
     "error_code String DEFAULT ''",
@@ -62,6 +63,17 @@ export const OCCURRENCE_GROUPING_COLUMNS = [
     "frames String DEFAULT '' CODEC(ZSTD(3))",
     "fingerprints Array(String) DEFAULT []",
 ];
+/**
+ * Migration 0020 columns — shared with the baseline DDL in clickhouse.ts.
+ * In-app browser JS frames a source map resolved / left unresolved at
+ * ingest (symbolicate.ts inAppFrameResolution); 0 and 0 for server
+ * occurrences, browser ones with no in-app JS frame, and rows written
+ * before 0020.
+ */
+export const OCCURRENCE_FRAME_RESOLUTION_COLUMNS = [
+    "in_app_frames_resolved UInt16 DEFAULT 0",
+    "in_app_frames_unresolved UInt16 DEFAULT 0",
+];
 export const MIGRATIONS = [
     // 0001 intentionally reserved as the baseline marker: databases created
     // before the migration runner existed record it as applied without
@@ -202,6 +214,22 @@ export const MIGRATIONS = [
             `ALTER TABLE {db}.runtime_source_maps ADD ${SOURCE_MAP_DEBUG_ID_INDEX.replace("INDEX ", "INDEX IF NOT EXISTS ")}`,
         ],
     },
+    // Rejections and drops per tenant, minute, route and reason (EI-27):
+    // what the ingester refused or did not store, so a repository's missing
+    // telemetry has a reason (ingest-drops.ts).
+    { id: "0018-runtime-ingest-drops", statements: [ingestDropsTableDDL("{db}")] },
+    // How each service's telemetry arrived: an OpenTelemetry Collector, an
+    // SDK exporter directly, or the browser relay (sdk-versions.ts).
+    {
+        id: "0019-sdk-versions-via",
+        statements: [`ALTER TABLE {db}.runtime_sdk_versions ADD COLUMN IF NOT EXISTS ${SDK_VERSION_VIA_COLUMN}`],
+    },
+    // Resolved and unresolved in-app browser frames per occurrence, after
+    // symbolication — the share the EI-14 source map rule reads.
+    {
+        id: "0020-occurrence-frame-resolution",
+        statements: OCCURRENCE_FRAME_RESOLUTION_COLUMNS.map((column) => `ALTER TABLE {db}.runtime_error_occurrences ADD COLUMN IF NOT EXISTS ${column}`),
+    },
 ];
 /** The tracking table itself — created by the runner before anything else. */
 export function migrationsTableDDL(db) {

package/dist/normalize-browser.d.ts

@@ -1,13 +1,9 @@
 import { z } from "zod";
 import { type RuntimeMetricPoint, type RuntimeOccurrenceInput } from "./types.js";
+/** Events past this in one payload are dropped and counted (events_over_limit). */
+export declare const MAX_BROWSER_EVENTS = 50;
+/** A whole payload, every event valid: what normalizeBrowserPayload takes. */
 export declare const browserPayloadSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    service: z.ZodString;
-    environment: z.ZodString;
-    release: z.ZodOptional<z.ZodString>;
-    /** @autter/runtime-browser version (1.4+); recorded for compatibility checks. */
-    sdk: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     events: z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         type: z.ZodEnum<["exception", "unhandled_rejection", "message", "session_start", "track_event", "outcome", "request_failure", "csp_violation", "timing"]>;
@@ -64,9 +60,9 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        name?: string | undefined;
         id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
@@ -83,13 +79,20 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        name?: string | undefined;
         id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
     }>, "many">;
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    service: z.ZodString;
+    environment: z.ZodString;
+    release: z.ZodOptional<z.ZodString>;
+    /** @autter/runtime-browser version (1.4+); recorded for compatibility checks. */
+    sdk: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
     service: string;
@@ -107,9 +110,9 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: Record<string, unknown> | undefined;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        name?: string | undefined;
         id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: string | string[] | undefined;
@@ -134,9 +137,9 @@ export declare const browserPayloadSchema: z.ZodObject<{
         debugIds?: unknown;
         durationMs?: number | undefined;
         filename?: string | undefined;
+        name?: string | undefined;
         column?: number | undefined;
         line?: number | undefined;
-        name?: string | undefined;
         id?: string | undefined;
         context?: Record<string, unknown> | undefined;
         fingerprint?: unknown;
@@ -146,6 +149,31 @@ export declare const browserPayloadSchema: z.ZodObject<{
     sdk?: unknown;
 }>;
 export type BrowserPayload = z.infer<typeof browserPayloadSchema>;
+export interface ParsedBrowserPayload {
+    /** The envelope with its valid events (at most MAX_BROWSER_EVENTS). */
+    payload: BrowserPayload;
+    /** Events dropped because they failed validation (invalid_event). */
+    invalidEvents: number;
+    /** Events past MAX_BROWSER_EVENTS, not looked at (events_over_limit). */
+    overLimitEvents: number;
+    /** The first validation issues of the dropped events; `path` starts with ["events", index]. */
+    issues: z.ZodIssue[];
+}
+/**
+ * Validate a browser payload event by event (1.8.0). The envelope (version,
+ * service, environment) must be valid or the payload is refused; an event
+ * that fails validation — a type this ingester doesn't know, a bad
+ * timestamp, an oversized field — is dropped on its own and counted, so it
+ * no longer costs the errors sent in the same beacon. Events past
+ * MAX_BROWSER_EVENTS are dropped and counted unread.
+ */
+export declare function parseBrowserPayload(body: unknown): {
+    success: true;
+    data: ParsedBrowserPayload;
+} | {
+    success: false;
+    issues: z.ZodIssue[];
+};
 export interface NormalizedBrowser {
     occurrences: RuntimeOccurrenceInput[];
     metricPoints: RuntimeMetricPoint[];

package/dist/normalize-browser.js

@@ -67,7 +67,9 @@ const browserEventSchema = z.object({
      */
     traceId: z.string().regex(/^(?!0{32})[0-9a-f]{32}$/).optional().catch(undefined),
 });
-export const browserPayloadSchema = z.object({
+/** Events past this in one payload are dropped and counted (events_over_limit). */
+export const MAX_BROWSER_EVENTS = 50;
+const browserEnvelope = {
     version: z.literal(1),
     sessionId: z.string().max(100).optional(),
     service: z.string().min(1).max(200),
@@ -75,8 +77,53 @@ export const browserPayloadSchema = z.object({
     release: z.string().max(200).optional(),
     /** @autter/runtime-browser version (1.4+); recorded for compatibility checks. */
     sdk: z.string().regex(/^\d{1,6}\.\d{1,6}\.\d{1,6}[0-9A-Za-z.+-]{0,20}$/).optional().catch(undefined),
-    events: z.array(browserEventSchema).max(50),
+};
+/** A whole payload, every event valid: what normalizeBrowserPayload takes. */
+export const browserPayloadSchema = z.object({
+    ...browserEnvelope,
+    events: z.array(browserEventSchema).max(MAX_BROWSER_EVENTS),
 });
+const browserEnvelopeSchema = z.object({ ...browserEnvelope, events: z.array(z.unknown()) });
+/**
+ * Validate a browser payload event by event (1.8.0). The envelope (version,
+ * service, environment) must be valid or the payload is refused; an event
+ * that fails validation — a type this ingester doesn't know, a bad
+ * timestamp, an oversized field — is dropped on its own and counted, so it
+ * no longer costs the errors sent in the same beacon. Events past
+ * MAX_BROWSER_EVENTS are dropped and counted unread.
+ */
+export function parseBrowserPayload(body) {
+    const envelope = browserEnvelopeSchema.safeParse(body);
+    if (!envelope.success)
+        return { success: false, issues: envelope.error.issues.slice(0, 5) };
+    const raw = envelope.data.events;
+    const considered = raw.slice(0, MAX_BROWSER_EVENTS);
+    const events = [];
+    const issues = [];
+    let invalidEvents = 0;
+    considered.forEach((candidate, index) => {
+        const parsed = browserEventSchema.safeParse(candidate);
+        if (parsed.success) {
+            events.push(parsed.data);
+            return;
+        }
+        invalidEvents += 1;
+        for (const issue of parsed.error.issues) {
+            if (issues.length >= 5)
+                break;
+            issues.push({ ...issue, path: ["events", index, ...issue.path] });
+        }
+    });
+    return {
+        success: true,
+        data: {
+            payload: { ...envelope.data, events },
+            invalidEvents,
+            overLimitEvents: raw.length - considered.length,
+            issues,
+        },
+    };
+}
 const TYPE_TO_ERROR_TYPE = {
     exception: "Error",
     unhandled_rejection: "UnhandledRejection",
@@ -154,14 +201,13 @@ export function normalizeBrowserPayload(payload) {
             continue;
         }
         const severity = asSeverity(event.severity, TYPE_TO_SEVERITY[event.type] ?? "error");
-        // The browser has no request stream, so error/message events are the
-        // only usage signal for many pages — count each as an event (and, for
-        // fatal/error severity, an error event). Without this, a page that
-        // only reports errors groups issues whose dashboards all read 0.
-        bumpRollup(event.route ? (event.route.split("?")[0] ?? "") : "", occurredAt, {
-            requestCount: 1,
-            errorCount: severity === "fatal" || severity === "error" ? 1 : 0,
-        });
+        // 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") {
+            bumpRollup(event.route ? (event.route.split("?")[0] ?? "") : "", occurredAt, { errorCount: 1 });
+        }
         occurrences.push({
             source: "browser",
             severity,

package/dist/normalize-otlp.js

@@ -6,6 +6,7 @@ import { normalizeRoute } from "./fingerprint.js";
 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 { 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) {
@@ -57,13 +58,18 @@ function spanKind(kind) {
 }
 function resourceInfo(resource) {
     const attrs = attrMap(resource?.attributes);
+    const service = attrs.get("service.name") ?? "unknown";
+    const environment = attrs.get("deployment.environment.name") ??
+        attrs.get("deployment.environment") ??
+        "production";
+    const release = attrs.get("service.version") ?? null;
     return {
-        service: attrs.get("service.name") ?? "unknown",
-        environment: attrs.get("deployment.environment.name") ??
-            attrs.get("deployment.environment") ??
-            "production",
-        release: attrs.get("service.version") ?? null,
+        service,
+        environment,
+        release,
+        metricsCountRoutedRequests: attrs.get("autter.metrics_wired") === "true" && attrs.get("autter.metrics_routes") === "true",
         metricsWired: attrs.get("autter.metrics_wired") === "true",
+        process: [service, environment, release ?? "", attrs.get("service.instance.id") ?? ""].join("\u0000"),
     };
 }
 function routeOf(attrs) {
@@ -73,6 +79,13 @@ function routeOf(attrs) {
         null;
     return route ? (route.split("?")[0] ?? null) : null;
 }
+/** How good a request name `routeOf` found: 2 for a route template
+ * (`http.route`), 1 for a raw path (`url.path` / `http.target`), 0 for none. */
+function routeQualityOf(attrs, route) {
+    if (!route)
+        return 0;
+    return attrs.has("http.route") ? 2 : 1;
+}
 function statusCodeOf(attrs) {
     const raw = attrs.get("http.response.status_code") ?? attrs.get("http.status_code");
     if (!raw)
@@ -102,10 +115,12 @@ function severityOf(eventAttrs, spanAttrs) {
 const MAX_SPANS_PER_REQUEST = 5000;
 export function normalizeTraces(request) {
     const signals = [];
-    // Per signal: whether a server span's request rollup already counts it,
-    // and the route its own rollup keys on (before HTTP inheritance).
+    // Per signal: the span it was recorded on (its index in `spans`), and the
+    // route its own event rollup keys on (before HTTP inheritance).
     const signalRollups = [];
     const spans = [];
+    // Per span, what the request rollups need beyond the span row.
+    const spanFacts = [];
     const llmCalls = [];
     const rollups = new Map();
     let spanCount = 0;
@@ -146,15 +161,20 @@ export function normalizeTraces(request) {
                     },
                     startedAt,
                 });
+                spanFacts.push({
+                    process: resource.process,
+                    routeQuality: routeQualityOf(attrs, route),
+                    // Who counts this span's request, as its outermost server
+                    // span: see countedBy.
+                    countedBy: countedBy(resource, attrs),
+                    templateRoute: attrs.has("http.route") && route ? normalizeRoute(route) : "",
+                });
                 // Error signals: one per exception event; if the span is
                 // errored without exception events, one from the span status.
                 // They become occurrences after the batch-wide dedupe below.
                 const traceId = span.traceId ?? "";
                 const spanId = span.spanId ?? "";
-                const rollup = {
-                    onRequestRollup: kind === "server" && attrs.get("autter.tail_retained") !== "true",
-                    route: route ?? "",
-                };
+                const rollup = { spanIndex: spans.length - 1, route: route ?? "" };
                 const spanAutter = attrs.has("autter.severity");
                 const exceptionEvents = (span.events ?? []).filter((event) => event.name === "exception");
                 for (const event of exceptionEvents) {
@@ -281,25 +301,6 @@ export function normalizeTraces(request) {
                 });
                 if (llmCall)
                     llmCalls.push(llmCall);
-                // Server spans fold into 1-minute usage rollups so traffic is
-                // tracked even when the metrics pipeline isn't wired. Spans
-                // exported by error-linked tail retention are skipped: the SDK
-                // ships those at ~100% alongside a metrics pipeline that already
-                // counts every request, so folding them in would double-count
-                // erroring routes.
-                if (rollup.onRequestRollup) {
-                    addToRollup(rollups, {
-                        service: resource.service,
-                        environment: resource.environment,
-                        release: resource.release,
-                        route: normalizeRoute(route),
-                        bucketAt: minuteBucket(startedAt),
-                        requestCount: 1,
-                        errorCount: isError ? 1 : 0,
-                        durationSumMs: durationMs,
-                        sessionCount: 0,
-                    });
-                }
             }
         }
     }
@@ -308,30 +309,94 @@ export function normalizeTraces(request) {
     // span chain explains are dropped (trace-dedupe.ts).
     const deduped = dedupeTraceSignals(signals, spans);
     const occurrences = deduped.occurrences;
-    // Occurrences on non-server spans (captureException's internal error
-    // spans, workers, consumers) have no request rollup to ride — count each
-    // as one event / one error event, or a service whose errors arrive
-    // outside HTTP handlers groups issues while every event counter stays 0.
-    // Server spans are excluded: their request rollup above already
-    // represents them, and so does it for a merged error any of whose
-    // recordings sits on one. Counted after the dedupe, so each thrown error
-    // is one event; a dropped status-only occurrence is none.
+    // Usage rollups (`runtime_metrics_1m`): `request_count` counts requests
+    // and only requests, `error_count` counts failed requests and errors
+    // outside any request. A request is its outermost server span
+    // (request-spans.ts); its server spans count it unless the sender's metric
+    // feed does (countedBySpans), and nothing else adds requests.
+    const membership = requestMembership(spans.map((span, i) => ({
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: span.parentSpanId,
+        kind: span.kind,
+        process: spanFacts[i].process,
+    })));
+    const requests = spanRequests(spans, spanFacts, membership);
+    const requestOfSignal = (m) => {
+        const root = membership.requestOf[signalRollups[m].spanIndex];
+        return root >= 0 ? requests.get(root) : undefined;
+    };
+    // Each error or fatal occurrence (after the dedupe: one per thrown error)
+    // counts once. One recorded in a request (on its server spans or any span
+    // below them in the batch) makes that request a failed one; any other
+    // (captureException's always-on spans exported apart from their request,
+    // workers, consumers, jobs) is one error outside a request. Warnings and
+    // info count nothing; neither does a dropped status-only occurrence.
+    const errorsOutsideRequests = [];
     deduped.members.forEach((members, i) => {
-        if (members.some((m) => signalRollups[m].onRequestRollup))
-            return;
         const occ = occurrences[i];
-        addToRollup(rollups, {
+        if (occ.severity !== "fatal" && occ.severity !== "error")
+            return;
+        const request = members.map(requestOfSignal).find((r) => r !== undefined);
+        if (request) {
+            request.hasErrorOccurrence = true;
+            return;
+        }
+        errorsOutsideRequests.push({
             service: occ.service,
             environment: occ.environment,
             release: occ.release,
             route: signalRollups[deduped.sourceIndexes[i]].route,
             bucketAt: minuteBucket(occ.occurredAt),
-            requestCount: 1,
-            errorCount: occ.severity === "fatal" || occ.severity === "error" ? 1 : 0,
+            requestCount: 0,
+            errorCount: 1,
             durationSumMs: 0,
             sessionCount: 0,
         });
     });
+    for (const [root, request] of requests) {
+        const span = spans[root];
+        const failed = request.isError || request.hasErrorOccurrence;
+        const point = {
+            service: span.service,
+            environment: span.environment,
+            release: span.release,
+            bucketAt: minuteBucket(span.startedAt),
+            sessionCount: 0,
+        };
+        switch (spanFacts[root].countedBy) {
+            case "spans":
+                addToRollup(rollups, {
+                    ...point,
+                    route: request.route,
+                    requestCount: 1,
+                    errorCount: failed ? 1 : 0,
+                    // The request's latency is its outermost span's.
+                    durationSumMs: span.durationMs,
+                });
+                break;
+            case "metrics": {
+                // The metric feed counted it, and already made a 5xx response
+                // a failed request. A request it saw succeed that recorded an
+                // error adds that one error, on the route its point carried.
+                const metricCountedFailure = span.statusCode !== null && span.statusCode >= 500;
+                if (request.hasErrorOccurrence && !metricCountedFailure) {
+                    addToRollup(rollups, { ...point, route: spanFacts[root].templateRoute, requestCount: 0, errorCount: 1, durationSumMs: 0 });
+                }
+                break;
+            }
+            case "none":
+                // Exported because it failed, with no metric feed counting
+                // requests: not a sample of the traffic, so no request; its
+                // failure counts once.
+                if (failed) {
+                    addToRollup(rollups, { ...point, route: request.route, requestCount: 0, errorCount: 1, durationSumMs: 0 });
+                }
+                break;
+        }
+    }
+    for (const error of errorsOutsideRequests)
+        addToRollup(rollups, error);
     inheritHttpFromParent(occurrences, deduped.sourceIndexes.map((index) => signals[index].spanId), spans);
     return {
         occurrences,
@@ -342,6 +407,53 @@ export function normalizeTraces(request) {
         spanCount,
     };
 }
+function countedBy(resource, attrs) {
+    if (resource.metricsCountRoutedRequests && attrs.get("autter.metric_has_route") === "true")
+        return "metrics";
+    if (attrs.get("autter.tail_retained") === "true")
+        return resource.metricsWired ? "metrics" : "none";
+    return "spans";
+}
+/**
+ * Every request in the batch, keyed by the batch index of its outermost
+ * server span (request-spans.ts). Server spans nested in it add no request:
+ * they lend their route when it is better (a template such as Next's
+ * `/blog/[slug]` over the HTTP span's raw path; on a tie the shallower
+ * span's), and their error. Latency and minute bucket stay the outermost
+ * span's.
+ */
+function spanRequests(spans, facts, membership) {
+    const requests = new Map();
+    spans.forEach((span, i) => {
+        if (membership.requestOf[i] !== i)
+            return;
+        requests.set(i, {
+            route: span.route ?? "",
+            routeQuality: facts[i].routeQuality,
+            routeDepth: membership.depth[i],
+            isError: span.status === "error",
+            hasErrorOccurrence: false,
+        });
+    });
+    spans.forEach((span, i) => {
+        const root = membership.requestOf[i];
+        if (root === i || span.kind !== "server")
+            return;
+        const request = requests.get(root);
+        if (!request)
+            return;
+        const quality = facts[i].routeQuality;
+        const depth = membership.depth[i];
+        if (quality > request.routeQuality || (quality === request.routeQuality && depth < request.routeDepth)) {
+            request.route = span.route ?? "";
+            request.routeQuality = quality;
+            request.routeDepth = depth;
+        }
+        if (span.status === "error")
+            request.isError = true;
+    });
+    return requests;
+}
 /**
  * Exception spans are often children named "Error" with no HTTP attributes.
  * Copy method, route, status, and duration from the server span in the same
@@ -438,8 +550,10 @@ const HTTP_DURATION_INSTRUMENTS = {
  * Cumulative histograms report lifetime totals on every export; adding them
  * into a SummingMergeTree would re-count all past requests each interval.
  * Only deltas are summable — cumulative senders are skipped and covered by
- * the span-fed rollup fallback instead. (Enum arrives as a number or an
- * `AGGREGATION_TEMPORALITY_*` string depending on the serialiser.)
+ * the span-fed rollup fallback instead (a sender must not mark itself
+ * `autter.metrics_wired` with cumulative histograms). (Enum arrives as a
+ * number or an `AGGREGATION_TEMPORALITY_*` string depending on the
+ * serialiser.)
  */
 function isCumulativeTemporality(t) {
     return t === 2 || t === "AGGREGATION_TEMPORALITY_CUMULATIVE";
@@ -448,6 +562,10 @@ export function normalizeMetrics(request) {
     const rollups = new Map();
     for (const resourceMetric of request.resourceMetrics ?? []) {
         const resource = resourceInfo(resourceMetric.resource);
+        // An SDK migrating semantic conventions can emit both instruments for
+        // every request (OTel's `OTEL_SEMCONV_STABILITY_OPT_IN=http/dup`).
+        // Count the stable one, as the latency histograms do (latency.ts).
+        const hasStableDuration = resourceMetric.scopeMetrics?.some((scope) => scope.metrics?.some((metric) => metric.name === "http.server.request.duration"));
         for (const scopeMetric of resourceMetric.scopeMetrics ?? []) {
             for (const metric of scopeMetric.metrics ?? []) {
                 const multiplier = metric.name
@@ -455,6 +573,8 @@ export function normalizeMetrics(request) {
                     : undefined;
                 if (multiplier === undefined)
                     continue;
+                if (hasStableDuration && metric.name === "http.server.duration")
+                    continue;
                 if (isCumulativeTemporality(metric.histogram?.aggregationTemporality)) {
                     continue;
                 }

package/dist/otlp-proto.d.ts

@@ -3,3 +3,17 @@ import type { OtlpLogsRequest } from "./logs.js";
 export declare function decodeTraceRequest(body: Buffer): OtlpTraceRequest;
 export declare function decodeMetricsRequest(body: Buffer): OtlpMetricsRequest;
 export declare function decodeLogsRequest(body: Buffer): OtlpLogsRequest;
+/**
+ * The protobuf body of an OTLP export response: empty when everything was
+ * accepted, else `partial_success` with the rejected count and why
+ * (identical bytes for traces, logs and metrics).
+ */
+export declare function encodeExportResponse(partial: {
+    rejected: number;
+    errorMessage: string;
+} | null): Uint8Array;
+/** Decode an OTLP export response body (tests, and anything reading our answers). */
+export declare function decodeExportResponse(body: Uint8Array): {
+    rejected: number;
+    errorMessage: string;
+} | null;

package/dist/otlp-proto.js

@@ -93,11 +93,19 @@ message HistogramDataPoint {
   repeated double explicit_bounds = 7;
   repeated KeyValue attributes = 9;
 }
+
+// ExportTraceServiceResponse, ExportLogsServiceResponse and
+// ExportMetricsServiceResponse share this wire shape: partial_success = 1,
+// and in it the rejected count (rejected_spans / rejected_log_records /
+// rejected_data_points) = 1 and error_message = 2.
+message ExportServiceResponse { ExportPartialSuccess partial_success = 1; }
+message ExportPartialSuccess { int64 rejected = 1; string error_message = 2; }
 `;
 const root = protobuf.parse(PROTO).root;
 const TraceRequest = root.lookupType("otlp.ExportTraceServiceRequest");
 const MetricsRequest = root.lookupType("otlp.ExportMetricsServiceRequest");
 const LogsRequest = root.lookupType("otlp.ExportLogsServiceRequest");
+const ServiceResponse = root.lookupType("otlp.ExportServiceResponse");
 const TO_OBJECT_OPTIONS = {
     longs: String, // 64-bit ints → strings (matches OTLP/JSON)
     defaults: false,
@@ -131,3 +139,20 @@ export function decodeMetricsRequest(body) {
 export function decodeLogsRequest(body) {
     return hexifyIds(LogsRequest.toObject(LogsRequest.decode(body), TO_OBJECT_OPTIONS));
 }
+/**
+ * The protobuf body of an OTLP export response: empty when everything was
+ * accepted, else `partial_success` with the rejected count and why
+ * (identical bytes for traces, logs and metrics).
+ */
+export function encodeExportResponse(partial) {
+    if (!partial)
+        return new Uint8Array(0);
+    return ServiceResponse.encode(ServiceResponse.create({ partialSuccess: { rejected: partial.rejected, errorMessage: partial.errorMessage } })).finish();
+}
+/** Decode an OTLP export response body (tests, and anything reading our answers). */
+export function decodeExportResponse(body) {
+    const message = ServiceResponse.toObject(ServiceResponse.decode(body), { longs: Number, defaults: false });
+    if (!message.partialSuccess)
+        return null;
+    return { rejected: message.partialSuccess.rejected ?? 0, errorMessage: message.partialSuccess.errorMessage ?? "" };
+}

package/dist/profiles.d.ts

@@ -13,10 +13,14 @@ export interface ProfileSample {
     value: number;
 }
 export declare function profileTableDDL(db: string): string;
+/** Samples kept per profile; the rest are dropped and counted (profile_samples_over_limit). */
+export declare const MAX_PROFILE_SAMPLES = 1000;
 export declare function decodeProfile(body: Buffer, meta: {
     service: string;
     environment: string;
     release: string;
     traceId: string;
     instanceId: string;
+}, stats?: {
+    overLimit: number;
 }): ProfileSample[];

package/dist/profiles.js

@@ -28,7 +28,9 @@ export function profileTableDDL(db) {
 	ORDER BY (org_id, repository_id, service, environment, release, observed_at, profile_id)
 	TTL toDateTime(observed_at) + INTERVAL 7 DAY`;
 }
-export function decodeProfile(body, meta) {
+/** Samples kept per profile; the rest are dropped and counted (profile_samples_over_limit). */
+export const MAX_PROFILE_SAMPLES = 1000;
+export function decodeProfile(body, meta, stats) {
     if (body.length === 0 || body.length > 1024 * 1024)
         throw new Error("invalid profile size");
     const payload = body[0] === 0x1f && body[1] === 0x8b
@@ -43,7 +45,9 @@ export function decodeProfile(body, meta) {
     const observedAt = observedMs > 0 && observedMs <= Date.now() + 300_000 ? new Date(observedMs) : new Date();
     const profileId = createHash("sha256").update(body).digest("hex").slice(0, 32);
     const samples = [];
-    for (const [sampleIndex, sample] of (profile.sample ?? []).slice(0, 1000).entries()) {
+    if (stats)
+        stats.overLimit += Math.max(0, (profile.sample ?? []).length - MAX_PROFILE_SAMPLES);
+    for (const [sampleIndex, sample] of (profile.sample ?? []).slice(0, MAX_PROFILE_SAMPLES).entries()) {
         const stack = (sample.locationId ?? []).slice(0, 64).flatMap((id) => {
             const locLine = locations.get(id)?.line?.[0];
             const fn = locLine?.functionId ? functions.get(locLine.functionId) : undefined;