@autter/otlp-ingester 1.7.0 → 1.9.0

package/dist/sink.d.ts

@@ -26,6 +26,17 @@ export interface SinkTuning {
     /** Deliveries run concurrently while healthy, serially while failing. */
     healthyConcurrency: number;
 }
+/** A batch the sink gave up on (counted in runtime_ingest_drops, route "sink"). */
+export interface SinkDrop {
+    orgId: string;
+    repositoryId: string;
+    /** sink_overflow: buffer overflow, or a batch bigger than the buffer;
+     * sink_rejected: the consumer answered a permanent 4xx;
+     * sink_gave_up: SINK_MAX_ATTEMPTS deliveries failed. */
+    reason: "sink_overflow" | "sink_rejected" | "sink_gave_up";
+    /** Occurrences in the batch. */
+    occurrences: number;
+}
 /**
  * Operational counters for /healthz. Failure detail is reduced to a fixed
  * category (`timeout`, `connection_error`, `http_<status>`, `error`) — the
@@ -72,10 +83,13 @@ export declare class SinkForwarder {
     private lastFailureAt;
     private lastFailureReason;
     private readonly tuning;
+    /** Called for every batch given up on; must not throw (errors are swallowed). */
+    onDrop: ((drop: SinkDrop) => void) | null;
     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;
+    private noteDrop;
     pendingCount(): number;
     /** Stop scheduling new deliveries (shutdown). Queued batches are logged
      * by the caller — they are recoverable from ClickHouse, not from here. */
