@autter/otlp-ingester 1.0.0 → 1.2.0

package/dist/sink.d.ts

@@ -0,0 +1,103 @@
+import type { IngesterConfig } from "./config.js";
+import type { IngestContext, RuntimeLlmCall, RuntimeMetricPoint, RuntimeOccurrence } from "./types.js";
+/**
+ * At-least-once delivery to the sink webhook.
+ *
+ * The sink feeds the consumer's issue grouping and incident detection, so a
+ * lost batch means silently missing error occurrences — a single
+ * fire-and-forget POST is not enough (a routine consumer deploy is longer
+ * than one request timeout). Batches therefore queue in memory and retry
+ * with exponential backoff until delivered, permanently rejected, or the
+ * bounded buffer overflows.
+ *
+ * Durability boundary: the queue is in-memory only. Everything forwarded
+ * here was already written to ClickHouse (ingest 503s otherwise), so after
+ * a process crash or an overflow/permanent drop the consumer recovers by
+ * replaying the logged time range from ClickHouse — see
+ * docs/ARCHITECTURE.md "Sink webhook". Every batch carries a unique
+ * `batchId` so consumers can deduplicate retried deliveries.
+ */
+/** Delivery timing/concurrency knobs; overridable for tests. */
+export interface SinkTuning {
+    /** Base delay before the second attempt; doubles per attempt to the cap. */
+    retryBaseMs: number;
+    retryCapMs: number;
+    requestTimeoutMs: number;
+    /** Deliveries run concurrently while healthy, serially while failing. */
+    healthyConcurrency: number;
+}
+/**
+ * Operational counters for /healthz. Failure detail is reduced to a fixed
+ * category (`timeout`, `connection_error`, `http_<status>`, `error`) — the
+ * health endpoint is unauthenticated, so raw transport/exception text stays
+ * in server-side logs only.
+ */
+export interface SinkStats {
+    queued: number;
+    queuedBytes: number;
+    inFlight: number;
+    delivered: number;
+    retried: number;
+    droppedOverflow: number;
+    droppedPermanent: number;
+    consecutiveFailures: number;
+    lastFailureAt: string | null;
+    lastFailureReason: string | null;
+    oldestQueuedSince: string | null;
+}
+export declare class SinkForwarder {
+    private readonly config;
+    private readonly fetchImpl;
+    /** Always sorted by `seq`: queue[0] is the oldest batch. */
+    private readonly queue;
+    private queuedBytes;
+    /** Per-org share of queuedBytes — overflow evicts from the heaviest org. */
+    private readonly queuedBytesByOrg;
+    private inFlight;
+    private timer;
+    private stopped;
+    private seqCounter;
+    private delivered;
+    private retried;
+    private droppedOverflow;
+    private droppedPermanent;
+    private consecutiveFailures;
+    /**
+     * Bumped on every failure. A success only clears consecutiveFailures if
+     * no failure happened after that request STARTED — a concurrent success
+     * that overlapped a failure proves nothing about current sink health and
+     * must not reopen full concurrency mid-outage.
+     */
+    private failureEpoch;
+    private lastFailureAt;
+    private lastFailureReason;
+    private readonly tuning;
+    constructor(config: IngesterConfig, fetchImpl?: typeof fetch, tuning?: Partial<SinkTuning>);
+    /** Queue a batch for delivery. No-op when there is nothing to send. */
+    enqueue(ctx: IngestContext, occurrences: RuntimeOccurrence[], metricPoints?: RuntimeMetricPoint[], llmCalls?: RuntimeLlmCall[]): void;
+    stats(): SinkStats;
+    pendingCount(): number;
+    /** Stop scheduling new deliveries (shutdown). Queued batches are logged
+     * by the caller — they are recoverable from ClickHouse, not from here. */
+    stop(): void;
+    /** Serialize one delivery payload; `seq` pins its age for ordering. */
+    private buildBatch;
+    private maxBufferedBytes;
+    private track;
+    private untrack;
+    /** Re-insert a retrying batch at its age position (queue is seq-sorted),
+     * so overflow eviction still drops the genuinely oldest signals first. */
+    private insertBySeq;
+    /**
+     * Oldest-first eviction, charged to the heaviest tenant: the freshest
+     * signals matter most to grouping, and one org flooding the shared
+     * buffer must not evict everyone else's batches.
+     */
+    private enforceBounds;
+    /** The oldest batch of the org holding the most buffered bytes. */
+    private evictOne;
+    private currentLimit;
+    private pump;
+    private scheduleWake;
+    private send;
+}

