@autter/otlp-ingester 1.6.1 → 1.8.0

package/dist/normalize-otlp.js

@@ -5,6 +5,8 @@ import { scrubText } from "./redact.js";
 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) {
@@ -56,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) {
@@ -72,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)
@@ -100,9 +114,13 @@ function severityOf(eventAttrs, spanAttrs) {
 }
 const MAX_SPANS_PER_REQUEST = 5000;
 export function normalizeTraces(request) {
-    const occurrences = [];
-    const occurrenceSpanIds = [];
+    const signals = [];
+    // 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;
@@ -143,39 +161,61 @@ export function normalizeTraces(request) {
                     },
                     startedAt,
                 });
-                // Error occurrences: one per exception event; if the span is
+                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.
-                const occurrencesBefore = occurrences.length;
+                // They become occurrences after the batch-wide dedupe below.
+                const traceId = span.traceId ?? "";
+                const spanId = span.spanId ?? "";
+                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) {
                     const eventAttrs = attrMap(event.attributes);
                     const handled = eventAttrs.get("autter.handled") === "true";
-                    occurrenceSpanIds.push(span.spanId ?? "");
-                    occurrences.push({
-                        source: "server",
-                        severity: severityOf(eventAttrs, attrs),
-                        service: resource.service,
-                        environment: resource.environment,
-                        release: resource.release,
-                        errorType: eventAttrs.get("exception.type") ?? "Error",
-                        message: eventAttrs.get("exception.message") ??
-                            span.status?.message ??
-                            span.name ??
-                            "Unknown error",
-                        stack: eventAttrs.get("exception.stacktrace") ?? null,
-                        route,
-                        method: methodOf(attrs),
-                        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" } : {}) }),
-                        occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
-                        // Event attributes first: one span can carry several
-                        // exceptions, each with its own code.
-                        ...liftErrorFields(eventAttrs, attrs),
-                        ...breadcrumbsField(eventAttrs.get(BREADCRUMBS_ATTRIBUTE), attrs.get(BREADCRUMBS_ATTRIBUTE)),
-                        ...fingerprintOverrideOf(eventAttrs.get("autter.fingerprint") ?? attrs.get("autter.fingerprint")),
+                    const eventAutter = hasAutterKey(eventAttrs);
+                    signalRollups.push(rollup);
+                    signals.push({
+                        traceId,
+                        spanId,
+                        signal: "exception",
+                        autterCapture: eventAutter || spanAutter,
+                        eventAutter,
+                        nextContext: hasNextContext(eventAttrs, attrs),
+                        handled,
+                        occurrence: {
+                            source: "server",
+                            severity: severityOf(eventAttrs, attrs),
+                            service: resource.service,
+                            environment: resource.environment,
+                            release: resource.release,
+                            errorType: eventAttrs.get("exception.type") ?? "Error",
+                            message: eventAttrs.get("exception.message") ??
+                                span.status?.message ??
+                                span.name ??
+                                "Unknown error",
+                            stack: eventAttrs.get("exception.stacktrace") ?? null,
+                            route,
+                            method: methodOf(attrs),
+                            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" } : {}) }),
+                            occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
+                            // Event attributes first: one span can carry several
+                            // exceptions, each with its own code.
+                            ...liftErrorFields(eventAttrs, attrs),
+                            ...breadcrumbsField(eventAttrs.get(BREADCRUMBS_ATTRIBUTE), attrs.get(BREADCRUMBS_ATTRIBUTE)),
+                            ...fingerprintOverrideOf(eventAttrs.get("autter.fingerprint") ?? attrs.get("autter.fingerprint")),
+                        },
                     });
                 }
                 const failedOutcomes = (span.events ?? []).filter((event) => {
@@ -186,40 +226,58 @@ export function normalizeTraces(request) {
                 for (const event of failedOutcomes) {
                     const outcome = attrMap(event.attributes);
                     const name = (outcome.get("autter.outcome.name") ?? "operation").replace(EMAIL_VALUE_RE, "[redacted]").slice(0, 200);
-                    occurrenceSpanIds.push(span.spanId ?? "");
-                    occurrences.push({
-                        source: "server", severity: "error", service: resource.service,
-                        environment: resource.environment, release: resource.release,
-                        errorType: "OutcomeFailure",
-                        message: `${name}: ${(outcome.get("autter.outcome.message") ?? "failed").replace(EMAIL_VALUE_RE, "[redacted]").slice(0, 1000)}`,
-                        stack: String(decodeOtlpAttributes(event.attributes)["autter.outcome.stack"] ?? "") || null, route, method: methodOf(attrs), statusCode,
-                        traceId: span.traceId ?? null, sessionId: null,
-                        attributes: sanitizeRuntimeContext({ ...decodeOtlpAttributes(span.attributes), ...decodeOtlpAttributes(event.attributes) }),
-                        occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
-                        ...liftErrorFields(outcome, attrs),
+                    signalRollups.push(rollup);
+                    signals.push({
+                        traceId,
+                        spanId,
+                        signal: "outcome",
+                        autterCapture: true,
+                        eventAutter: true,
+                        nextContext: hasNextContext(outcome, attrs),
+                        handled: false,
+                        occurrence: {
+                            source: "server", severity: "error", service: resource.service,
+                            environment: resource.environment, release: resource.release,
+                            errorType: "OutcomeFailure",
+                            message: `${name}: ${(outcome.get("autter.outcome.message") ?? "failed").replace(EMAIL_VALUE_RE, "[redacted]").slice(0, 1000)}`,
+                            stack: String(decodeOtlpAttributes(event.attributes)["autter.outcome.stack"] ?? "") || null, route, method: methodOf(attrs), statusCode,
+                            traceId: span.traceId ?? null, sessionId: null,
+                            attributes: sanitizeRuntimeContext({ ...decodeOtlpAttributes(span.attributes), ...decodeOtlpAttributes(event.attributes) }),
+                            occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
+                            ...liftErrorFields(outcome, attrs),
+                        },
                     });
                 }
                 if (exceptionEvents.length === 0 && failedOutcomes.length === 0 && isError) {
-                    occurrenceSpanIds.push(span.spanId ?? "");
-                    occurrences.push({
-                        source: "server",
-                        severity: severityOf(new Map(), attrs),
-                        service: resource.service,
-                        environment: resource.environment,
-                        release: resource.release,
-                        errorType: statusCode !== null && statusCode >= 500 ? "HttpServerError" : "SpanError",
-                        message: span.status?.message || (statusCode !== null && statusCode >= 500
-                            ? `${methodOf(attrs) ?? "HTTP"} ${route ?? span.name ?? "request"} returned ${statusCode}`
-                            : `${span.name ?? "span"} failed`),
-                        stack: null,
-                        route,
-                        method: methodOf(attrs),
-                        statusCode,
-                        traceId: span.traceId ?? null,
-                        sessionId: null,
-                        attributes: decodeOtlpAttributes(span.attributes),
-                        occurredAt: startedAt,
-                        ...liftErrorFields(attrs),
+                    signalRollups.push(rollup);
+                    signals.push({
+                        traceId,
+                        spanId,
+                        signal: "status",
+                        autterCapture: spanAutter,
+                        eventAutter: false,
+                        nextContext: hasNextContext(attrs),
+                        handled: false,
+                        occurrence: {
+                            source: "server",
+                            severity: severityOf(new Map(), attrs),
+                            service: resource.service,
+                            environment: resource.environment,
+                            release: resource.release,
+                            errorType: statusCode !== null && statusCode >= 500 ? "HttpServerError" : "SpanError",
+                            message: span.status?.message || (statusCode !== null && statusCode >= 500
+                                ? `${methodOf(attrs) ?? "HTTP"} ${route ?? span.name ?? "request"} returned ${statusCode}`
+                                : `${span.name ?? "span"} failed`),
+                            stack: null,
+                            route,
+                            method: methodOf(attrs),
+                            statusCode,
+                            traceId: span.traceId ?? null,
+                            sessionId: null,
+                            attributes: decodeOtlpAttributes(span.attributes),
+                            occurredAt: startedAt,
+                            ...liftErrorFields(attrs),
+                        },
                     });
                 }
                 // LLM provider calls (GenAI semconv, Vercel AI SDK telemetry,
@@ -243,58 +301,159 @@ 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 (kind === "server" && attrs.get("autter.tail_retained") !== "true") {
-                    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,
-                    });
-                }
-                else {
-                    // 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.
-                    for (const occ of occurrences.slice(occurrencesBefore)) {
-                        addToRollup(rollups, {
-                            service: occ.service,
-                            environment: occ.environment,
-                            release: occ.release,
-                            route: occ.route ?? "",
-                            bucketAt: minuteBucket(occ.occurredAt),
-                            requestCount: 1,
-                            errorCount: occ.severity === "fatal" || occ.severity === "error" ? 1 : 0,
-                            durationSumMs: 0,
-                            sessionCount: 0,
-                        });
-                    }
+            }
+        }
+    }
+    // One occurrence per thrown error: recordings of one error on several
+    // spans of a trace merge, and status-only occurrences an error on their
+    // span chain explains are dropped (trace-dedupe.ts).
+    const deduped = dedupeTraceSignals(signals, spans);
+    const occurrences = deduped.occurrences;
+    // 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) => {
+        const occ = occurrences[i];
+        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: 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;
         }
     }
-    inheritHttpFromParent(occurrences, occurrenceSpanIds, spans);
+    for (const error of errorsOutsideRequests)
+        addToRollup(rollups, error);
+    inheritHttpFromParent(occurrences, deduped.sourceIndexes.map((index) => signals[index].spanId), spans);
     return {
         occurrences,
+        occurrenceBatchIndexes: deduped.sourceIndexes,
         spans,
         metricPoints: [...rollups.values()],
         llmCalls,
         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
@@ -391,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";
@@ -401,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
@@ -408,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;

package/dist/request-spans.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Which request each span of an export batch belongs to, so the span-fed
+ * usage rollups (`runtime_metrics_1m`) count one request once.
+ *
+ * A framework that opens its own SERVER span under the HTTP
+ * instrumentation's gives one request two server spans: Next.js's
+ * `BaseServer.handleRequest` span is a child of the HTTP server span, and
+ * some NestJS and Fastify setups and gRPC gateways serving RPCs in-process do
+ * the same. Each server span used to add a request, its latency and its error
+ * to the rollups, so every traced request of such an app counted twice.
+ *
+ * The request is the OUTERMOST server span. Walking up from a span through
+ * the parent links present in the batch, its request is the highest SERVER
+ * span reached. The walk stops:
+ *   - at a parent that is not in the batch: the span's own chain ends there,
+ *     so a server span whose parent is missing is a request of its own, as
+ *     before. When an exporter's timer splits one request's spans across two
+ *     batches, the nested server span therefore counts in its batch and the
+ *     outer one in the other; a batch cannot tell a parent exported elsewhere
+ *     from a remote caller;
+ *   - at a parent in another process (service, environment, release and
+ *     `service.instance.id`): one process serves one request;
+ *   - where a SERVER or CONSUMER span's parent is a CLIENT or PRODUCER span:
+ *     that edge is a call over the wire, a request of its own even when a
+ *     service calls itself.
+ */
+export interface RequestSpanLink {
+    traceId: string;
+    spanId: string;
+    parentSpanId: string | null;
+    /** Lower-case OTel span kind: "server", "client", "internal", … */
+    kind: string;
+    /** The process the span was recorded in; spans of different processes
+     * are never one request. */
+    process: string;
+}
+export interface RequestMembership {
+    /** Per span: the batch index of its request's (outermost) server span,
+     * or -1 when no server span is on its chain. */
+    requestOf: number[];
+    /** Per span: how many parent links the walk followed above it (0 at the
+     * top of its chain). Nested spans are deeper than their request span. */
+    depth: number[];
+}
+export declare function requestMembership(spans: RequestSpanLink[]): RequestMembership;