@autter/otlp-ingester 1.3.1 → 1.3.2

package/dist/clickhouse.d.ts

@@ -1,5 +1,6 @@
 import type { IngesterConfig } from "./config.js";
 import { type LatencyHistogram } from "./latency.js";
+import { type ProfileSample } from "./profiles.js";
 import { type Migration } from "./migrations.js";
 import type { IngestContext, RuntimeLlmCall, RuntimeMetricPoint, RuntimeOccurrence, RuntimeSpanRow } from "./types.js";
 export declare class ClickHouseStore {
@@ -23,6 +24,12 @@ export declare class ClickHouseStore {
     ping(): Promise<boolean>;
     insertOccurrences(ctx: IngestContext, occurrences: RuntimeOccurrence[]): Promise<void>;
     insertSpans(ctx: IngestContext, spans: RuntimeSpanRow[]): Promise<void>;
+    insertProfileSamples(ctx: IngestContext, samples: ProfileSample[]): Promise<void>;
+    insertSourceMap(ctx: IngestContext, sourceMap: {
+        release: string;
+        filename: string;
+        map: string;
+    }): Promise<void>;
     insertLlmCalls(ctx: IngestContext, calls: RuntimeLlmCall[]): Promise<void>;
     insertMetricPoints(ctx: IngestContext, points: RuntimeMetricPoint[]): Promise<void>;
     insertLatencyHistograms(ctx: IngestContext, points: LatencyHistogram[]): Promise<void>;

package/dist/clickhouse.js

@@ -1,5 +1,7 @@
 import { createClient, } from "@clickhouse/client";
 import { latencyTableDDL } from "./latency.js";
+import { profileTableDDL } from "./profiles.js";
+import { sourceMapTableDDL } from "./source-maps.js";
 import { MIGRATIONS, migrationsTableDDL, } from "./migrations.js";
 /**
  * ClickHouse persistence. The schema is idempotent and applied lazily once
@@ -46,6 +48,8 @@ export class ClickHouseStore {
         return [
             `CREATE DATABASE IF NOT EXISTS ${db}`,
             latencyTableDDL(db, metricsTtlDays),
+            profileTableDDL(db),
+            sourceMapTableDDL(db),
             `CREATE TABLE IF NOT EXISTS ${db}.runtime_error_occurrences (
 				org_id             String,
 				repository_id      String,
@@ -258,6 +262,33 @@ export class ClickHouseStore {
             })),
         });
     }
+    async insertProfileSamples(ctx, samples) {
+        if (!samples.length)
+            return;
+        if (!this.configured)
+            throw new Error("CLICKHOUSE_URL is not configured");
+        await this.ensureSchema();
+        await this.getClient().insert({
+            table: this.table("runtime_profile_samples"), format: "JSONEachRow",
+            clickhouse_settings: INSERT_SETTINGS,
+            values: samples.map((sample) => ({
+                org_id: ctx.orgId, repository_id: ctx.repositoryId,
+                profile_id: sample.profileId, sample_index: sample.sampleIndex, service: sample.service,
+                environment: sample.environment, release: sample.release,
+                trace_id: sample.traceId, observed_at: sample.observedAt.toISOString(),
+                sample_type: sample.sampleType, unit: sample.unit,
+                stack: sample.stack, value: sample.value,
+            })),
+        });
+    }
+    async insertSourceMap(ctx, sourceMap) {
+        await this.ensureSchema();
+        await this.getClient().insert({
+            table: this.table("runtime_source_maps"), format: "JSONEachRow",
+            clickhouse_settings: INSERT_SETTINGS,
+            values: [{ org_id: ctx.orgId, repository_id: ctx.repositoryId, ...sourceMap }],
+        });
+    }
     async insertLlmCalls(ctx, calls) {
         if (calls.length === 0 || !this.configured)
             return;

package/dist/migrations.js

@@ -33,6 +33,8 @@
  *   },
  */
 import { latencyTableDDL } from "./latency.js";
+import { profileTableDDL } from "./profiles.js";
+import { sourceMapTableDDL } from "./source-maps.js";
 export const MIGRATIONS = [
     // 0001 intentionally reserved as the baseline marker: databases created
     // before the migration runner existed record it as applied without
@@ -115,6 +117,8 @@ export const MIGRATIONS = [
         ],
     },
     { id: "0005-latency-histograms", statements: [latencyTableDDL("{db}")] },
+    { id: "0006-profile-samples", statements: [profileTableDDL("{db}")] },
+    { id: "0007-source-maps", statements: [sourceMapTableDDL("{db}")] },
 ];
 /** The tracking table itself — created by the runner before anything else. */
 export function migrationsTableDDL(db) {

package/dist/normalize-browser.d.ts

@@ -8,13 +8,14 @@ export declare const browserPayloadSchema: z.ZodObject<{
     release: 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"]>;
+        type: z.ZodEnum<["exception", "unhandled_rejection", "message", "session_start", "track_event", "outcome", "request_failure", "timing"]>;
         timestamp: z.ZodString;
         /** exception/message events: signal level. Defaults per type. */
         severity: z.ZodOptional<z.ZodEnum<["fatal", "error", "warning", "info"]>>;
         message: z.ZodDefault<z.ZodString>;
         /** track_event only: the event name (counted, never free-form PII). */
         name: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
         stack: z.ZodOptional<z.ZodString>;
         errorType: z.ZodOptional<z.ZodString>;
         filename: z.ZodOptional<z.ZodString>;
@@ -24,29 +25,31 @@ export declare const browserPayloadSchema: z.ZodObject<{
         route: z.ZodOptional<z.ZodString>;
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event";
+        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event" | "outcome" | "request_failure" | "timing";
         message: string;
         timestamp: string;
+        durationMs?: number | undefined;
+        filename?: string | undefined;
         id?: string | undefined;
         severity?: "fatal" | "error" | "warning" | "info" | undefined;
         name?: string | undefined;
         stack?: string | undefined;
         errorType?: string | undefined;
-        filename?: string | undefined;
         line?: number | undefined;
         column?: number | undefined;
         route?: string | undefined;
         context?: Record<string, unknown> | undefined;
     }, {
-        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event";
+        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event" | "outcome" | "request_failure" | "timing";
         timestamp: string;
+        durationMs?: number | undefined;
+        filename?: string | undefined;
         id?: string | undefined;
         message?: string | undefined;
         severity?: "fatal" | "error" | "warning" | "info" | undefined;
         name?: string | undefined;
         stack?: string | undefined;
         errorType?: string | undefined;
-        filename?: string | undefined;
         line?: number | undefined;
         column?: number | undefined;
         route?: string | undefined;
@@ -57,15 +60,16 @@ export declare const browserPayloadSchema: z.ZodObject<{
     environment: string;
     version: 1;
     events: {
-        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event";
+        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event" | "outcome" | "request_failure" | "timing";
         message: string;
         timestamp: string;
+        durationMs?: number | undefined;
+        filename?: string | undefined;
         id?: string | undefined;
         severity?: "fatal" | "error" | "warning" | "info" | undefined;
         name?: string | undefined;
         stack?: string | undefined;
         errorType?: string | undefined;
-        filename?: string | undefined;
         line?: number | undefined;
         column?: number | undefined;
         route?: string | undefined;
@@ -78,15 +82,16 @@ export declare const browserPayloadSchema: z.ZodObject<{
     environment: string;
     version: 1;
     events: {
-        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event";
+        type: "exception" | "message" | "unhandled_rejection" | "session_start" | "track_event" | "outcome" | "request_failure" | "timing";
         timestamp: string;
+        durationMs?: number | undefined;
+        filename?: string | undefined;
         id?: string | undefined;
         message?: string | undefined;
         severity?: "fatal" | "error" | "warning" | "info" | undefined;
         name?: string | undefined;
         stack?: string | undefined;
         errorType?: string | undefined;
-        filename?: string | undefined;
         line?: number | undefined;
         column?: number | undefined;
         route?: string | undefined;

package/dist/normalize-browser.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { normalizeRoute } from "./fingerprint.js";
 import { asSeverity, } from "./types.js";
 /**
  * The compact browser payload (`version: 1`) emitted by
@@ -14,6 +15,9 @@ const browserEventSchema = z.object({
         "message",
         "session_start",
         "track_event",
+        "outcome",
+        "request_failure",
+        "timing",
     ]),
     timestamp: z.string().datetime(),
     /** exception/message events: signal level. Defaults per type. */
@@ -21,6 +25,7 @@ const browserEventSchema = z.object({
     message: z.string().max(4000).default(""),
     /** track_event only: the event name (counted, never free-form PII). */
     name: z.string().max(200).optional(),
+    durationMs: z.number().nonnegative().max(120000).optional(),
     stack: z.string().max(32000).optional(),
     errorType: z.string().max(200).optional(),
     filename: z.string().max(1000).optional(),
@@ -42,6 +47,8 @@ const TYPE_TO_ERROR_TYPE = {
     exception: "Error",
     unhandled_rejection: "UnhandledRejection",
     message: "Message",
+    outcome: "OutcomeFailure",
+    request_failure: "HttpRequestError",
 };
 // Content-level gate for the free-form `context` bag. The schema whitelist
 // above is structural; this masks obvious PII/secrets inside whatever a
@@ -69,6 +76,8 @@ const TYPE_TO_SEVERITY = {
     exception: "error",
     unhandled_rejection: "error",
     message: "warning",
+    outcome: "error",
+    request_failure: "error",
 };
 export function normalizeBrowserPayload(payload) {
     const occurrences = [];
@@ -109,6 +118,15 @@ export function normalizeBrowserPayload(payload) {
                 bumpRollup(`event:${name}`, occurredAt, { requestCount: 1 });
             continue;
         }
+        if (event.type === "timing") {
+            const name = event.name === "browser.longtask" ? "browser.longtask"
+                : `browser.resource:${normalizeRoute((event.name ?? "").replace(/^browser\.resource:/, "").split("?")[0].replace(EMAIL_VALUE_RE, REDACTED))}`;
+            bumpRollup(name, occurredAt, { requestCount: 1 });
+            const point = rollups.get(`${name} ${Math.floor(occurredAt.getTime() / 60_000) * 60_000}`);
+            if (point)
+                point.durationSumMs += event.durationMs ?? 0;
+            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
@@ -125,7 +143,9 @@ export function normalizeBrowserPayload(payload) {
             environment: payload.environment,
             release: payload.release ?? null,
             errorType: event.errorType ?? TYPE_TO_ERROR_TYPE[event.type] ?? "Error",
-            message: event.message || "Unknown error",
+            message: event.type === "outcome" ? `${(event.name ?? "outcome").replace(EMAIL_VALUE_RE, REDACTED)}: ${event.message.replace(EMAIL_VALUE_RE, REDACTED)}`
+                : event.type === "request_failure" ? `${normalizeRoute((event.name ?? "request").split("?")[0].replace(EMAIL_VALUE_RE, REDACTED))}: ${event.message}`
+                    : event.message || "Unknown error",
             stack: event.stack ?? null,
             route: event.route ? (event.route.split("?")[0] ?? null) : null,
             method: null,

package/dist/normalize-otlp.js

@@ -1,6 +1,7 @@
 import { normalizeRoute } from "./fingerprint.js";
 import { extractLlmCall } from "./llm.js";
 import { asSeverity, } from "./types.js";
+const EMAIL_VALUE_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
 function attrMap(attributes) {
     const map = new Map();
     for (const attr of attributes ?? []) {
@@ -112,8 +113,11 @@ export function normalizeTraces(request) {
                 const startedAt = nanosToDate(span.startTimeUnixNano);
                 const durationMs = spanDurationMs(span);
                 const kind = spanKind(span.kind);
-                const isError = isErrorStatus(span.status?.code) ||
-                    (statusCode !== null && statusCode >= 500);
+                const hasFailureEvent = (span.events ?? []).some((event) => event.name === "exception" || (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);
                 spans.push({
                     service: resource.service,
                     environment: resource.environment,
@@ -138,6 +142,7 @@ export function normalizeTraces(request) {
                 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";
                     occurrences.push({
                         source: "server",
                         severity: severityOf(eventAttrs, attrs),
@@ -155,19 +160,42 @@ export function normalizeTraces(request) {
                         statusCode,
                         traceId: span.traceId ?? null,
                         sessionId: null,
-                        attributes: null,
+                        attributes: handled ? {
+                            "autter.handled": true,
+                            "autter.sampled": eventAttrs.get("autter.sampled") === "true",
+                        } : null,
+                        occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
+                    });
+                }
+                const failedOutcomes = (span.events ?? []).filter((event) => {
+                    if (event.name !== "autter.outcome")
+                        return false;
+                    return attrMap(event.attributes).get("autter.outcome.status") === "error";
+                });
+                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);
+                    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: null, route, method: methodOf(attrs), statusCode,
+                        traceId: span.traceId ?? null, sessionId: null, attributes: null,
                         occurredAt: nanosToDate(event.timeUnixNano ?? span.startTimeUnixNano),
                     });
                 }
-                if (exceptionEvents.length === 0 && isErrorStatus(span.status?.code)) {
+                if (exceptionEvents.length === 0 && failedOutcomes.length === 0 && isError) {
                     occurrences.push({
                         source: "server",
                         severity: severityOf(new Map(), attrs),
                         service: resource.service,
                         environment: resource.environment,
                         release: resource.release,
-                        errorType: "SpanError",
-                        message: span.status?.message || `${span.name ?? "span"} failed`,
+                        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),

package/dist/profiles.d.ts

@@ -0,0 +1,20 @@
+export interface ProfileSample {
+    profileId: string;
+    sampleIndex: number;
+    service: string;
+    environment: string;
+    release: string;
+    traceId: string;
+    observedAt: Date;
+    sampleType: string;
+    unit: string;
+    stack: string[];
+    value: number;
+}
+export declare function profileTableDDL(db: string): string;
+export declare function decodeProfile(body: Buffer, meta: {
+    service: string;
+    environment: string;
+    release: string;
+    traceId: string;
+}): ProfileSample[];

package/dist/profiles.js

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+import { gunzipSync } from "node:zlib";
+import protobuf from "protobufjs";
+// Only the pprof fields needed for a bounded, symbolized CPU sample index.
+const schema = protobuf.parse(`syntax = "proto3";
+message Profile {
+  repeated ValueType sample_type = 1;
+  repeated Sample sample = 2;
+  repeated Location location = 4;
+  repeated Function function = 5;
+  repeated string string_table = 6;
+  int64 time_nanos = 9;
+}
+message ValueType { int64 type = 1; int64 unit = 2; }
+message Sample { repeated uint64 location_id = 1 [packed=true]; repeated int64 value = 2 [packed=true]; }
+message Location { uint64 id = 1; repeated Line line = 4; }
+message Line { uint64 function_id = 1; int64 line = 2; }
+message Function { uint64 id = 1; int64 name = 2; int64 system_name = 3; int64 filename = 4; }
+`).root.lookupType("Profile");
+export function profileTableDDL(db) {
+    return `CREATE TABLE IF NOT EXISTS ${db}.runtime_profile_samples (
+		org_id String, repository_id String, profile_id String, sample_index UInt16,
+		service LowCardinality(String), environment LowCardinality(String), release String,
+		trace_id String DEFAULT '', observed_at DateTime64(3, 'UTC'),
+		sample_type LowCardinality(String), unit LowCardinality(String),
+		stack Array(String), value UInt64
+	) ENGINE = MergeTree PARTITION BY toDate(observed_at)
+	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) {
+    if (body.length === 0 || body.length > 1024 * 1024)
+        throw new Error("invalid profile size");
+    const payload = body[0] === 0x1f && body[1] === 0x8b
+        ? gunzipSync(body, { maxOutputLength: 1024 * 1024 }) : body;
+    const profile = schema.toObject(schema.decode(payload), { longs: String, arrays: true });
+    const strings = profile.stringTable ?? [];
+    const locations = new Map((profile.location ?? []).map((location) => [location.id, location]));
+    const functions = new Map((profile.function ?? []).map((fn) => [fn.id, fn]));
+    const type = profile.sampleType?.[0];
+    const observedMs = Number(BigInt(profile.timeNanos ?? "0") / 1000000n);
+    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()) {
+        const stack = (sample.locationId ?? []).slice(0, 64).flatMap((id) => {
+            const fnId = locations.get(id)?.line?.[0]?.functionId;
+            const name = fnId ? strings[Number(functions.get(fnId)?.name ?? 0)] : undefined;
+            return name ? [name.slice(0, 200)] : [];
+        });
+        const value = Number(sample.value?.[0] ?? 0);
+        if (!stack.length || !Number.isSafeInteger(value) || value <= 0)
+            continue;
+        samples.push({ profileId, sampleIndex, ...meta, observedAt,
+            sampleType: (strings[Number(type?.type ?? 0)] ?? "samples").slice(0, 80),
+            unit: (strings[Number(type?.unit ?? 0)] ?? "count").slice(0, 40),
+            stack, value });
+    }
+    return samples;
+}

package/dist/server.js

@@ -6,6 +6,8 @@ import { deriveFields, fingerprintOccurrence, occurrenceIdFor, } from "./fingerp
 import { browserPayloadSchema, normalizeBrowserPayload, } from "./normalize-browser.js";
 import { normalizeMetrics, normalizeTraces, } from "./normalize-otlp.js";
 import { decodeMetricsRequest, decodeTraceRequest } from "./otlp-proto.js";
+import { decodeProfile } from "./profiles.js";
+import { validateSourceMap } from "./source-maps.js";
 import { SinkForwarder } from "./sink.js";
 export function createIngesterApp(config) {
     const store = new ClickHouseStore(config);
@@ -18,6 +20,8 @@ export function createIngesterApp(config) {
     const clientRateLimiter = new RateLimiter(config.clientRateLimitPerMinute);
     const app = express();
     app.disable("x-powered-by");
+    app.use(express.raw({ limit: "1mb", type: ["application/x-pprof"] }));
+    app.use("/v1/sourcemaps", express.json({ limit: "5mb" }));
     app.use(express.json({
         limit: config.maxBodyBytes,
         type: ["application/json"],
@@ -140,6 +144,57 @@ export function createIngesterApp(config) {
         }
         res.status(200).json({ partialSuccess: {} });
     }
+    app.post("/v1/profiles", async (req, res) => {
+        const ctx = await authenticate(req, res, "otlp");
+        if (!ctx)
+            return;
+        if (!req.is("application/x-pprof") || !Buffer.isBuffer(req.body)) {
+            res.status(415).json({ error: "expected application/x-pprof" });
+            return;
+        }
+        const service = req.header("x-autter-service")?.trim() ?? "";
+        const environment = req.header("x-autter-environment")?.trim() || "production";
+        const release = req.header("x-autter-release")?.trim() ?? "";
+        const traceId = req.header("x-autter-trace-id")?.trim() ?? "";
+        if (!/^[a-zA-Z0-9._-]{1,200}$/.test(service) || environment.length > 100 || release.length > 200 || (traceId && !/^[a-f0-9]{32}$/.test(traceId))) {
+            res.status(400).json({ error: "invalid profile metadata" });
+            return;
+        }
+        let samples;
+        try {
+            samples = decodeProfile(req.body, { service, environment, release, traceId });
+            if (!samples.length)
+                throw new Error("empty profile");
+        }
+        catch {
+            res.status(400).json({ error: "invalid or unsymbolized profile" });
+            return;
+        }
+        try {
+            await store.insertProfileSamples(ctx, samples);
+            res.status(202).json({ profileId: samples[0].profileId, samples: samples.length });
+        }
+        catch (err) {
+            storageError(res, err);
+        }
+    });
+    app.post("/v1/sourcemaps", async (req, res) => {
+        const ctx = await authenticate(req, res, "otlp");
+        if (!ctx)
+            return;
+        const sourceMap = validateSourceMap(req.body);
+        if (!sourceMap) {
+            res.status(400).json({ error: "invalid source map" });
+            return;
+        }
+        try {
+            await store.insertSourceMap(ctx, sourceMap);
+            res.status(202).json({ accepted: true });
+        }
+        catch (err) {
+            storageError(res, err);
+        }
+    });
     app.post("/v1/traces", async (req, res) => {
         const ctx = await authenticate(req, res, "otlp");
         if (!ctx)

package/dist/source-maps.d.ts

@@ -0,0 +1,6 @@
+export declare function sourceMapTableDDL(db: string): string;
+export declare function validateSourceMap(body: unknown): {
+    release: string;
+    filename: string;
+    map: string;
+} | null;

package/dist/source-maps.js

@@ -0,0 +1,41 @@
+export function sourceMapTableDDL(db) {
+    return `CREATE TABLE IF NOT EXISTS ${db}.runtime_source_maps (
+		org_id String, repository_id String, release String, filename String,
+		map String CODEC(ZSTD(3)), uploaded_at DateTime64(3, 'UTC') DEFAULT now64(3)
+	) ENGINE = ReplacingMergeTree(uploaded_at)
+	ORDER BY (org_id, repository_id, release, filename)
+	TTL toDateTime(uploaded_at) + INTERVAL 30 DAY`;
+}
+export function validateSourceMap(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const input = body;
+    if (typeof input.release !== "string" || !/^[a-zA-Z0-9._-]{1,200}$/.test(input.release))
+        return null;
+    if (typeof input.filename !== "string" || input.filename.length > 1000)
+        return null;
+    let filename;
+    try {
+        filename = new URL(input.filename, "https://autter.invalid").pathname;
+    }
+    catch {
+        return null;
+    }
+    if (!filename.endsWith(".js"))
+        return null;
+    let parsed;
+    try {
+        parsed = typeof input.map === "string" ? JSON.parse(input.map) : input.map;
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || parsed.version !== 3 || typeof parsed.mappings !== "string" || !Array.isArray(parsed.sources))
+        return null;
+    // Source contents are unnecessary for position lookup and may contain secrets.
+    const { sourcesContent: _omitted, ...safe } = parsed;
+    const map = JSON.stringify(safe);
+    if (map.length > 5 * 1024 * 1024)
+        return null;
+    return { release: input.release, filename, map };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@autter/otlp-ingester",
-	"version": "1.3.1",
+	"version": "1.3.2",
 	"description": "Self-hostable OTLP + browser-error ingest service for Autter Runtime: normalises telemetry into a per-repo ClickHouse data model",
 	"license": "MIT",
 	"type": "module",