package/dist/sink.js

@@ -0,0 +1,314 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TUNING = {
+    retryBaseMs: 1000,
+    retryCapMs: 60_000,
+    requestTimeoutMs: 10_000,
+    healthyConcurrency: 4,
+};
+/** Fixed failure category — safe for the unauthenticated health response. */
+function failureReason(err) {
+    if (err instanceof Error) {
+        if (err.name === "TimeoutError" || err.name === "AbortError") {
+            return "timeout";
+        }
+        // fetch surfaces DNS/TLS/socket failures as TypeError.
+        if (err instanceof TypeError)
+            return "connection_error";
+    }
+    return "error";
+}
+export class SinkForwarder {
+    config;
+    fetchImpl;
+    /** Always sorted by `seq`: queue[0] is the oldest batch. */
+    queue = [];
+    queuedBytes = 0;
+    /** Per-org share of queuedBytes — overflow evicts from the heaviest org. */
+    queuedBytesByOrg = new Map();
+    inFlight = 0;
+    timer = null;
+    stopped = false;
+    seqCounter = 0;
+    delivered = 0;
+    retried = 0;
+    droppedOverflow = 0;
+    droppedPermanent = 0;
+    consecutiveFailures = 0;
+    /**
+     * Bumped on every failure. A success only clears consecutiveFailures if
+     * no failure happened after that request STARTED — a concurrent success
+     * that overlapped a failure proves nothing about current sink health and
+     * must not reopen full concurrency mid-outage.
+     */
+    failureEpoch = 0;
+    lastFailureAt = null;
+    lastFailureReason = null;
+    tuning;
+    constructor(config, fetchImpl = fetch, tuning = {}) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+        this.tuning = { ...DEFAULT_TUNING, ...tuning };
+    }
+    /** Queue a batch for delivery. No-op when there is nothing to send. */
+    enqueue(ctx, occurrences, metricPoints = [], llmCalls = []) {
+        if (!this.config.sinkUrl || this.stopped)
+            return;
+        if (occurrences.length === 0 &&
+            metricPoints.length === 0 &&
+            llmCalls.length === 0) {
+            return;
+        }
+        const batch = this.buildBatch(ctx, occurrences, metricPoints, llmCalls);
+        // A batch bigger than the whole buffer could never be admitted without
+        // evicting everyone else — and the consumer's body cap would reject it
+        // anyway. Drop it alone instead of letting it flush the queue.
+        if (batch.bytes > this.maxBufferedBytes()) {
+            this.droppedOverflow += 1;
+            console.warn(`sink batch ${batch.batchId} (org ${batch.orgId}) exceeds the buffer cap (${batch.bytes} bytes) — dropped; replay signals ${batch.signalsFrom ?? "?"} .. ${batch.signalsTo ?? "?"} from ClickHouse`);
+            return;
+        }
+        this.queue.push(batch);
+        this.track(batch);
+        this.enforceBounds();
+        this.pump();
+    }
+    stats() {
+        const oldest = this.queue[0]?.enqueuedAt ?? null;
+        return {
+            queued: this.queue.length,
+            queuedBytes: this.queuedBytes,
+            inFlight: this.inFlight,
+            delivered: this.delivered,
+            retried: this.retried,
+            droppedOverflow: this.droppedOverflow,
+            droppedPermanent: this.droppedPermanent,
+            consecutiveFailures: this.consecutiveFailures,
+            lastFailureAt: this.lastFailureAt,
+            lastFailureReason: this.lastFailureReason,
+            oldestQueuedSince: oldest ? new Date(oldest).toISOString() : null,
+        };
+    }
+    pendingCount() {
+        return this.queue.length + this.inFlight;
+    }
+    /** Stop scheduling new deliveries (shutdown). Queued batches are logged
+     * by the caller — they are recoverable from ClickHouse, not from here. */
+    stop() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    /** Serialize one delivery payload; `seq` pins its age for ordering. */
+    buildBatch(ctx, occurrences, metricPoints, llmCalls) {
+        const batchId = randomUUID();
+        const body = JSON.stringify({
+            version: 1,
+            batchId,
+            orgId: ctx.orgId,
+            repositoryId: ctx.repositoryId,
+            occurrences: occurrences.map((o) => ({
+                ...o,
+                occurredAt: o.occurredAt.toISOString(),
+            })),
+            metrics: metricPoints.map((p) => ({
+                ...p,
+                bucketAt: p.bucketAt.toISOString(),
+            })),
+            llmCalls: llmCalls.map((c) => ({
+                ...c,
+                startedAt: c.startedAt.toISOString(),
+            })),
+        });
+        const range = signalRange(occurrences, metricPoints, llmCalls);
+        return {
+            batchId,
+            orgId: ctx.orgId,
+            body,
+            bytes: Buffer.byteLength(body),
+            seq: ++this.seqCounter,
+            attempts: 0,
+            nextAttemptAt: Date.now(),
+            signalsFrom: range.from,
+            signalsTo: range.to,
+            enqueuedAt: Date.now(),
+        };
+    }
+    maxBufferedBytes() {
+        return this.config.sinkMaxBufferedMb * 1024 * 1024;
+    }
+    track(batch) {
+        this.queuedBytes += batch.bytes;
+        this.queuedBytesByOrg.set(batch.orgId, (this.queuedBytesByOrg.get(batch.orgId) ?? 0) + batch.bytes);
+    }
+    untrack(batch) {
+        this.queuedBytes -= batch.bytes;
+        const left = (this.queuedBytesByOrg.get(batch.orgId) ?? 0) - batch.bytes;
+        if (left > 0)
+            this.queuedBytesByOrg.set(batch.orgId, left);
+        else
+            this.queuedBytesByOrg.delete(batch.orgId);
+    }
+    /** Re-insert a retrying batch at its age position (queue is seq-sorted),
+     * so overflow eviction still drops the genuinely oldest signals first. */
+    insertBySeq(batch) {
+        const at = this.queue.findIndex((b) => b.seq > batch.seq);
+        if (at === -1)
+            this.queue.push(batch);
+        else
+            this.queue.splice(at, 0, batch);
+    }
+    /**
+     * Oldest-first eviction, charged to the heaviest tenant: the freshest
+     * signals matter most to grouping, and one org flooding the shared
+     * buffer must not evict everyone else's batches.
+     */
+    enforceBounds() {
+        const maxBytes = this.maxBufferedBytes();
+        while (this.queue.length > this.config.sinkMaxBufferedBatches ||
+            (this.queuedBytes > maxBytes && this.queue.length > 1)) {
+            const dropped = this.evictOne();
+            if (!dropped)
+                break;
+            this.droppedOverflow += 1;
+            console.warn(`sink buffer overflow: dropped batch ${dropped.batchId} (org ${dropped.orgId}, signals ${dropped.signalsFrom ?? "?"} .. ${dropped.signalsTo ?? "?"}) — replay this range from ClickHouse`);
+        }
+    }
+    /** The oldest batch of the org holding the most buffered bytes. */
+    evictOne() {
+        let heaviest = null;
+        let heaviestBytes = -1;
+        for (const [orgId, bytes] of this.queuedBytesByOrg) {
+            if (bytes > heaviestBytes) {
+                heaviest = orgId;
+                heaviestBytes = bytes;
+            }
+        }
+        const at = heaviest
+            ? this.queue.findIndex((b) => b.orgId === heaviest)
+            : 0;
+        const [dropped] = this.queue.splice(at === -1 ? 0 : at, 1);
+        if (!dropped)
+            return null;
+        this.untrack(dropped);
+        return dropped;
+    }
+    currentLimit() {
+        return this.consecutiveFailures > 0 ? 1 : this.tuning.healthyConcurrency;
+    }
+    pump() {
+        if (this.stopped || !this.config.sinkUrl)
+            return;
+        const limit = this.currentLimit();
+        const now = Date.now();
+        while (this.inFlight < limit) {
+            const index = this.queue.findIndex((b) => b.nextAttemptAt <= now);
+            if (index === -1)
+                break;
+            const [batch] = this.queue.splice(index, 1);
+            if (!batch)
+                break;
+            this.untrack(batch);
+            this.inFlight += 1;
+            void this.send(batch).finally(() => {
+                this.inFlight -= 1;
+                this.pump();
+            });
+        }
+        this.scheduleWake();
+    }
+    scheduleWake() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.stopped || this.queue.length === 0)
+            return;
+        // At capacity there is nothing to wake for: every completion pumps
+        // again anyway, and a 0 ms timer here would spin the event loop while
+        // a ready batch waits on a slow in-flight request.
+        if (this.inFlight >= this.currentLimit())
+            return;
+        const next = Math.min(...this.queue.map((b) => b.nextAttemptAt));
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.pump();
+        }, Math.max(0, next - Date.now()));
+        this.timer.unref();
+    }
+    async send(batch) {
+        batch.attempts += 1;
+        const epochAtStart = this.failureEpoch;
+        let reason = null;
+        /** Raw failure text — logged server-side, never surfaced in stats. */
+        let detail = null;
+        let permanent = false;
+        try {
+            const res = await this.fetchImpl(this.config.sinkUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(this.config.sinkToken
+                        ? { authorization: `Bearer ${this.config.sinkToken}` }
+                        : {}),
+                },
+                body: batch.body,
+                signal: AbortSignal.timeout(this.tuning.requestTimeoutMs),
+            });
+            // Drain the body so keep-alive sockets are reusable; its content is
+            // irrelevant to delivery.
+            await res.text().catch(() => { });
+            if (res.ok) {
+                this.delivered += 1;
+                if (epochAtStart === this.failureEpoch) {
+                    this.consecutiveFailures = 0;
+                }
+                return;
+            }
+            reason = `http_${res.status}`;
+            detail = `sink responded ${res.status}`;
+            // 4xx (except timeout/rate-limit) means the consumer rejected the
+            // batch — retrying the same body cannot succeed.
+            permanent = res.status < 500 && res.status !== 408 && res.status !== 429;
+        }
+        catch (err) {
+            reason = failureReason(err);
+            detail = err instanceof Error ? err.message : String(err);
+        }
+        this.failureEpoch += 1;
+        this.consecutiveFailures += 1;
+        this.lastFailureAt = new Date().toISOString();
+        this.lastFailureReason = reason;
+        if (permanent || batch.attempts >= this.config.sinkMaxAttempts) {
+            this.droppedPermanent += 1;
+            console.error(`sink delivery gave up after ${batch.attempts} attempt(s) (${detail}): batch ${batch.batchId} (signals ${batch.signalsFrom ?? "?"} .. ${batch.signalsTo ?? "?"}) — replay this range from ClickHouse`);
+            return;
+        }
+        this.retried += 1;
+        // Full jitter avoids retry stampedes when the consumer comes back.
+        const backoff = Math.min(this.tuning.retryCapMs, this.tuning.retryBaseMs * 2 ** (batch.attempts - 1));
+        batch.nextAttemptAt = Date.now() + backoff / 2 + Math.random() * (backoff / 2);
+        this.insertBySeq(batch);
+        this.track(batch);
+        if (batch.attempts === 1 || batch.attempts % 5 === 0) {
+            console.warn(`sink delivery failed (attempt ${batch.attempts}/${this.config.sinkMaxAttempts}, will retry): ${detail}`);
+        }
+        this.enforceBounds();
+        this.scheduleWake();
+    }
+}
+/** ISO range across every signal in the batch — the replay hint on drops. */
+function signalRange(occurrences, metricPoints, llmCalls) {
+    const timestamps = [
+        ...occurrences.map((o) => o.occurredAt),
+        ...metricPoints.map((p) => p.bucketAt),
+        ...llmCalls.map((c) => c.startedAt),
+    ].map((d) => d.getTime());
+    if (timestamps.length === 0)
+        return { from: null, to: null };
+    return {
+        from: new Date(Math.min(...timestamps)).toISOString(),
+        to: new Date(Math.max(...timestamps)).toISOString(),
+    };
+}

