footprintjs 10.0.0 → 10.1.0

package/dist/esm/lib/recorder/attemptMetricRows.d.ts

@@ -0,0 +1,11 @@
+import type { AttemptQuery, AttemptRow } from './attemptMetricsTypes.js';
+/** Decode plain own data only; external data never gets to run getters or coercion hooks. */
+export declare function ownDataRecord(value: unknown): Record<string, unknown> | undefined;
+/** Read an external array window by descriptors, never by executing an index accessor or iterator. */
+export declare function metricWindow(value: unknown, maxRows: number): {
+    values: unknown[];
+    omitted: number;
+};
+/** Invalid stored data is omitted and accounted, never copied as an arbitrary envelope. */
+export declare function metricRow(value: unknown): AttemptRow | undefined;
+export declare function matchesQuery(row: AttemptRow, query: AttemptQuery): boolean;

package/dist/esm/lib/recorder/attemptMetricRows.js

@@ -0,0 +1,202 @@
+import { parseAttemptId } from 'foottrace';
+// Fixed named fields: a huge unknown envelope is never enumerated just to discard it.
+const DATA_FIELDS = [
+    'kind',
+    'runId',
+    'startedAt',
+    'endedAt',
+    'outcome',
+    'target',
+    'runtimeStageId',
+    'attemptId',
+    'id',
+    'series',
+    'attempt',
+    'of',
+    'effect',
+    'reconciled',
+    'next',
+    'reason',
+    'attemptKind',
+    'durationMs',
+    'category',
+    'traceId',
+    'retryLoop',
+    'phase',
+    'since',
+    'until',
+    'omittedRows',
+];
+/** Decode plain own data only; external data never gets to run getters or coercion hooks. */
+export function ownDataRecord(value) {
+    try {
+        if (value === null || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+            return undefined;
+        const data = Object.create(null);
+        for (const key of DATA_FIELDS) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor === undefined)
+                continue;
+            if (!Object.hasOwn(descriptor, 'value'))
+                return undefined;
+            data[key] = descriptor.value;
+        }
+        return data;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read an external array window by descriptors, never by executing an index accessor or iterator. */
+export function metricWindow(value, maxRows) {
+    try {
+        if (!Array.isArray(value))
+            return { values: [], omitted: 1 };
+        const length = Object.getOwnPropertyDescriptor(value, 'length')?.value;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+            return { values: [], omitted: 1 };
+        const start = Math.max(0, length - maxRows);
+        const values = [];
+        let omitted = start;
+        for (let index = start; index < length; index++) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined || !Object.hasOwn(descriptor, 'value'))
+                omitted++;
+            else
+                values.push(descriptor.value);
+        }
+        return { values, omitted };
+    }
+    catch {
+        return { values: [], omitted: 1 };
+    }
+}
+const outcomes = new Set(['ok', 'failed', 'timeout', 'aborted', 'paused']);
+const categories = new Set(['timeout', 'rate-limited', 'server', 'network', 'auth', 'permanent', 'unknown']);
+const reasons = new Set(['succeeded', 'paused', 'aborted', 'exhausted', 'declined', 'no-time-left', 'retryable']);
+const nexts = new Set(['retry', 'done', 'stop']);
+const effects = new Set(['none', 'applied', 'unknown']);
+const number = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+const text = (value) => typeof value === 'string' && value.length > 0 && value.length <= 4096;
+const count = (value) => number(value) && Number.isSafeInteger(value) && value >= 1;
+function loopOf(value) {
+    if (value === undefined)
+        return undefined;
+    const v = ownDataRecord(value);
+    if (v === undefined)
+        throw new TypeError('invalid attempt loop');
+    if (!text(v.id) ||
+        !text(v.series) ||
+        !parseAttemptId(`${v.series}@1`) ||
+        !count(v.attempt) ||
+        !count(v.of) ||
+        v.attempt > v.of ||
+        (v.phase !== 'attempt' && v.phase !== 'reconcile'))
+        throw new TypeError('invalid attempt loop');
+    return { id: v.id, series: v.series, attempt: v.attempt, of: v.of, phase: v.phase };
+}
+/** Invalid stored data is omitted and accounted, never copied as an arbitrary envelope. */
+export function metricRow(value) {
+    try {
+        const v = ownDataRecord(value);
+        if (v === undefined)
+            return undefined;
+        if (!text(v.runId) || !number(v.startedAt))
+            return undefined;
+        if (v.kind === 'run') {
+            if (!['running', 'ok', 'failed', 'paused'].includes(v.outcome) ||
+                (v.endedAt !== undefined && !number(v.endedAt)))
+                return undefined;
+            return {
+                kind: 'run',
+                runId: v.runId,
+                startedAt: v.startedAt,
+                ...(v.endedAt === undefined ? {} : { endedAt: v.endedAt }),
+                outcome: v.outcome,
+            };
+        }
+        if (!text(v.target) || !text(v.runtimeStageId) || !parseAttemptId(`${v.runtimeStageId}@1`))
+            return undefined;
+        if (v.kind === 'decision') {
+            const parsed = text(v.attemptId) ? parseAttemptId(v.attemptId) : undefined;
+            if (!parsed ||
+                !text(v.id) ||
+                !text(v.series) ||
+                !parseAttemptId(`${v.series}@1`) ||
+                !count(v.attempt) ||
+                !count(v.of) ||
+                v.attempt > v.of ||
+                !effects.has(v.effect) ||
+                typeof v.reconciled !== 'boolean' ||
+                !nexts.has(v.next) ||
+                !reasons.has(v.reason))
+                return undefined;
+            return {
+                kind: 'decision',
+                id: v.id,
+                series: v.series,
+                attempt: v.attempt,
+                of: v.of,
+                effect: v.effect,
+                reconciled: v.reconciled,
+                next: v.next,
+                reason: v.reason,
+                runId: v.runId,
+                target: v.target,
+                runtimeStageId: v.runtimeStageId,
+                attemptId: v.attemptId,
+                startedAt: v.startedAt,
+            };
+        }
+        const parsed = text(v.id) ? parseAttemptId(v.id) : undefined;
+        if (v.kind !== 'attempt' ||
+            !parsed ||
+            parsed.runtimeStageId !== v.runtimeStageId ||
+            !text(v.series) ||
+            !count(v.attempt) ||
+            v.id !== `${v.series}@${v.attempt}` ||
+            (v.of !== undefined && (!count(v.of) || v.attempt > v.of)) ||
+            !number(v.durationMs) ||
+            !outcomes.has(v.outcome) ||
+            !['stage', 'call', 'observed'].includes(v.attemptKind) ||
+            !nexts.has(v.next) ||
+            !reasons.has(v.reason) ||
+            (v.category !== undefined && !categories.has(v.category)) ||
+            (v.effect !== undefined && !effects.has(v.effect)) ||
+            (v.traceId !== undefined && !text(v.traceId)))
+            return undefined;
+        const retryLoop = loopOf(v.retryLoop);
+        if (retryLoop !== undefined && v.attemptKind !== 'call')
+            return undefined;
+        return {
+            kind: 'attempt',
+            id: v.id,
+            series: v.series,
+            runId: v.runId,
+            runtimeStageId: v.runtimeStageId,
+            target: v.target,
+            ...(v.traceId === undefined ? {} : { traceId: v.traceId }),
+            startedAt: v.startedAt,
+            durationMs: v.durationMs,
+            outcome: v.outcome,
+            ...(v.category === undefined ? {} : { category: v.category }),
+            next: v.next,
+            reason: v.reason,
+            attemptKind: v.attemptKind,
+            attempt: v.attempt,
+            ...(v.of === undefined ? {} : { of: v.of }),
+            ...(v.effect === undefined ? {} : { effect: v.effect }),
+            ...(retryLoop === undefined ? {} : { retryLoop }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function matchesQuery(row, query) {
+    return ((query.since === undefined || row.startedAt >= query.since) &&
+        (query.until === undefined || row.startedAt <= query.until) &&
+        (query.runId === undefined || row.runId === query.runId) &&
+        (query.target === undefined || (row.kind !== 'run' && row.target === query.target)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attemptMetricRows.js","sourceRoot":"","sources":["../../../../src/lib/recorder/attemptMetricRows.ts"],"names":[],"mappings":"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","sourcesContent":["/** Named-field admission for metric rows, shared by live collection and external store reads. */\nimport type { AttemptId } from 'foottrace';\nimport { parseAttemptId } from 'foottrace';\n\nimport type { RetryLoopCall } from '../attempt/retryLoopTypes.js';\nimport type { AttemptCategory, AttemptKind, AttemptNext, AttemptOutcome, AttemptReason } from '../attempt/types.js';\nimport type {\n  AttemptDecisionRow,\n  AttemptQuery,\n  AttemptRow,\n  AttemptRunRow,\n  PhysicalAttemptRow,\n} from './attemptMetricsTypes.js';\n\n// Fixed named fields: a huge unknown envelope is never enumerated just to discard it.\nconst DATA_FIELDS = [\n  'kind',\n  'runId',\n  'startedAt',\n  'endedAt',\n  'outcome',\n  'target',\n  'runtimeStageId',\n  'attemptId',\n  'id',\n  'series',\n  'attempt',\n  'of',\n  'effect',\n  'reconciled',\n  'next',\n  'reason',\n  'attemptKind',\n  'durationMs',\n  'category',\n  'traceId',\n  'retryLoop',\n  'phase',\n  'since',\n  'until',\n  'omittedRows',\n] as const;\n/** Decode plain own data only; external data never gets to run getters or coercion hooks. */\nexport function ownDataRecord(value: unknown): Record<string, unknown> | undefined {\n  try {\n    if (value === null || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))\n      return undefined;\n    const data: Record<string, unknown> = Object.create(null);\n    for (const key of DATA_FIELDS) {\n      const descriptor = Object.getOwnPropertyDescriptor(value, key);\n      if (descriptor === undefined) continue;\n      if (!Object.hasOwn(descriptor, 'value')) return undefined;\n      data[key] = descriptor.value;\n    }\n    return data;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Read an external array window by descriptors, never by executing an index accessor or iterator. */\nexport function metricWindow(value: unknown, maxRows: number): { values: unknown[]; omitted: number } {\n  try {\n    if (!Array.isArray(value)) return { values: [], omitted: 1 };\n    const length = Object.getOwnPropertyDescriptor(value, 'length')?.value as unknown;\n    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0) return { values: [], omitted: 1 };\n    const start = Math.max(0, length - maxRows);\n    const values: unknown[] = [];\n    let omitted = start;\n    for (let index = start; index < length; index++) {\n      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));\n      if (descriptor === undefined || !Object.hasOwn(descriptor, 'value')) omitted++;\n      else values.push(descriptor.value);\n    }\n    return { values, omitted };\n  } catch {\n    return { values: [], omitted: 1 };\n  }\n}\n\nconst outcomes = new Set(['ok', 'failed', 'timeout', 'aborted', 'paused']);\nconst categories = new Set(['timeout', 'rate-limited', 'server', 'network', 'auth', 'permanent', 'unknown']);\nconst reasons = new Set(['succeeded', 'paused', 'aborted', 'exhausted', 'declined', 'no-time-left', 'retryable']);\nconst nexts = new Set(['retry', 'done', 'stop']);\nconst effects = new Set(['none', 'applied', 'unknown']);\nconst number = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;\nconst text = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 4096;\nconst count = (value: unknown): value is number => number(value) && Number.isSafeInteger(value) && value >= 1;\nfunction loopOf(value: unknown): RetryLoopCall | undefined {\n  if (value === undefined) return undefined;\n  const v = ownDataRecord(value);\n  if (v === undefined) throw new TypeError('invalid attempt loop');\n  if (\n    !text(v.id) ||\n    !text(v.series) ||\n    !parseAttemptId(`${v.series}@1`) ||\n    !count(v.attempt) ||\n    !count(v.of) ||\n    v.attempt > v.of ||\n    (v.phase !== 'attempt' && v.phase !== 'reconcile')\n  )\n    throw new TypeError('invalid attempt loop');\n  return { id: v.id, series: v.series, attempt: v.attempt, of: v.of, phase: v.phase };\n}\n/** Invalid stored data is omitted and accounted, never copied as an arbitrary envelope. */\nexport function metricRow(value: unknown): AttemptRow | undefined {\n  try {\n    const v = ownDataRecord(value);\n    if (v === undefined) return undefined;\n    if (!text(v.runId) || !number(v.startedAt)) return undefined;\n    if (v.kind === 'run') {\n      if (\n        !['running', 'ok', 'failed', 'paused'].includes(v.outcome as string) ||\n        (v.endedAt !== undefined && !number(v.endedAt))\n      )\n        return undefined;\n      return {\n        kind: 'run',\n        runId: v.runId,\n        startedAt: v.startedAt,\n        ...(v.endedAt === undefined ? {} : { endedAt: v.endedAt as number }),\n        outcome: v.outcome as AttemptRunRow['outcome'],\n      };\n    }\n    if (!text(v.target) || !text(v.runtimeStageId) || !parseAttemptId(`${v.runtimeStageId}@1`)) return undefined;\n    if (v.kind === 'decision') {\n      const parsed = text(v.attemptId) ? parseAttemptId(v.attemptId) : undefined;\n      if (\n        !parsed ||\n        !text(v.id) ||\n        !text(v.series) ||\n        !parseAttemptId(`${v.series}@1`) ||\n        !count(v.attempt) ||\n        !count(v.of) ||\n        v.attempt > v.of ||\n        !effects.has(v.effect as string) ||\n        typeof v.reconciled !== 'boolean' ||\n        !nexts.has(v.next as string) ||\n        !reasons.has(v.reason as string)\n      )\n        return undefined;\n      return {\n        kind: 'decision',\n        id: v.id,\n        series: v.series,\n        attempt: v.attempt,\n        of: v.of,\n        effect: v.effect as AttemptDecisionRow['effect'],\n        reconciled: v.reconciled,\n        next: v.next as AttemptNext,\n        reason: v.reason as string,\n        runId: v.runId,\n        target: v.target,\n        runtimeStageId: v.runtimeStageId,\n        attemptId: v.attemptId as AttemptId,\n        startedAt: v.startedAt,\n      };\n    }\n    const parsed = text(v.id) ? parseAttemptId(v.id) : undefined;\n    if (\n      v.kind !== 'attempt' ||\n      !parsed ||\n      parsed.runtimeStageId !== v.runtimeStageId ||\n      !text(v.series) ||\n      !count(v.attempt) ||\n      v.id !== `${v.series}@${v.attempt}` ||\n      (v.of !== undefined && (!count(v.of) || v.attempt > v.of)) ||\n      !number(v.durationMs) ||\n      !outcomes.has(v.outcome as string) ||\n      !['stage', 'call', 'observed'].includes(v.attemptKind as string) ||\n      !nexts.has(v.next as string) ||\n      !reasons.has(v.reason as string) ||\n      (v.category !== undefined && !categories.has(v.category as string)) ||\n      (v.effect !== undefined && !effects.has(v.effect as string)) ||\n      (v.traceId !== undefined && !text(v.traceId))\n    )\n      return undefined;\n    const retryLoop = loopOf(v.retryLoop);\n    if (retryLoop !== undefined && v.attemptKind !== 'call') return undefined;\n    return {\n      kind: 'attempt',\n      id: v.id as AttemptId,\n      series: v.series,\n      runId: v.runId,\n      runtimeStageId: v.runtimeStageId,\n      target: v.target,\n      ...(v.traceId === undefined ? {} : { traceId: v.traceId as string }),\n      startedAt: v.startedAt,\n      durationMs: v.durationMs,\n      outcome: v.outcome as AttemptOutcome,\n      ...(v.category === undefined ? {} : { category: v.category as AttemptCategory }),\n      next: v.next as AttemptNext,\n      reason: v.reason as AttemptReason,\n      attemptKind: v.attemptKind as AttemptKind,\n      attempt: v.attempt,\n      ...(v.of === undefined ? {} : { of: v.of as number }),\n      ...(v.effect === undefined ? {} : { effect: v.effect as PhysicalAttemptRow['effect'] }),\n      ...(retryLoop === undefined ? {} : { retryLoop }),\n    };\n  } catch {\n    return undefined;\n  }\n}\nexport function matchesQuery(row: AttemptRow, query: AttemptQuery): boolean {\n  return (\n    (query.since === undefined || row.startedAt >= query.since) &&\n    (query.until === undefined || row.startedAt <= query.until) &&\n    (query.runId === undefined || row.runId === query.runId) &&\n    (query.target === undefined || (row.kind !== 'run' && row.target === query.target))\n  );\n}\n"]}

package/dist/esm/lib/recorder/attemptMetrics.d.ts

@@ -0,0 +1,7 @@
+import type { AttemptAggregate, AttemptMetricRef, AttemptRow, AttemptStorageStats, PhysicalAttemptRow } from './attemptMetricsTypes.js';
+export declare const attemptRowKey: (row: AttemptRow) => string;
+export declare const logicalKey: (runId: string, series: string, attempt: number) => string;
+export declare const seriesKey: (runId: string, series: string) => string;
+export declare function reference(row: PhysicalAttemptRow): AttemptMetricRef;
+export declare function worst(rows: readonly PhysicalAttemptRow[], limit: number): AttemptMetricRef[];
+export declare function aggregateAttempts(rows: readonly AttemptRow[], exemplars: number, storage: AttemptStorageStats): AttemptAggregate;

package/dist/esm/lib/recorder/attemptMetrics.js

@@ -0,0 +1,165 @@
+import { gaveUp } from './attemptSeries.js';
+export const attemptRowKey = (row) => JSON.stringify(row.kind === 'attempt'
+    ? [row.kind, row.runId, row.id]
+    : row.kind === 'decision'
+        ? [row.kind, row.runId, row.series, row.attempt]
+        : [row.kind, row.runId]);
+export const logicalKey = (runId, series, attempt) => JSON.stringify([runId, series, attempt]);
+export const seriesKey = (runId, series) => JSON.stringify([runId, series]);
+export function reference(row) {
+    const { id, series, runId, runtimeStageId, attemptKind, target, traceId, startedAt, durationMs, outcome, category, next, reason, retryLoop, } = row;
+    return {
+        id,
+        series,
+        runId,
+        runtimeStageId,
+        attemptKind,
+        target,
+        ...(traceId === undefined ? {} : { traceId }),
+        startedAt,
+        durationMs,
+        outcome,
+        ...(category === undefined ? {} : { category }),
+        next,
+        reason,
+        ...(retryLoop === undefined ? {} : { retryLoop: { ...retryLoop } }),
+    };
+}
+const order = (a, b) => b.durationMs - a.durationMs || b.startedAt - a.startedAt || a.id.localeCompare(b.id);
+export function worst(rows, limit) {
+    return [...rows].sort(order).slice(0, limit).map(reference);
+}
+function summarized(target, rows, decisions, exemplars) {
+    const byKind = { stage: 0, call: 0, observed: 0 };
+    const byOutcome = { ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };
+    const byCategory = { timeout: 0, 'rate-limited': 0, server: 0, network: 0, auth: 0, permanent: 0, unknown: 0 };
+    let retries = 0;
+    const retried = new Set();
+    const gave = new Set();
+    const stopped = new Set();
+    for (const row of rows) {
+        byKind[row.attemptKind]++;
+        byOutcome[row.outcome]++;
+        if (row.category !== undefined)
+            byCategory[row.category]++;
+        // A reconciliation wire call is work, but its one-call stop is not a logical workflow give-up.
+        if (row.retryLoop?.phase === 'reconcile')
+            continue;
+        const logical = row.retryLoop;
+        const decision = logical === undefined ? row : decisions.get(logicalKey(row.runId, logical.series, logical.attempt));
+        if (decision === undefined ||
+            (logical !== undefined && (decision.kind !== 'decision' || decision.attemptId !== row.id)))
+            continue; // A logical verdict belongs only to the exact physical attempt it cites.
+        const key = seriesKey(row.runId, logical?.series ?? row.series);
+        if (decision.next === 'retry') {
+            retries++;
+            retried.add(key);
+        }
+        if (gaveUp({ next: decision.next, reason: decision.reason })) {
+            gave.add(key);
+            stopped.add(row);
+        }
+    }
+    const sorted = [...rows].sort(order);
+    const n = sorted.length;
+    const rank = (p) => (n === 0 ? 0 : sorted[n - Math.ceil(n * p)].durationMs);
+    const refs = (include) => sorted.filter(include).slice(0, exemplars).map(reference);
+    const used = rows.reduce((n, row) => n + row.durationMs, 0);
+    return {
+        target,
+        count: n,
+        byKind,
+        byOutcome,
+        byCategory,
+        retries,
+        seriesRetried: retried.size,
+        gaveUp: gave.size,
+        effectUnknown: rows.filter((row) => row.effect === 'unknown').length,
+        latencyMs: {
+            p50: rank(0.5),
+            p90: rank(0.9),
+            p95: rank(0.95),
+            max: n === 0 ? 0 : sorted[0].durationMs,
+            mean: n === 0 ? 0 : used / n,
+        },
+        budgetUsedMs: used,
+        exemplars: {
+            slowest: refs(() => true),
+            timeout: refs((row) => row.outcome === 'timeout'),
+            failed: refs((row) => row.outcome === 'failed' || row.outcome === 'aborted'),
+            unknown: refs((row) => row.effect === 'unknown'),
+            gaveUp: refs((row) => stopped.has(row)),
+        },
+    };
+}
+export function aggregateAttempts(rows, exemplars, storage) {
+    // Append stores may contain multiple lifecycle versions; the last row is the recorded current fact.
+    const unique = new Map(rows.map((row) => [attemptRowKey(row), row]));
+    const all = [...unique.values()];
+    const decisions = new Map();
+    const physical = new Map(all
+        .filter((row) => row.kind === 'attempt')
+        .map((row) => [JSON.stringify([row.runId, row.id]), row]));
+    let unsupported = 0;
+    const grouped = new Map();
+    for (const row of all)
+        if (row.kind === 'decision') {
+            const source = physical.get(JSON.stringify([row.runId, row.attemptId]));
+            const loop = source?.retryLoop;
+            if (source === undefined ||
+                source.target !== row.target ||
+                loop?.phase !== 'attempt' ||
+                loop.id !== row.id ||
+                loop.series !== row.series ||
+                loop.attempt !== row.attempt ||
+                loop.of !== row.of) {
+                unsupported++;
+                continue;
+            }
+            decisions.set(logicalKey(row.runId, row.series, row.attempt), row);
+        }
+    for (const row of all)
+        if (row.kind === 'attempt') {
+            const bucket = grouped.get(row.target) ?? [];
+            bucket.push(row);
+            grouped.set(row.target, bucket);
+        }
+    const byTarget = new Map([...grouped].map(([target, entries]) => [target, summarized(target, entries, decisions, exemplars)]));
+    const runs = new Map();
+    for (const row of all) {
+        const bucket = runs.get(row.runId) ?? [];
+        bucket.push(row);
+        runs.set(row.runId, bucket);
+    }
+    const byRun = new Map();
+    for (const [runId, own] of runs) {
+        const attempts = own.filter((row) => row.kind === 'attempt');
+        const perTarget = new Map();
+        for (const row of attempts) {
+            const bucket = perTarget.get(row.target) ?? [];
+            bucket.push(row);
+            perTarget.set(row.target, bucket);
+        }
+        const stats = [...perTarget].map(([target, entries]) => summarized(target, entries, decisions, 0));
+        const run = own.find((row) => row.kind === 'run');
+        byRun.set(runId, {
+            runId,
+            attempts: attempts.length,
+            retries: stats.reduce((n, s) => n + s.retries, 0),
+            gaveUp: stats.reduce((n, s) => n + s.gaveUp, 0),
+            budgetUsedMs: stats.reduce((n, s) => n + s.budgetUsedMs, 0),
+            exemplars: worst(attempts, exemplars),
+            outcome: run?.kind === 'run' ? run.outcome : 'incomplete',
+        });
+    }
+    return {
+        byTarget,
+        byRun,
+        storage: {
+            ...storage,
+            omittedRows: storage.omittedRows + unsupported,
+            incomplete: storage.incomplete || unsupported > 0,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attemptMetrics.js","sourceRoot":"","sources":["../../../../src/lib/recorder/attemptMetrics.ts"],"names":[],"mappings":"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","sourcesContent":["/** Aggregate recorded facts; no execution-tree walk and no reconstruction of logical retries from event counts. */\nimport type { AttemptReason } from '../attempt/types.js';\nimport type {\n  AttemptAggregate,\n  AttemptDecisionRow,\n  AttemptMetricRef,\n  AttemptRow,\n  AttemptStats,\n  AttemptStorageStats,\n  PhysicalAttemptRow,\n} from './attemptMetricsTypes.js';\nimport { gaveUp } from './attemptSeries.js';\n\nexport const attemptRowKey = (row: AttemptRow): string =>\n  JSON.stringify(\n    row.kind === 'attempt'\n      ? [row.kind, row.runId, row.id]\n      : row.kind === 'decision'\n      ? [row.kind, row.runId, row.series, row.attempt]\n      : [row.kind, row.runId],\n  );\nexport const logicalKey = (runId: string, series: string, attempt: number): string =>\n  JSON.stringify([runId, series, attempt]);\nexport const seriesKey = (runId: string, series: string): string => JSON.stringify([runId, series]);\nexport function reference(row: PhysicalAttemptRow): AttemptMetricRef {\n  const {\n    id,\n    series,\n    runId,\n    runtimeStageId,\n    attemptKind,\n    target,\n    traceId,\n    startedAt,\n    durationMs,\n    outcome,\n    category,\n    next,\n    reason,\n    retryLoop,\n  } = row;\n  return {\n    id,\n    series,\n    runId,\n    runtimeStageId,\n    attemptKind,\n    target,\n    ...(traceId === undefined ? {} : { traceId }),\n    startedAt,\n    durationMs,\n    outcome,\n    ...(category === undefined ? {} : { category }),\n    next,\n    reason,\n    ...(retryLoop === undefined ? {} : { retryLoop: { ...retryLoop } }),\n  };\n}\nconst order = (a: PhysicalAttemptRow, b: PhysicalAttemptRow) =>\n  b.durationMs - a.durationMs || b.startedAt - a.startedAt || a.id.localeCompare(b.id);\nexport function worst(rows: readonly PhysicalAttemptRow[], limit: number): AttemptMetricRef[] {\n  return [...rows].sort(order).slice(0, limit).map(reference);\n}\nfunction summarized(\n  target: string,\n  rows: readonly PhysicalAttemptRow[],\n  decisions: Map<string, AttemptDecisionRow>,\n  exemplars: number,\n): AttemptStats {\n  const byKind = { stage: 0, call: 0, observed: 0 };\n  const byOutcome = { ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };\n  const byCategory = { timeout: 0, 'rate-limited': 0, server: 0, network: 0, auth: 0, permanent: 0, unknown: 0 };\n  let retries = 0;\n  const retried = new Set<string>();\n  const gave = new Set<string>();\n  const stopped = new Set<PhysicalAttemptRow>();\n  for (const row of rows) {\n    byKind[row.attemptKind]++;\n    byOutcome[row.outcome]++;\n    if (row.category !== undefined) byCategory[row.category]++;\n    // A reconciliation wire call is work, but its one-call stop is not a logical workflow give-up.\n    if (row.retryLoop?.phase === 'reconcile') continue;\n    const logical = row.retryLoop;\n    const decision =\n      logical === undefined ? row : decisions.get(logicalKey(row.runId, logical.series, logical.attempt));\n    if (\n      decision === undefined ||\n      (logical !== undefined && (decision.kind !== 'decision' || decision.attemptId !== row.id))\n    )\n      continue; // A logical verdict belongs only to the exact physical attempt it cites.\n    const key = seriesKey(row.runId, logical?.series ?? row.series);\n    if (decision.next === 'retry') {\n      retries++;\n      retried.add(key);\n    }\n    if (gaveUp({ next: decision.next, reason: decision.reason as AttemptReason })) {\n      gave.add(key);\n      stopped.add(row);\n    }\n  }\n  const sorted = [...rows].sort(order);\n  const n = sorted.length;\n  const rank = (p: number) => (n === 0 ? 0 : sorted[n - Math.ceil(n * p)].durationMs);\n  const refs = (include: (row: PhysicalAttemptRow) => boolean) =>\n    sorted.filter(include).slice(0, exemplars).map(reference);\n  const used = rows.reduce((n, row) => n + row.durationMs, 0);\n  return {\n    target,\n    count: n,\n    byKind,\n    byOutcome,\n    byCategory,\n    retries,\n    seriesRetried: retried.size,\n    gaveUp: gave.size,\n    effectUnknown: rows.filter((row) => row.effect === 'unknown').length,\n    latencyMs: {\n      p50: rank(0.5),\n      p90: rank(0.9),\n      p95: rank(0.95),\n      max: n === 0 ? 0 : sorted[0].durationMs,\n      mean: n === 0 ? 0 : used / n,\n    },\n    budgetUsedMs: used,\n    exemplars: {\n      slowest: refs(() => true),\n      timeout: refs((row) => row.outcome === 'timeout'),\n      failed: refs((row) => row.outcome === 'failed' || row.outcome === 'aborted'),\n      unknown: refs((row) => row.effect === 'unknown'),\n      gaveUp: refs((row) => stopped.has(row)),\n    },\n  };\n}\nexport function aggregateAttempts(\n  rows: readonly AttemptRow[],\n  exemplars: number,\n  storage: AttemptStorageStats,\n): AttemptAggregate {\n  // Append stores may contain multiple lifecycle versions; the last row is the recorded current fact.\n  const unique = new Map(rows.map((row) => [attemptRowKey(row), row]));\n  const all = [...unique.values()];\n  const decisions = new Map<string, AttemptDecisionRow>();\n  const physical = new Map(\n    all\n      .filter((row): row is PhysicalAttemptRow => row.kind === 'attempt')\n      .map((row) => [JSON.stringify([row.runId, row.id]), row]),\n  );\n  let unsupported = 0;\n  const grouped = new Map<string, PhysicalAttemptRow[]>();\n  for (const row of all)\n    if (row.kind === 'decision') {\n      const source = physical.get(JSON.stringify([row.runId, row.attemptId]));\n      const loop = source?.retryLoop;\n      if (\n        source === undefined ||\n        source.target !== row.target ||\n        loop?.phase !== 'attempt' ||\n        loop.id !== row.id ||\n        loop.series !== row.series ||\n        loop.attempt !== row.attempt ||\n        loop.of !== row.of\n      ) {\n        unsupported++;\n        continue;\n      }\n      decisions.set(logicalKey(row.runId, row.series, row.attempt), row);\n    }\n  for (const row of all)\n    if (row.kind === 'attempt') {\n      const bucket = grouped.get(row.target) ?? [];\n      bucket.push(row);\n      grouped.set(row.target, bucket);\n    }\n  const byTarget = new Map(\n    [...grouped].map(([target, entries]) => [target, summarized(target, entries, decisions, exemplars)]),\n  );\n  const runs = new Map<string, AttemptRow[]>();\n  for (const row of all) {\n    const bucket = runs.get(row.runId) ?? [];\n    bucket.push(row);\n    runs.set(row.runId, bucket);\n  }\n  const byRun: AttemptAggregate['byRun'] = new Map();\n  for (const [runId, own] of runs) {\n    const attempts = own.filter((row): row is PhysicalAttemptRow => row.kind === 'attempt');\n    const perTarget = new Map<string, PhysicalAttemptRow[]>();\n    for (const row of attempts) {\n      const bucket = perTarget.get(row.target) ?? [];\n      bucket.push(row);\n      perTarget.set(row.target, bucket);\n    }\n    const stats = [...perTarget].map(([target, entries]) => summarized(target, entries, decisions, 0));\n    const run = own.find((row) => row.kind === 'run');\n    byRun.set(runId, {\n      runId,\n      attempts: attempts.length,\n      retries: stats.reduce((n, s) => n + s.retries, 0),\n      gaveUp: stats.reduce((n, s) => n + s.gaveUp, 0),\n      budgetUsedMs: stats.reduce((n, s) => n + s.budgetUsedMs, 0),\n      exemplars: worst(attempts, exemplars),\n      outcome: run?.kind === 'run' ? run.outcome : 'incomplete',\n    });\n  }\n  return {\n    byTarget,\n    byRun,\n    storage: {\n      ...storage,\n      omittedRows: storage.omittedRows + unsupported,\n      incomplete: storage.incomplete || unsupported > 0,\n    },\n  };\n}\n"]}

package/dist/esm/lib/recorder/attemptMetricsTypes.d.ts

@@ -0,0 +1,114 @@
+/** Payload-free P7 rows and public metric projections. Store adapters receive named facts, never errors or keys. */
+import type { AttemptId } from 'foottrace';
+import type { RetryLoopCall, RetryLoopDecision } from '../attempt/retryLoopTypes.js';
+import type { AttemptCategory, AttemptEffect, AttemptKind, AttemptNext, AttemptOutcome, AttemptReason } from '../attempt/types.js';
+export interface AttemptMetricRef {
+    readonly id: AttemptId;
+    readonly series: string;
+    readonly runId: string;
+    readonly runtimeStageId: string;
+    readonly attemptKind: AttemptKind;
+    readonly retryLoop?: RetryLoopCall;
+    readonly target: string;
+    readonly traceId?: string;
+    readonly startedAt: number;
+    readonly durationMs: number;
+    readonly outcome: AttemptOutcome;
+    readonly category?: AttemptCategory;
+    readonly next: AttemptNext;
+    readonly reason: AttemptReason;
+}
+export interface PhysicalAttemptRow extends AttemptMetricRef {
+    readonly kind: 'attempt';
+    readonly attemptKind: AttemptKind;
+    readonly attempt: number;
+    readonly of?: number;
+    readonly effect?: AttemptEffect;
+    readonly retryLoop?: RetryLoopCall;
+}
+export interface AttemptDecisionRow extends RetryLoopDecision {
+    readonly kind: 'decision';
+    readonly runId: string;
+    readonly target: string;
+    readonly runtimeStageId: string;
+    readonly attemptId: AttemptId;
+    readonly startedAt: number;
+}
+export interface AttemptRunRow {
+    readonly kind: 'run';
+    readonly runId: string;
+    readonly startedAt: number;
+    readonly endedAt?: number;
+    readonly outcome: 'running' | 'ok' | 'failed' | 'paused';
+}
+export type AttemptRow = PhysicalAttemptRow | AttemptDecisionRow | AttemptRunRow;
+export interface AttemptQuery {
+    readonly since?: number;
+    readonly until?: number;
+    readonly target?: string;
+    readonly runId?: string;
+}
+export interface AttemptStore {
+    append(rows: readonly AttemptRow[]): void | Promise<void>;
+    read(query: AttemptQuery): Promise<readonly AttemptRow[]>;
+    /** Optional known retention accounting; omitted evidence must not appear complete. */
+    stats?(): {
+        readonly omittedRows: number;
+    };
+}
+export interface AttemptStorageStats {
+    readonly pending: number;
+    readonly failed: number;
+    readonly dropped: number;
+    readonly omittedRows: number;
+    readonly incomplete: boolean;
+}
+export interface AttemptStats {
+    readonly target: string;
+    readonly count: number;
+    readonly byKind: Record<AttemptKind, number>;
+    readonly byOutcome: Record<AttemptOutcome, number>;
+    readonly byCategory: Record<AttemptCategory, number>;
+    readonly retries: number;
+    readonly seriesRetried: number;
+    readonly gaveUp: number;
+    readonly effectUnknown: number;
+    readonly latencyMs: {
+        readonly p50: number;
+        readonly p90: number;
+        readonly p95: number;
+        readonly max: number;
+        readonly mean: number;
+    };
+    /** Sum of attempt durations (work time), which can overlap or nest; not elapsed run time. */
+    readonly budgetUsedMs: number;
+    readonly exemplars: {
+        readonly slowest: AttemptMetricRef[];
+        readonly timeout: AttemptMetricRef[];
+        readonly failed: AttemptMetricRef[];
+        readonly unknown: AttemptMetricRef[];
+        readonly gaveUp: AttemptMetricRef[];
+    };
+}
+export interface AttemptRunStats {
+    readonly runId: string;
+    readonly attempts: number;
+    readonly retries: number;
+    readonly gaveUp: number;
+    readonly budgetUsedMs: number;
+    readonly budgetMs?: number;
+    readonly exemplars: AttemptMetricRef[];
+    readonly outcome: AttemptRunRow['outcome'] | 'incomplete';
+}
+export interface AttemptAggregate {
+    readonly byTarget: Map<string, AttemptStats>;
+    readonly byRun: Map<string, AttemptRunStats>;
+    readonly storage: AttemptStorageStats;
+}
+export interface AttemptRecorderOptions {
+    readonly exemplars?: number;
+    readonly maxRows?: number;
+    readonly maxPending?: number;
+    readonly storeTimeoutMs?: number;
+    readonly store?: AttemptStore;
+}

package/dist/esm/lib/recorder/attemptMetricsTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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