@@ -110,7 +124,10 @@ export declare class SinkForwarder {
  * 1.6.0 adds `frames` (innermost first, ≤ 50), `fingerprints` (every
  * identity candidate, highest precedence first, ending with the legacy
  * `fingerprint`) and `fingerprintRecord`; `fingerprint`/`fingerprintScheme`
- * keep their legacy meaning. Older consumers ignore unknown keys, so the
- * version stays 1.
+ * keep their legacy meaning. 1.9.0 adds `count`: the occurrences this
+ * record stands for, sent only when above 1 (a loop-collapse sample:
+ * 1 + collapsedCount, see loop-collapse.ts); consumers add `count ?? 1` to
+ * their event counts. Older consumers ignore unknown keys, so the version
+ * stays 1.
  */
 export declare function sinkOccurrence(o: RuntimeOccurrence): Record<string, unknown>;

package/dist/sink.js

@@ -44,6 +44,8 @@ export class SinkForwarder {
     lastFailureAt = null;
     lastFailureReason = null;
     tuning;
+    /** Called for every batch given up on; must not throw (errors are swallowed). */
+    onDrop = null;
     constructor(config, fetchImpl = fetch, tuning = {}) {
         this.config = config;
         this.fetchImpl = fetchImpl;
@@ -65,6 +67,7 @@ export class SinkForwarder {
         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`);
+            this.noteDrop(batch, "sink_overflow");
             return;
         }
         this.queue.push(batch);
@@ -88,6 +91,14 @@ export class SinkForwarder {
             oldestQueuedSince: oldest ? new Date(oldest).toISOString() : null,
         };
     }
+    noteDrop(batch, reason) {
+        try {
+            this.onDrop?.({ orgId: batch.orgId, repositoryId: batch.repositoryId, reason, occurrences: batch.occurrences });
+        }
+        catch {
+            // Drop accounting must never affect delivery.
+        }
+    }
     pendingCount() {
         return this.queue.length + this.inFlight;
     }
@@ -122,6 +133,8 @@ export class SinkForwarder {
         return {
             batchId,
             orgId: ctx.orgId,
+            repositoryId: ctx.repositoryId,
+            occurrences: occurrences.length,
             body,
             bytes: Buffer.byteLength(body),
             seq: ++this.seqCounter,
@@ -170,6 +183,7 @@ export class SinkForwarder {
                 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`);
+            this.noteDrop(dropped, "sink_overflow");
         }
     }
     /** The oldest batch of the org holding the most buffered bytes. */
@@ -280,6 +294,7 @@ export class SinkForwarder {
         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`);
+            this.noteDrop(batch, permanent ? "sink_rejected" : "sink_gave_up");
             return;
         }
         this.retried += 1;
@@ -304,13 +319,16 @@ export class SinkForwarder {
  * 1.6.0 adds `frames` (innermost first, ≤ 50), `fingerprints` (every
  * identity candidate, highest precedence first, ending with the legacy
  * `fingerprint`) and `fingerprintRecord`; `fingerprint`/`fingerprintScheme`
- * keep their legacy meaning. Older consumers ignore unknown keys, so the
- * version stays 1.
+ * keep their legacy meaning. 1.9.0 adds `count`: the occurrences this
+ * record stands for, sent only when above 1 (a loop-collapse sample:
+ * 1 + collapsedCount, see loop-collapse.ts); consumers add `count ?? 1` to
+ * their event counts. Older consumers ignore unknown keys, so the version
+ * stays 1.
  */
 export function sinkOccurrence(o) {
     const { traceId, route, method, statusCode, errorCode, why, fix, link, expected, requestId, breadcrumbs, frames, fingerprints, fingerprintRecord, 
     // Input-only: locates source maps, never leaves the ingester.
-    debugIds: _debugIds, ...rest } = o;
+    debugIds: _debugIds, collapsedCount, ...rest } = o;
     return {
         ...rest,
         occurredAt: o.occurredAt.toISOString(),
@@ -329,6 +347,8 @@ export function sinkOccurrence(o) {
         ...(frames?.length ? { frames } : {}),
         ...(fingerprints?.length ? { fingerprints } : {}),
         ...(fingerprintRecord ? { fingerprintRecord } : {}),
+        // 1.9.0: a collapsed sample stands for 1 + collapsedCount occurrences.
+        ...(collapsedCount && collapsedCount > 0 ? { count: 1 + collapsedCount } : {}),
     };
 }
 /** ISO range across every signal in the batch — the replay hint on drops. */

package/dist/stack-frames.d.ts

@@ -11,8 +11,10 @@ import type { StackFrame } from "./types.js";
  * - V8 (Node, Chrome, Edge): `at fn (file:line:col)` / `at file:line:col`
  * - Firefox / Safari: `fn@url:line:col` / `@url:line:col`
  * - Python: `File "…", line N, in fn` — tracebacks list the OUTERMOST frame
- *   first, so the frames are reversed; only the last (reported) traceback
- *   of a chained exception is used
+ *   first, so the frames are reversed; only the reported exception's own
+ *   frames are used: the last top-level block of a chained exception, and
+ *   for an exception group (3.11+) its own `| `-margined block, never its
+ *   sub-exceptions
  * - Go: function line + `\t<file>.go:<line> +0x…`, first goroutine only
  * - JVM: `at pkg.Class.method(File.java:N)`, first exception block only
  *   (before `Caused by:`)
@@ -34,6 +36,7 @@ export type FrameLanguage = "javascript" | "python" | "go" | "jvm" | "dotnet" |
  * `C:\app\node_modules\x.js` counts too. A frame with no path is in-app.
  */
 export declare function isInAppPath(path: string | null): boolean;
+export declare function isPythonStdlibPath(path: string | null): boolean;
 /**
  * Contract §3. Source-map ignore lists are applied by symbolicate.ts; the
  * language rules apply only to frames of that language, so a JS object

package/dist/stack-frames.js

@@ -11,8 +11,10 @@ import { detectStackLanguage } from "./fingerprint.js";
  * - V8 (Node, Chrome, Edge): `at fn (file:line:col)` / `at file:line:col`
  * - Firefox / Safari: `fn@url:line:col` / `@url:line:col`
  * - Python: `File "…", line N, in fn` — tracebacks list the OUTERMOST frame
- *   first, so the frames are reversed; only the last (reported) traceback
- *   of a chained exception is used
+ *   first, so the frames are reversed; only the reported exception's own
+ *   frames are used: the last top-level block of a chained exception, and
+ *   for an exception group (3.11+) its own `| `-margined block, never its
+ *   sub-exceptions
  * - Go: function line + `\t<file>.go:<line> +0x…`, first goroutine only
  * - JVM: `at pkg.Class.method(File.java:N)`, first exception block only
  *   (before `Caused by:`)
@@ -63,6 +65,22 @@ export function isInAppPath(path) {
         return false;
     return true;
 }
+/**
+ * Python's standard library: frozen modules (`<frozen runpy>`) and the
+ * version directory of an installation (`/usr/local/lib/python3.12/`,
+ * `…/Versions/3.14/lib/python3.14/`, `C:\Python312\Lib\`); a
+ * virtualenv's packages are `site-packages`, covered by the path rule. Like
+ * Go's `/usr/local/go/`, they are the runtime, not the app: an asyncio or
+ * socket error's first five frames would otherwise all be stdlib frames.
+ */
+const PY_STDLIB_RE = /\/lib\/(?:python|pypy)\d\.\d+t?\/|\/python\d{2,3}t?\/lib\//i;
+export function isPythonStdlibPath(path) {
+    if (!path)
+        return false;
+    if (path.startsWith("<frozen "))
+        return true;
+    return PY_STDLIB_RE.test(path.replace(/\\/g, "/"));
+}
 /** Fully qualified name for the language rules (`module.function`). */
 function qualifiedName(frame) {
     if (frame.module && frame.function)
@@ -84,6 +102,8 @@ export function isInAppFrame(frame, language) {
         if ((frame.filename ?? "").replace(/\\/g, "/").includes("/usr/local/go/"))
             return false;
     }
+    if (language === "python" && isPythonStdlibPath(frame.filename))
+        return false;
     if (language === "jvm" && /^(?:java|javax|kotlin|jdk)\./.test(qualified))
         return false;
     if (language === "dotnet" && /^(?:System|Microsoft)\./.test(qualified))
@@ -225,15 +245,41 @@ function parseGecko(lines) {
 // ── Python ────────────────────────────────────────────────────────────────
 const PY_FILE_RE = /^\s*File "(.+)", line (\d+)(?:, in (.+?))?\s*$/;
 const PY_TRACEBACK_RE = /^\s*Traceback \(most recent call last\):\s*$/;
+// 3.11+: an exception group prints its own frames behind a "| " margin,
+// under this header (nested groups' headers carry the margin instead of "+"),
+// then its sub-exceptions after a "+-+---- 1 ----" separator.
+const PY_GROUP_TRACEBACK_RE = /^\s*\+ Exception Group Traceback \(most recent call last\):\s*$/;
+const PY_GROUP_MARGIN_RE = /^\s*\|/;
+const PY_GROUP_SUBEXCEPTIONS_RE = /^\s*\+-/;
+function isPythonFrameLine(line) {
+    return PY_FILE_RE.test(line) || PY_FILE_RE.test(line.replace(PY_GROUP_MARGIN_RE, ""));
+}
 function parsePython(lines) {
-    // A chained exception prints one traceback per exception; the reported
-    // (final) exception's frames are the last block.
-    let start = 0;
-    for (let i = 0; i < lines.length; i++)
-        if (PY_TRACEBACK_RE.test(lines[i]))
+    // A chained exception prints one block per exception, the reported
+    // (final) one last, whether the chain says "During handling of the above
+    // exception" or "The above exception was the direct cause". Blocks of
+    // sub-exceptions and of groups in the chain carry a margin, so the last
+    // unmargined header starts the reported exception's own frames.
+    let start = -1;
+    let group = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (PY_TRACEBACK_RE.test(lines[i])) {
+            start = i;
+            group = false;
+        }
+        else if (PY_GROUP_TRACEBACK_RE.test(lines[i])) {
             start = i;
+            group = true;
+        }
+    }
     const outermostFirst = [];
-    for (const line of lines.slice(start)) {
+    for (const raw of lines.slice(start + 1)) {
+        let line = raw;
+        if (group) {
+            if (PY_GROUP_SUBEXCEPTIONS_RE.test(line))
+                break;
+            line = line.replace(PY_GROUP_MARGIN_RE, "");
+        }
         const m = PY_FILE_RE.exec(line);
         if (!m)
             continue;
@@ -391,7 +437,7 @@ export function detectFrameLanguage(lines) {
             return "dotnet";
         default:
     }
-    if (lines.some((line) => PY_FILE_RE.test(line)))
+    if (lines.some(isPythonFrameLine))
         return "python";
     if (lines.some((line) => DOTNET_BARE_RE.test(line)) &&
         !lines.some((line) => /:\d+(?::\d+)?\)?\s*$/.test(line))) {

package/dist/suppression.d.ts

@@ -0,0 +1,79 @@
+import type { RuntimeOccurrence } from "./types.js";
+/**
+ * Suppression rules (1.9.0, EI-38): occurrences the user chose not to keep,
+ * set per repository in Autter and delivered with the key (the validator's
+ * `suppression` answer, cached with the key for 60 s), or on a static key
+ * entry for self-hosted ingesters.
+ *
+ * A rule is a list of filters that must ALL match (AND) and an action:
+ *
+ *   { "id": "rsr_1", "action": "drop",
+ *     "filters": [{ "key": "errorType", "op": "equals", "value": "AbortError" }] }
+ *   { "id": "rsr_2", "action": "sample", "sampleRate": 0.1,
+ *     "filters": [{ "key": "message", "op": "matches", "value": "ResizeObserver loop*" }] }
+ *
+ * Keys: errorType, message, service, environment, route, release, source
+ * (`browser` or `server`). Operators, all case-insensitive: `equals`,
+ * `contains`, `starts_with`, `matches` (a glob over the whole value where
+ * `*` is any run of characters; matched segment by segment, so time is
+ * linear in the value and no user pattern can stall ingest). A missing
+ * value (no route, no release) is the empty string.
+ *
+ * Rules are tried in order and the first that matches decides: `drop`
+ * leaves the occurrence out; `sample` keeps `sampleRate` (0 < rate < 1) of
+ * them, chosen by the occurrence id, so a retried batch keeps the same
+ * ones, and never samples out a `fatal` occurrence. Suppressed occurrences
+ * are not stored or forwarded and are counted in `runtime_ingest_drops`
+ * (reason `suppressed`). Request and error-rate rollups are not affected:
+ * they count requests, not the occurrences kept.
+ *
+ * Parsing never throws: an invalid rule (unknown key or operator, empty or
+ * oversized value, a sample rate outside (0, 1)) is left out on its own.
+ */
+export declare const SUPPRESSION_PROPERTIES: readonly ["errorType", "message", "service", "environment", "route", "release", "source"];
+export type SuppressionProperty = (typeof SUPPRESSION_PROPERTIES)[number];
+export declare const SUPPRESSION_OPERATORS: readonly ["equals", "contains", "starts_with", "matches"];
+export type SuppressionOperator = (typeof SUPPRESSION_OPERATORS)[number];
+export type SuppressionAction = "drop" | "sample";
+export interface SuppressionFilter {
+    key: SuppressionProperty;
+    op: SuppressionOperator;
+    /** Lower-cased at parse time: every comparison is case-insensitive. */
+    value: string;
+}
+export interface SuppressionRule {
+    id: string;
+    filters: SuppressionFilter[];
+    action: SuppressionAction;
+    /** `sample` only: the share kept, 0 < rate < 1. */
+    sampleRate?: number;
+}
+/** Longest filter value accepted; longer ones make the rule invalid. */
+export declare const MAX_SUPPRESSION_VALUE_LENGTH = 500;
+/** One rule, or null when any part of it is invalid (a rule is never half-applied). */
+export declare function parseSuppressionRule(raw: unknown): SuppressionRule | null;
+/** The valid rules of a validator answer or static key entry, in order; [] for anything else. */
+export declare function parseSuppressionRules(raw: unknown): SuppressionRule[];
+/**
+ * `*`-glob over the whole text: literal segments must appear in order, the
+ * first anchored at the start unless the pattern starts with `*`, the last
+ * at the end unless it ends with `*`. Each segment is found leftmost with
+ * indexOf, which is always a valid placement for star-only globs, so there
+ * is no backtracking. Both sides are expected lower-cased.
+ */
+export declare function globMatch(pattern: string, text: string): boolean;
+/** The first rule whose filters all match, or null. */
+export declare function matchingRule(rules: readonly SuppressionRule[], o: RuntimeOccurrence): SuppressionRule | null;
+/**
+ * A stable number in [0, 1) for an occurrence: its id is a content-derived
+ * hex digest (occurrenceIdFor), so the same occurrence in a retried batch
+ * lands in the same place. Ids that are not hex fall back to FNV-1a.
+ */
+export declare function sampleUnit(occurrenceId: string): number;
+export interface SuppressionOutcome<T> {
+    kept: T[];
+    /** Occurrences left out (dropped or sampled out). */
+    suppressed: number;
+}
+/** Apply the tenant's rules; order of the kept occurrences is preserved. */
+export declare function applySuppression<T extends RuntimeOccurrence>(occurrences: T[], rules: readonly SuppressionRule[] | undefined): SuppressionOutcome<T>;

package/dist/suppression.js

@@ -0,0 +1,203 @@
+/**
+ * Suppression rules (1.9.0, EI-38): occurrences the user chose not to keep,
+ * set per repository in Autter and delivered with the key (the validator's
+ * `suppression` answer, cached with the key for 60 s), or on a static key
+ * entry for self-hosted ingesters.
+ *
+ * A rule is a list of filters that must ALL match (AND) and an action:
+ *
+ *   { "id": "rsr_1", "action": "drop",
+ *     "filters": [{ "key": "errorType", "op": "equals", "value": "AbortError" }] }
+ *   { "id": "rsr_2", "action": "sample", "sampleRate": 0.1,
+ *     "filters": [{ "key": "message", "op": "matches", "value": "ResizeObserver loop*" }] }
+ *
+ * Keys: errorType, message, service, environment, route, release, source
+ * (`browser` or `server`). Operators, all case-insensitive: `equals`,
+ * `contains`, `starts_with`, `matches` (a glob over the whole value where
+ * `*` is any run of characters; matched segment by segment, so time is
+ * linear in the value and no user pattern can stall ingest). A missing
+ * value (no route, no release) is the empty string.
+ *
+ * Rules are tried in order and the first that matches decides: `drop`
+ * leaves the occurrence out; `sample` keeps `sampleRate` (0 < rate < 1) of
+ * them, chosen by the occurrence id, so a retried batch keeps the same
+ * ones, and never samples out a `fatal` occurrence. Suppressed occurrences
+ * are not stored or forwarded and are counted in `runtime_ingest_drops`
+ * (reason `suppressed`). Request and error-rate rollups are not affected:
+ * they count requests, not the occurrences kept.
+ *
+ * Parsing never throws: an invalid rule (unknown key or operator, empty or
+ * oversized value, a sample rate outside (0, 1)) is left out on its own.
+ */
+export const SUPPRESSION_PROPERTIES = ["errorType", "message", "service", "environment", "route", "release", "source"];
+export const SUPPRESSION_OPERATORS = ["equals", "contains", "starts_with", "matches"];
+/** Longest filter value accepted; longer ones make the rule invalid. */
+export const MAX_SUPPRESSION_VALUE_LENGTH = 500;
+const PROPERTIES = new Set(SUPPRESSION_PROPERTIES);
+const OPERATORS = new Set(SUPPRESSION_OPERATORS);
+function parseFilter(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const { key, op, value } = raw;
+    if (typeof key !== "string" || !PROPERTIES.has(key))
+        return null;
+    if (typeof op !== "string" || !OPERATORS.has(op))
+        return null;
+    if (typeof value !== "string" || !value || value.length > MAX_SUPPRESSION_VALUE_LENGTH)
+        return null;
+    return { key: key, op: op, value: value.toLowerCase() };
+}
+/** One rule, or null when any part of it is invalid (a rule is never half-applied). */
+export function parseSuppressionRule(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const { id, filters, action, sampleRate } = raw;
+    if (typeof id !== "string" || !id || id.length > 200)
+        return null;
+    if (action !== "drop" && action !== "sample")
+        return null;
+    if (!Array.isArray(filters) || filters.length === 0)
+        return null;
+    const parsed = [];
+    for (const item of filters) {
+        const filter = parseFilter(item);
+        if (!filter)
+            return null;
+        parsed.push(filter);
+    }
+    if (action === "sample") {
+        if (typeof sampleRate !== "number" || !Number.isFinite(sampleRate) || sampleRate <= 0 || sampleRate >= 1)
+            return null;
+        return { id, filters: parsed, action, sampleRate };
+    }
+    return { id, filters: parsed, action };
+}
+/** The valid rules of a validator answer or static key entry, in order; [] for anything else. */
+export function parseSuppressionRules(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const rules = [];
+    for (const item of raw) {
+        try {
+            const rule = parseSuppressionRule(item);
+            if (rule)
+                rules.push(rule);
+        }
+        catch {
+            // A hostile getter or Proxy: leave the rule out.
+        }
+    }
+    return rules;
+}
+/**
+ * `*`-glob over the whole text: literal segments must appear in order, the
+ * first anchored at the start unless the pattern starts with `*`, the last
+ * at the end unless it ends with `*`. Each segment is found leftmost with
+ * indexOf, which is always a valid placement for star-only globs, so there
+ * is no backtracking. Both sides are expected lower-cased.
+ */
+export function globMatch(pattern, text) {
+    const segments = pattern.split("*");
+    if (segments.length === 1)
+        return pattern === text;
+    const first = segments[0];
+    const last = segments[segments.length - 1];
+    if (!text.startsWith(first))
+        return false;
+    let at = first.length;
+    for (let i = 1; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        if (!segment)
+            continue;
+        const found = text.indexOf(segment, at);
+        if (found === -1)
+            return false;
+        at = found + segment.length;
+    }
+    return text.length - last.length >= at && text.endsWith(last);
+}
+function propertyOf(o, key) {
+    switch (key) {
+        case "errorType":
+            return o.errorType ?? "";
+        case "message":
+            return o.message ?? "";
+        case "service":
+            return o.service ?? "";
+        case "environment":
+            return o.environment ?? "";
+        case "route":
+            return o.route ?? "";
+        case "release":
+            return o.release ?? "";
+        case "source":
+            return o.source ?? "";
+    }
+}
+function filterMatches(filter, o) {
+    const value = propertyOf(o, filter.key).toLowerCase();
+    switch (filter.op) {
+        case "equals":
+            return value === filter.value;
+        case "contains":
+            return value.includes(filter.value);
+        case "starts_with":
+            return value.startsWith(filter.value);
+        case "matches":
+            return globMatch(filter.value, value);
+    }
+}
+/** The first rule whose filters all match, or null. */
+export function matchingRule(rules, o) {
+    for (const rule of rules) {
+        if (rule.filters.every((filter) => filterMatches(filter, o)))
+            return rule;
+    }
+    return null;
+}
+/**
+ * A stable number in [0, 1) for an occurrence: its id is a content-derived
+ * hex digest (occurrenceIdFor), so the same occurrence in a retried batch
+ * lands in the same place. Ids that are not hex fall back to FNV-1a.
+ */
+export function sampleUnit(occurrenceId) {
+    const head = occurrenceId.slice(0, 8);
+    if (/^[0-9a-f]{8}$/i.test(head))
+        return Number.parseInt(head, 16) / 0x1_0000_0000;
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < occurrenceId.length; i++) {
+        hash ^= occurrenceId.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash / 0x1_0000_0000;
+}
+const NEVER_SAMPLED = new Set(["fatal"]);
+/** Apply the tenant's rules; order of the kept occurrences is preserved. */
+export function applySuppression(occurrences, rules) {
+    if (!rules?.length || occurrences.length === 0)
+        return { kept: occurrences, suppressed: 0 };
+    const kept = [];
+    let suppressed = 0;
+    for (const o of occurrences) {
+        let rule = null;
+        try {
+            rule = matchingRule(rules, o);
+        }
+        catch {
+            // Never fail ingest on a rule: keep the occurrence.
+        }
+        if (!rule) {
+            kept.push(o);
+        }
+        else if (rule.action === "drop") {
+            suppressed += 1;
+        }
+        else if (NEVER_SAMPLED.has(o.severity) || sampleUnit(o.occurrenceId) < (rule.sampleRate ?? 1)) {
+            kept.push(o);
+        }
+        else {
+            suppressed += 1;
+        }
+    }
+    return { kept, suppressed };
+}

package/dist/symbolicate.d.ts

@@ -40,6 +40,19 @@ export interface SymbolicationScope {
     /** Script URL → debug id (EI-13), when the browser sent them. */
     debugIds?: Record<string, string> | null;
 }
+/**
+ * In-app browser frames a source map could resolve, counted after
+ * symbolication (EI-27): `resolved` ones, and `unresolved` .js/.mjs/.cjs
+ * frames left as parsed (no map uploaded, no release or debug id, no
+ * mapping at that position). Frames a map moved out of the app
+ * (node_modules, ignoreList) and non-JS frames count in neither. Stored per
+ * occurrence (`in_app_frames_resolved` / `in_app_frames_unresolved`) for the
+ * EI-14 rule: over 30% unresolved means the release needs source maps.
+ */
+export declare function inAppFrameResolution(frames: readonly StackFrame[] | undefined): {
+    resolved: number;
+    unresolved: number;
+};
 /** Path-only form of a script URL — the key uploads are stored under. */
 export declare function scriptPath(filename: string): string | null;
 export interface SourceMapCacheOptions {

package/dist/symbolicate.js

@@ -5,6 +5,28 @@ import { isInAppPath, stripQueryAndHash } from "./stack-frames.js";
 const JS_FILE_RE = /\.[cm]?js$/i;
 const MAX_CONTEXT_CHARS = 300;
 const CONTEXT_LINES = 3;
+/**
+ * In-app browser frames a source map could resolve, counted after
+ * symbolication (EI-27): `resolved` ones, and `unresolved` .js/.mjs/.cjs
+ * frames left as parsed (no map uploaded, no release or debug id, no
+ * mapping at that position). Frames a map moved out of the app
+ * (node_modules, ignoreList) and non-JS frames count in neither. Stored per
+ * occurrence (`in_app_frames_resolved` / `in_app_frames_unresolved`) for the
+ * EI-14 rule: over 30% unresolved means the release needs source maps.
+ */
+export function inAppFrameResolution(frames) {
+    let resolved = 0;
+    let unresolved = 0;
+    for (const frame of frames ?? []) {
+        if (!frame.inApp)
+            continue;
+        if (frame.resolved)
+            resolved += 1;
+        else if (frame.filename && JS_FILE_RE.test(frame.filename))
+            unresolved += 1;
+    }
+    return { resolved, unresolved };
+}
 /** Path-only form of a script URL — the key uploads are stored under. */
 export function scriptPath(filename) {
     try {

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { Breadcrumb } from "./breadcrumbs.js";
+import type { SuppressionRule } from "./suppression.js";
 export type RuntimeSource = "browser" | "server";
 /**
  * Signal severity. Errors AND warnings/info land in the same occurrences
@@ -131,6 +132,13 @@ export interface RuntimeOccurrence extends RuntimeOccurrenceInput {
     topFrames: string[];
     /** topFrames[0] — single-column GROUP BY for "where did this come from". */
     firstFrame: string;
+    /**
+     * Loop collapse (1.9.0, loop-collapse.ts): the minute's collapsed sample
+     * stands for itself plus this many identical occurrences whose payloads
+     * were not stored. Stored as `collapsed_count`, sent to the sink as
+     * `count` (1 + collapsedCount). Absent (0) on every other occurrence.
+     */
+    collapsedCount?: number;
 }
 export interface RuntimeSpanRow {
     service: string;
@@ -212,4 +220,10 @@ export interface IngestContext {
     scope: IngestKeyScope;
     /** client keys only: exact origins allowed to send (empty = any). */
     allowedOrigins: string[];
+    /**
+     * Suppression rules set by the user for this repository (1.9.0): from the
+     * key validator's `suppression` answer (cached with the key, 60 s) or a
+     * static key's `suppression` entry. Absent or empty: nothing suppressed.
+     */
+    suppression?: SuppressionRule[];
 }

package/package.json

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