package/dist/stack-fixtures.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Representative raw stack traces for every officially-supported runtime,
+ * exactly as their OpenTelemetry SDKs put them on the `exception.stacktrace`
+ * span attribute (or the browser relay's `stack` field). These drive the
+ * golden fingerprint tests in fingerprint.test.ts.
+ *
+ * Each language provides three variants of the SAME family of errors:
+ *   - `primary`  — the defect under test.
+ *   - `sibling`  — a DIFFERENT defect (different top function/file) that
+ *     carries the SAME error message. It must fingerprint separately: this is
+ *     the regression the pipeline exists to prevent (before per-language
+ *     parsing, Go/Rust frames were dropped and these collided into one issue).
+ *   - `redeploy` — the primary defect after a rebuild that shifted every line
+ *     number (and, for Go, pointer offsets/addresses/goroutine ids). It must
+ *     fingerprint IDENTICALLY to `primary`, proving grouping is stable across
+ *     re-deploys and repeated ingestion.
+ */
+export interface StackFixture {
+    primary: string;
+    sibling: string;
+    redeploy: string;
+    /** Golden normalised top frames for `primary` (locks the parser output). */
+    primaryFrames: string[];
+}
+export declare const STACK_FIXTURES: Record<string, StackFixture>;

package/dist/stack-fixtures.js

@@ -0,0 +1,231 @@
+/**
+ * Representative raw stack traces for every officially-supported runtime,
+ * exactly as their OpenTelemetry SDKs put them on the `exception.stacktrace`
+ * span attribute (or the browser relay's `stack` field). These drive the
+ * golden fingerprint tests in fingerprint.test.ts.
+ *
+ * Each language provides three variants of the SAME family of errors:
+ *   - `primary`  — the defect under test.
+ *   - `sibling`  — a DIFFERENT defect (different top function/file) that
+ *     carries the SAME error message. It must fingerprint separately: this is
+ *     the regression the pipeline exists to prevent (before per-language
+ *     parsing, Go/Rust frames were dropped and these collided into one issue).
+ *   - `redeploy` — the primary defect after a rebuild that shifted every line
+ *     number (and, for Go, pointer offsets/addresses/goroutine ids). It must
+ *     fingerprint IDENTICALLY to `primary`, proving grouping is stable across
+ *     re-deploys and repeated ingestion.
+ */
+// ── Go ──────────────────────────────────────────────────────────────────────
+const GO_PRIMARY = `panic: runtime error: invalid memory address or nil pointer dereference
+[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x1a2b3c]
+
+goroutine 42 [running]:
+main.(*OrderService).Process(0xc0000b4000, 0xc0000d2000)
+	/app/orders/service.go:128 +0x1a5
+main.(*Handler).ServeHTTP(0xc0000a2000, {0x8f2a40, 0xc0000b0000})
+	/app/web/handler.go:64 +0x2c8
+net/http.(*conn).serve(0xc0001a4000, {0x8f2b20, 0xc0000c2000})
+	/usr/local/go/src/net/http/server.go:2092 +0x1a5
+created by net/http.(*Server).Serve in goroutine 1
+	/usr/local/go/src/net/http/server.go:3285 +0x33e`;
+const GO_SIBLING = `panic: runtime error: invalid memory address or nil pointer dereference
+[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x4d5e6f]
+
+goroutine 88 [running]:
+main.(*PaymentService).Charge(0xc0000f4000, 0xc000102000)
+	/app/payments/service.go:212 +0x9c
+main.(*Handler).ServeHTTP(0xc0000a2000, {0x8f2a40, 0xc0000b0000})
+	/app/web/handler.go:64 +0x2c8
+net/http.(*conn).serve(0xc0001a4000, {0x8f2b20, 0xc0000c2000})
+	/usr/local/go/src/net/http/server.go:2092 +0x1a5`;
+const GO_REDEPLOY = `panic: runtime error: invalid memory address or nil pointer dereference
+[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x7a8b9c]
+
+goroutine 15 [running]:
+main.(*OrderService).Process(0xc000200000, 0xc000210000)
+	/app/orders/service.go:140 +0x1f2
+main.(*Handler).ServeHTTP(0xc000202000, {0x8f2a40, 0xc000208000})
+	/app/web/handler.go:71 +0x300
+net/http.(*conn).serve(0xc000300000, {0x8f2b20, 0xc000310000})
+	/usr/local/go/src/net/http/server.go:2092 +0x1a5
+created by net/http.(*Server).Serve in goroutine 1
+	/usr/local/go/src/net/http/server.go:3285 +0x33e`;
+// ── Rust ────────────────────────────────────────────────────────────────────
+const RUST_PRIMARY = `thread 'actix-rt|system:0|arbiter:1' panicked at src/orders/service.rs:88:21:
+called \`Result::unwrap()\` on an \`Err\` value: PoolTimedOut
+stack backtrace:
+   0: rust_begin_unwind
+             at /rustc/abc123/library/std/src/panicking.rs:665:5
+   1: core::panicking::panic_fmt
+             at /rustc/abc123/library/core/src/panicking.rs:74:14
+   2: core::result::unwrap_failed
+             at /rustc/abc123/library/core/src/result.rs:1679:5
+   3: myapp::orders::service::OrderService::process
+             at ./src/orders/service.rs:88:21
+   4: myapp::web::handler::handle_request
+             at ./src/web/handler.rs:42:9`;
+const RUST_SIBLING = `thread 'main' panicked at src/payments/service.rs:143:10:
+called \`Result::unwrap()\` on an \`Err\` value: PoolTimedOut
+stack backtrace:
+   0: rust_begin_unwind
+             at /rustc/abc123/library/std/src/panicking.rs:665:5
+   1: core::panicking::panic_fmt
+             at /rustc/abc123/library/core/src/panicking.rs:74:14
+   2: core::result::unwrap_failed
+             at /rustc/abc123/library/core/src/result.rs:1679:5
+   3: myapp::payments::service::PaymentService::charge
+             at ./src/payments/service.rs:143:10
+   4: myapp::web::handler::handle_request
+             at ./src/web/handler.rs:42:9`;
+const RUST_REDEPLOY = `thread 'main' panicked at src/orders/service.rs:95:21:
+called \`Result::unwrap()\` on an \`Err\` value: PoolTimedOut
+stack backtrace:
+   0: rust_begin_unwind
+             at /rustc/abc123/library/std/src/panicking.rs:665:5
+   1: core::panicking::panic_fmt
+             at /rustc/abc123/library/core/src/panicking.rs:74:14
+   2: core::result::unwrap_failed
+             at /rustc/abc123/library/core/src/result.rs:1679:5
+   3: myapp::orders::service::OrderService::process
+             at ./src/orders/service.rs:95:21
+   4: myapp::web::handler::handle_request
+             at ./src/web/handler.rs:47:9`;
+// ── Java / JVM ──────────────────────────────────────────────────────────────
+const JAVA_PRIMARY = `java.lang.NullPointerException: Cannot invoke "com.example.model.Order.total()" because "order" is null
+	at com.example.orders.OrderService.process(OrderService.java:88)
+	at com.example.web.RequestHandler.handle(RequestHandler.java:42)
+	at com.example.web.RequestHandler.doGet(RequestHandler.java:31)
+	at jakarta.servlet.http.HttpServlet.service(HttpServlet.java:687)
+	at java.base/java.lang.Thread.run(Thread.java:1583)
+Caused by: java.lang.IllegalStateException: order not loaded
+	at com.example.orders.OrderLoader.require(OrderLoader.java:55)
+	... 4 more`;
+const JAVA_SIBLING = `java.lang.NullPointerException: Cannot invoke "com.example.model.Order.total()" because "order" is null
+	at com.example.billing.InvoiceService.render(InvoiceService.java:140)
+	at com.example.web.RequestHandler.handle(RequestHandler.java:42)
+	at com.example.web.RequestHandler.doGet(RequestHandler.java:31)
+	at jakarta.servlet.http.HttpServlet.service(HttpServlet.java:687)
+	at java.base/java.lang.Thread.run(Thread.java:1583)`;
+const JAVA_REDEPLOY = `java.lang.NullPointerException: Cannot invoke "com.example.model.Order.total()" because "order" is null
+	at com.example.orders.OrderService.process(OrderService.java:92)
+	at com.example.web.RequestHandler.handle(RequestHandler.java:45)
+	at com.example.web.RequestHandler.doGet(RequestHandler.java:33)
+	at jakarta.servlet.http.HttpServlet.service(HttpServlet.java:690)
+	at java.base/java.lang.Thread.run(Thread.java:1589)`;
+// ── .NET ────────────────────────────────────────────────────────────────────
+const DOTNET_PRIMARY = `System.NullReferenceException: Object reference not set to an instance of an object.
+   at MyApp.Orders.OrderService.Process(Order order) in C:\\src\\MyApp\\Orders\\OrderService.cs:line 88
+   at MyApp.Web.RequestHandler.HandleAsync(HttpContext context) in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 42
+   at MyApp.Web.RequestHandler.<HandleAsync>d__4.MoveNext() in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 39
+   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](ref TStateMachine stateMachine)
+   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(ref Task currentTaskSlot)`;
+const DOTNET_SIBLING = `System.NullReferenceException: Object reference not set to an instance of an object.
+   at MyApp.Billing.InvoiceService.Render(Invoice invoice) in C:\\src\\MyApp\\Billing\\InvoiceService.cs:line 205
+   at MyApp.Web.RequestHandler.HandleAsync(HttpContext context) in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 42
+   at MyApp.Web.RequestHandler.<HandleAsync>d__4.MoveNext() in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 39
+   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](ref TStateMachine stateMachine)
+   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(ref Task currentTaskSlot)`;
+const DOTNET_REDEPLOY = `System.NullReferenceException: Object reference not set to an instance of an object.
+   at MyApp.Orders.OrderService.Process(Order order) in C:\\src\\MyApp\\Orders\\OrderService.cs:line 94
+   at MyApp.Web.RequestHandler.HandleAsync(HttpContext context) in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 47
+   at MyApp.Web.RequestHandler.<HandleAsync>d__4.MoveNext() in C:\\src\\MyApp\\Web\\RequestHandler.cs:line 44
+   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](ref TStateMachine stateMachine)
+   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(ref Task currentTaskSlot)`;
+// ── JavaScript / Node (V8) ──────────────────────────────────────────────────
+const NODE_PRIMARY = `TypeError: Cannot read properties of undefined (reading 'total')
+    at OrderService.process (/app/dist/orders/service.js:128:35)
+    at RequestHandler.handle (/app/dist/web/handler.js:64:20)
+    at /app/dist/web/router.js:22:9
+    at processTicksAndRejections (node:internal/process/task_queues:95:5)`;
+const NODE_SIBLING = `TypeError: Cannot read properties of undefined (reading 'total')
+    at PaymentService.charge (/app/dist/payments/service.js:212:18)
+    at RequestHandler.handle (/app/dist/web/handler.js:64:20)
+    at /app/dist/web/router.js:22:9
+    at processTicksAndRejections (node:internal/process/task_queues:95:5)`;
+const NODE_REDEPLOY = `TypeError: Cannot read properties of undefined (reading 'total')
+    at OrderService.process (/app/dist/orders/service.js:131:35)
+    at RequestHandler.handle (/app/dist/web/handler.js:70:20)
+    at /app/dist/web/router.js:25:9
+    at processTicksAndRejections (node:internal/process/task_queues:95:5)`;
+// ── Python ──────────────────────────────────────────────────────────────────
+const PYTHON_PRIMARY = `Traceback (most recent call last):
+  File "/app/web/handler.py", line 42, in handle
+    return self.service.process(order)
+  File "/app/orders/service.py", line 88, in process
+    raise ValueError(f"order {order_id} is invalid")
+ValueError: order 4821 is invalid`;
+const PYTHON_SIBLING = `Traceback (most recent call last):
+  File "/app/web/handler.py", line 42, in handle
+    return self.service.process(order)
+  File "/app/billing/invoice.py", line 205, in render
+    raise ValueError(f"order {order_id} is invalid")
+ValueError: order 7734 is invalid`;
+export const STACK_FIXTURES = {
+    go: {
+        primary: GO_PRIMARY,
+        sibling: GO_SIBLING,
+        redeploy: GO_REDEPLOY,
+        primaryFrames: [
+            "main.(*OrderService).Process (/app/orders/service.go)",
+            "main.(*Handler).ServeHTTP (/app/web/handler.go)",
+            "net/http.(*conn).serve (/usr/local/go/src/net/http/server.go)",
+            "net/http.(*Server).Serve (/usr/local/go/src/net/http/server.go)",
+        ],
+    },
+    rust: {
+        primary: RUST_PRIMARY,
+        sibling: RUST_SIBLING,
+        redeploy: RUST_REDEPLOY,
+        primaryFrames: [
+            "rust_begin_unwind (/rustc/abc123/library/std/src/panicking.rs)",
+            "core::panicking::panic_fmt (/rustc/abc123/library/core/src/panicking.rs)",
+            "core::result::unwrap_failed (/rustc/abc123/library/core/src/result.rs)",
+            "myapp::orders::service::OrderService::process (./src/orders/service.rs)",
+            "myapp::web::handler::handle_request (./src/web/handler.rs)",
+        ],
+    },
+    java: {
+        primary: JAVA_PRIMARY,
+        sibling: JAVA_SIBLING,
+        redeploy: JAVA_REDEPLOY,
+        primaryFrames: [
+            "com.example.orders.OrderService.process(OrderService.java)",
+            "com.example.web.RequestHandler.handle(RequestHandler.java)",
+            "com.example.web.RequestHandler.doGet(RequestHandler.java)",
+            "jakarta.servlet.http.HttpServlet.service(HttpServlet.java)",
+            "java.base/java.lang.Thread.run(Thread.java)",
+        ],
+    },
+    dotnet: {
+        primary: DOTNET_PRIMARY,
+        sibling: DOTNET_SIBLING,
+        redeploy: DOTNET_REDEPLOY,
+        primaryFrames: [
+            "MyApp.Orders.OrderService.Process (C:\\src\\MyApp\\Orders\\OrderService.cs)",
+            "MyApp.Web.RequestHandler.HandleAsync (C:\\src\\MyApp\\Web\\RequestHandler.cs)",
+            "MyApp.Web.RequestHandler.<HandleAsync>d__4.MoveNext (C:\\src\\MyApp\\Web\\RequestHandler.cs)",
+            "System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine]",
+            "System.Threading.Tasks.Task.ExecuteWithThreadLocal",
+        ],
+    },
+    node: {
+        primary: NODE_PRIMARY,
+        sibling: NODE_SIBLING,
+        redeploy: NODE_REDEPLOY,
+        primaryFrames: [
+            "at OrderService.process (/app/dist/orders/service.js",
+            "at RequestHandler.handle (/app/dist/web/handler.js",
+            "at /app/dist/web/router.js",
+            "at processTicksAndRejections (node:internal/process/task_queues",
+        ],
+    },
+    python: {
+        primary: PYTHON_PRIMARY,
+        sibling: PYTHON_SIBLING,
+        redeploy: PYTHON_PRIMARY,
+        primaryFrames: [
+            'File "/app/web/handler.py", line 42, in handle',
+            'File "/app/orders/service.py", line 88, in process',
+        ],
+    },
+};