@autter/otlp-ingester 1.9.0 → 1.10.0

package/dist/compat-manifest.json

@@ -169,6 +169,14 @@
             "ingester": "1.9.0",
             "migrations": ["0021-occurrence-collapsed-count"],
             "sdks": {}
+        },
+        {
+            "id": "edge_request_counts",
+            "title": "Edge requests counted from their request summaries",
+            "ingester": "1.10.0",
+            "migrations": [],
+            "route": "/v1/logs",
+            "sdks": { "@autter/runtime-edge": "1.3.0" }
         }
     ]
 }

package/dist/log-promotion.d.ts

@@ -48,9 +48,40 @@ export interface PromotionLookup {
  */
 export declare function promotionLookups(occurrences: RuntimeOccurrenceInput[], now?: number): PromotionLookup[];
 /**
- * One error per promoted occurrence, in `error_count` only — the same
- * counting the trace path applies to errors outside a request (a log record
- * names no request the rollups count), so error counters for logger-only and
- * edge services don't read 0 and no request is invented.
+ * `autter.request.counted_by = "summary"`: the request this record belongs to
+ * is counted in the usage rollups by its request summary (the record of
+ * `autter.operation.kind = "request"` carrying the same mark), because no
+ * other feed sees it. `@autter/runtime-edge` (1.3.0+) puts it on every
+ * record of a request: an edge function has no trace pipeline and no
+ * `http.server.duration` histogram, so without it edge services had error
+ * counts and no requests. Nothing else sets it: Node and Next.js summaries
+ * never carry it (their requests are counted by the histogram or the spans),
+ * so a request is counted by its summary only when its sender says the
+ * summary is the one count it gets.
  */
-export declare function promotionRollups(occurrences: RuntimeOccurrence[]): RuntimeMetricPoint[];
+export declare const COUNTED_BY_ATTRIBUTE = "autter.request.counted_by";
+/** On a counted summary: an error of the request was reported (an
+ * `autter.capture.mode = "log"` record), which makes it a failed request. */
+export declare const ERROR_REPORTED_ATTRIBUTE = "autter.request.error_reported";
+export declare function countedBySummary(attributes: Record<string, unknown> | null | undefined): boolean;
+/**
+ * The usage rollups (`runtime_metrics_1m`) a /v1/logs batch adds, counted the
+ * way the trace path counts (normalize-otlp.ts): `request_count` counts
+ * requests only, `error_count` counts failed requests once and errors outside
+ * a counted request one each.
+ *
+ * - A request summary marked counted (`countedBySummary`) is one request:
+ *   `request_count` 1, its duration, on its route and minute; `error_count` 1
+ *   when it failed — outcome `failed`, a status ≥ 500, or an error reported
+ *   in it (`autter.request.error_reported`), as an error occurrence recorded
+ *   in a request fails it on the trace path.
+ * - A promoted occurrence (logger-only or edge error record) adds
+ *   `error_count` 1 — unless its record is marked counted: its request's
+ *   summary already counts that failure once, however many errors it had.
+ *
+ * The decision is per record, never by matching records across a batch, so
+ * a request whose records an exporter splits over two batches is still
+ * counted once. Unmarked summaries add nothing (they are counted elsewhere,
+ * or by no one, as before).
+ */
+export declare function logRollups(rows: RuntimeLogRecord[], promoted: RuntimeOccurrence[]): RuntimeMetricPoint[];

package/dist/log-promotion.js

@@ -81,38 +81,93 @@ export function promotionLookups(occurrences, now = Date.now()) {
     return lookups;
 }
 /**
- * One error per promoted occurrence, in `error_count` only — the same
- * counting the trace path applies to errors outside a request (a log record
- * names no request the rollups count), so error counters for logger-only and
- * edge services don't read 0 and no request is invented.
+ * `autter.request.counted_by = "summary"`: the request this record belongs to
+ * is counted in the usage rollups by its request summary (the record of
+ * `autter.operation.kind = "request"` carrying the same mark), because no
+ * other feed sees it. `@autter/runtime-edge` (1.3.0+) puts it on every
+ * record of a request: an edge function has no trace pipeline and no
+ * `http.server.duration` histogram, so without it edge services had error
+ * counts and no requests. Nothing else sets it: Node and Next.js summaries
+ * never carry it (their requests are counted by the histogram or the spans),
+ * so a request is counted by its summary only when its sender says the
+ * summary is the one count it gets.
  */
-export function promotionRollups(occurrences) {
+export const COUNTED_BY_ATTRIBUTE = "autter.request.counted_by";
+/** On a counted summary: an error of the request was reported (an
+ * `autter.capture.mode = "log"` record), which makes it a failed request. */
+export const ERROR_REPORTED_ATTRIBUTE = "autter.request.error_reported";
+export function countedBySummary(attributes) {
+    return attributes?.[COUNTED_BY_ATTRIBUTE] === "summary";
+}
+/**
+ * The usage rollups (`runtime_metrics_1m`) a /v1/logs batch adds, counted the
+ * way the trace path counts (normalize-otlp.ts): `request_count` counts
+ * requests only, `error_count` counts failed requests once and errors outside
+ * a counted request one each.
+ *
+ * - A request summary marked counted (`countedBySummary`) is one request:
+ *   `request_count` 1, its duration, on its route and minute; `error_count` 1
+ *   when it failed — outcome `failed`, a status ≥ 500, or an error reported
+ *   in it (`autter.request.error_reported`), as an error occurrence recorded
+ *   in a request fails it on the trace path.
+ * - A promoted occurrence (logger-only or edge error record) adds
+ *   `error_count` 1 — unless its record is marked counted: its request's
+ *   summary already counts that failure once, however many errors it had.
+ *
+ * The decision is per record, never by matching records across a batch, so
+ * a request whose records an exporter splits over two batches is still
+ * counted once. Unmarked summaries add nothing (they are counted elsewhere,
+ * or by no one, as before).
+ */
+export function logRollups(rows, promoted) {
     const rollups = new Map();
-    for (const occ of occurrences) {
-        const bucketAt = new Date(Math.floor(occ.occurredAt.getTime() / 60_000) * 60_000);
-        const route = normalizeRoute(occ.route);
-        const key = [
-            occ.service,
-            occ.environment,
-            occ.release ?? "",
-            route,
-            bucketAt.getTime(),
-        ].join(" ");
+    const add = (point) => {
+        const { at, ...rest } = point;
+        const bucketAt = new Date(Math.floor(at.getTime() / 60_000) * 60_000);
+        const key = [rest.service, rest.environment, rest.release ?? "", rest.route, bucketAt.getTime()].join(" ");
         const existing = rollups.get(key);
         if (existing) {
-            existing.errorCount += 1;
-            continue;
+            existing.requestCount += rest.requestCount;
+            existing.errorCount += rest.errorCount;
+            existing.durationSumMs += rest.durationSumMs;
+            return;
         }
-        rollups.set(key, {
+        rollups.set(key, { ...rest, bucketAt, sessionCount: 0 });
+    };
+    for (const row of rows) {
+        if (row.kind !== "request" || !countedBySummary(row.attributes))
+            continue;
+        const failed = row.outcome === "failed" ||
+            row.statusCode >= 500 ||
+            row.attributes[ERROR_REPORTED_ATTRIBUTE] === true;
+        add({
+            service: row.service,
+            environment: row.environment,
+            release: row.release || null,
+            // Already normalized (logs.ts), the key promoted errors use too.
+            route: row.route,
+            at: row.occurredAt,
+            requestCount: 1,
+            errorCount: failed ? 1 : 0,
+            durationSumMs: row.durationMs,
+        });
+    }
+    for (const occ of promoted) {
+        // Its request's summary counts this failure.
+        if (countedBySummary(occ.attributes))
+            continue;
+        // One error of its own, in `error_count` only — what the trace path
+        // does for an error outside a request: the record names no request
+        // the rollups count, so no request is invented.
+        add({
             service: occ.service,
             environment: occ.environment,
             release: occ.release,
-            route,
-            bucketAt,
+            route: normalizeRoute(occ.route),
+            at: occ.occurredAt,
             requestCount: 0,
             errorCount: 1,
             durationSumMs: 0,
-            sessionCount: 0,
         });
     }
     return [...rollups.values()];

package/dist/server.js

@@ -8,7 +8,7 @@ import { deriveFields, occurrenceIdFor } from "./fingerprint.js";
 import { occurrenceIdentity } from "./fingerprint-v3.js";
 import { parseStackFrames } from "./stack-frames.js";
 import { SourceMapCache, Symbolicator } from "./symbolicate.js";
-import { logPromotionCandidates, promotionLookups, promotionRollups, } from "./log-promotion.js";
+import { logPromotionCandidates, promotionLookups, logRollups, } from "./log-promotion.js";
 import { normalizeBrowserPayload, parseBrowserPayload, } from "./normalize-browser.js";
 import { normalizeMetrics, normalizeTraces, } from "./normalize-otlp.js";
 import { decodeMetricsRequest, decodeTraceRequest, decodeLogsRequest, encodeExportResponse } from "./otlp-proto.js";
@@ -700,7 +700,7 @@ export function createIngesterApp(config) {
         // and those are promoted to occurrences here — see log-promotion.ts.
         const promoted = await promoteLogs(ctx, logs);
         // Rollups count every promoted error, collapsed or suppressed ones too.
-        const metricPoints = promotionRollups(promoted);
+        const metricPoints = logRollups(logs, promoted);
         const admitted = admit(ctx, req, promoted);
         try {
             await Promise.all([

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@autter/otlp-ingester",
-	"version": "1.9.0",
+	"version": "1.10.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",