footprintjs 10.0.1 → 10.2.0

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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

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

@@ -0,0 +1,78 @@
+import type { AttemptStats, PhysicalAttemptRow } from './attemptMetricsTypes.js';
+export declare function attemptOTel(rows: readonly PhysicalAttemptRow[], byTarget: ReadonlyMap<string, AttemptStats>, limit: number): {
+    resourceMetrics: {
+        resource: {
+            attributes: never[];
+        };
+        scopeMetrics: {
+            scope: {
+                name: string;
+            };
+            metrics: ({
+                name: string;
+                unit: string;
+                description: string;
+                histogram: {
+                    aggregationTemporality: number;
+                    dataPoints: {
+                        attributes: {
+                            key: string;
+                            value: {
+                                stringValue: string;
+                            };
+                        }[];
+                        startTimeUnixNano: string;
+                        timeUnixNano: string;
+                        count: string;
+                        sum: number;
+                        explicitBounds: number[];
+                        bucketCounts: string[];
+                        exemplars: {
+                            traceId?: string | undefined;
+                            asDouble: number;
+                            timeUnixNano: string;
+                            filteredAttributes: {
+                                key: string;
+                                value: {
+                                    stringValue: string;
+                                };
+                            }[];
+                        }[];
+                    }[];
+                };
+                sum?: undefined;
+            } | {
+                name: string;
+                unit: string;
+                sum: {
+                    aggregationTemporality: number;
+                    isMonotonic: boolean;
+                    dataPoints: {
+                        attributes: {
+                            key: string;
+                            value: {
+                                stringValue: string;
+                            };
+                        }[];
+                        startTimeUnixNano: string;
+                        timeUnixNano: string;
+                        asDouble: number;
+                        exemplars: {
+                            asDouble: number;
+                            traceId?: string | undefined;
+                            timeUnixNano: string;
+                            filteredAttributes: {
+                                key: string;
+                                value: {
+                                    stringValue: string;
+                                };
+                            }[];
+                        }[];
+                    }[];
+                };
+                description?: undefined;
+                histogram?: undefined;
+            })[];
+        }[];
+    }[];
+};

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

@@ -0,0 +1,107 @@
+/** OTLP JSON metrics: exact histogram bucket counts and real bounded physical-attempt exemplars. */
+import { worst } from './attemptMetrics.js';
+const BOUNDS = [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
+const attribute = (key, value) => ({ key, value: { stringValue: value } });
+const nano = (ms) => (BigInt(Math.trunc(ms)) * 1000000n).toString();
+function exemplars(refs, value = 'duration') {
+    return refs.map((ref) => ({
+        asDouble: value === 'count' ? 1 : ref.durationMs,
+        timeUnixNano: nano(ref.startedAt),
+        filteredAttributes: [
+            attribute('footprint.attempt.kind', ref.attemptKind),
+            attribute('footprint.attempt.id', ref.id),
+            attribute('footprint.runtime_stage_id', ref.runtimeStageId),
+            attribute('footprint.series', ref.series),
+            attribute('footprint.run_id', ref.runId),
+            ...(ref.traceId === undefined ? [] : [attribute('footprint.trace_id', ref.traceId)]),
+            ...(ref.retryLoop === undefined
+                ? []
+                : [
+                    attribute('footprint.retry_loop.series', ref.retryLoop.series),
+                    attribute('footprint.retry_loop.phase', ref.retryLoop.phase),
+                ]),
+        ],
+        ...(/^[a-f0-9]{32}$/.test(ref.traceId ?? '') && !/^0+$/.test(ref.traceId ?? '') ? { traceId: ref.traceId } : {}),
+    }));
+}
+export function attemptOTel(rows, byTarget, limit) {
+    const grouped = new Map();
+    for (const row of rows) {
+        const key = JSON.stringify([row.target, row.outcome, row.category ?? null, row.attemptKind]);
+        const bucket = grouped.get(key) ?? [];
+        bucket.push(row);
+        grouped.set(key, bucket);
+    }
+    const histograms = [...grouped.values()].map((group) => {
+        const first = group[0];
+        const buckets = Array(BOUNDS.length + 1).fill(0);
+        for (const row of group) {
+            const at = BOUNDS.findIndex((bound) => row.durationMs <= bound);
+            buckets[at < 0 ? BOUNDS.length : at]++;
+        }
+        return {
+            attributes: [
+                attribute('footprint.target', first.target),
+                attribute('footprint.outcome', first.outcome),
+                attribute('footprint.attempt.kind', first.attemptKind),
+                ...(first.category === undefined ? [] : [attribute('footprint.category', first.category)]),
+            ],
+            startTimeUnixNano: nano(group.reduce((n, row) => Math.min(n, row.startedAt), Infinity)),
+            timeUnixNano: nano(group.reduce((n, row) => Math.max(n, row.startedAt + row.durationMs), 0)),
+            count: String(group.length),
+            sum: group.reduce((n, row) => n + row.durationMs, 0),
+            explicitBounds: [...BOUNDS],
+            bucketCounts: buckets.map(String),
+            exemplars: exemplars(worst(group, limit)),
+        };
+    });
+    const counts = histograms.map(({ attributes, startTimeUnixNano, timeUnixNano, count, exemplars: refs }) => ({
+        attributes,
+        startTimeUnixNano,
+        timeUnixNano,
+        asDouble: Number(count),
+        exemplars: refs.map((ref) => ({ ...ref, asDouble: 1 })),
+    }));
+    const gave = [...byTarget.values()]
+        .filter((stat) => stat.gaveUp > 0)
+        .map((stat) => ({
+        attributes: [attribute('footprint.target', stat.target)],
+        asDouble: stat.gaveUp,
+        startTimeUnixNano: nano(rows.filter((row) => row.target === stat.target).reduce((n, row) => Math.min(n, row.startedAt), Infinity)),
+        timeUnixNano: nano(rows
+            .filter((row) => row.target === stat.target)
+            .reduce((n, row) => Math.max(n, row.startedAt + row.durationMs), 0)),
+        exemplars: exemplars(stat.exemplars.gaveUp, 'count'),
+    }));
+    return {
+        resourceMetrics: [
+            {
+                resource: { attributes: [] },
+                scopeMetrics: [
+                    {
+                        scope: { name: 'footprintjs.attempts' },
+                        metrics: [
+                            {
+                                name: 'footprint.attempt.duration',
+                                unit: 'ms',
+                                description: 'Attempt work duration; nested attempts may overlap',
+                                histogram: { aggregationTemporality: 2, dataPoints: histograms },
+                            },
+                            {
+                                name: 'footprint.attempt.count',
+                                unit: '{attempt}',
+                                sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints: counts },
+                            },
+                            {
+                                name: 'footprint.attempt.gave_up',
+                                unit: '{series}',
+                                sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints: gave },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attemptOTel.js","sourceRoot":"","sources":["../../../../src/lib/recorder/attemptOTel.ts"],"names":[],"mappings":"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","sourcesContent":["/** OTLP JSON metrics: exact histogram bucket counts and real bounded physical-attempt exemplars. */\nimport { worst } from './attemptMetrics.js';\nimport type { AttemptMetricRef, AttemptStats, PhysicalAttemptRow } from './attemptMetricsTypes.js';\nconst BOUNDS = [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];\nconst attribute = (key: string, value: string) => ({ key, value: { stringValue: value } });\nconst nano = (ms: number) => (BigInt(Math.trunc(ms)) * 1000000n).toString();\nfunction exemplars(refs: readonly AttemptMetricRef[], value: 'duration' | 'count' = 'duration') {\n  return refs.map((ref) => ({\n    asDouble: value === 'count' ? 1 : ref.durationMs,\n    timeUnixNano: nano(ref.startedAt),\n    filteredAttributes: [\n      attribute('footprint.attempt.kind', ref.attemptKind),\n      attribute('footprint.attempt.id', ref.id),\n      attribute('footprint.runtime_stage_id', ref.runtimeStageId),\n      attribute('footprint.series', ref.series),\n      attribute('footprint.run_id', ref.runId),\n      ...(ref.traceId === undefined ? [] : [attribute('footprint.trace_id', ref.traceId)]),\n      ...(ref.retryLoop === undefined\n        ? []\n        : [\n            attribute('footprint.retry_loop.series', ref.retryLoop.series),\n            attribute('footprint.retry_loop.phase', ref.retryLoop.phase),\n          ]),\n    ],\n    ...(/^[a-f0-9]{32}$/.test(ref.traceId ?? '') && !/^0+$/.test(ref.traceId ?? '') ? { traceId: ref.traceId } : {}),\n  }));\n}\nexport function attemptOTel(\n  rows: readonly PhysicalAttemptRow[],\n  byTarget: ReadonlyMap<string, AttemptStats>,\n  limit: number,\n) {\n  const grouped = new Map<string, PhysicalAttemptRow[]>();\n  for (const row of rows) {\n    const key = JSON.stringify([row.target, row.outcome, row.category ?? null, row.attemptKind]);\n    const bucket = grouped.get(key) ?? [];\n    bucket.push(row);\n    grouped.set(key, bucket);\n  }\n  const histograms = [...grouped.values()].map((group) => {\n    const first = group[0];\n    const buckets = Array(BOUNDS.length + 1).fill(0) as number[];\n    for (const row of group) {\n      const at = BOUNDS.findIndex((bound) => row.durationMs <= bound);\n      buckets[at < 0 ? BOUNDS.length : at]++;\n    }\n    return {\n      attributes: [\n        attribute('footprint.target', first.target),\n        attribute('footprint.outcome', first.outcome),\n        attribute('footprint.attempt.kind', first.attemptKind),\n        ...(first.category === undefined ? [] : [attribute('footprint.category', first.category)]),\n      ],\n      startTimeUnixNano: nano(group.reduce((n, row) => Math.min(n, row.startedAt), Infinity)),\n      timeUnixNano: nano(group.reduce((n, row) => Math.max(n, row.startedAt + row.durationMs), 0)),\n      count: String(group.length),\n      sum: group.reduce((n, row) => n + row.durationMs, 0),\n      explicitBounds: [...BOUNDS],\n      bucketCounts: buckets.map(String),\n      exemplars: exemplars(worst(group, limit)),\n    };\n  });\n  const counts = histograms.map(({ attributes, startTimeUnixNano, timeUnixNano, count, exemplars: refs }) => ({\n    attributes,\n    startTimeUnixNano,\n    timeUnixNano,\n    asDouble: Number(count),\n    exemplars: refs.map((ref) => ({ ...ref, asDouble: 1 })),\n  }));\n  const gave = [...byTarget.values()]\n    .filter((stat) => stat.gaveUp > 0)\n    .map((stat) => ({\n      attributes: [attribute('footprint.target', stat.target)],\n      asDouble: stat.gaveUp,\n      startTimeUnixNano: nano(\n        rows.filter((row) => row.target === stat.target).reduce((n, row) => Math.min(n, row.startedAt), Infinity),\n      ),\n      timeUnixNano: nano(\n        rows\n          .filter((row) => row.target === stat.target)\n          .reduce((n, row) => Math.max(n, row.startedAt + row.durationMs), 0),\n      ),\n      exemplars: exemplars(stat.exemplars.gaveUp, 'count'),\n    }));\n  return {\n    resourceMetrics: [\n      {\n        resource: { attributes: [] },\n        scopeMetrics: [\n          {\n            scope: { name: 'footprintjs.attempts' },\n            metrics: [\n              {\n                name: 'footprint.attempt.duration',\n                unit: 'ms',\n                description: 'Attempt work duration; nested attempts may overlap',\n                histogram: { aggregationTemporality: 2, dataPoints: histograms },\n              },\n              {\n                name: 'footprint.attempt.count',\n                unit: '{attempt}',\n                sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints: counts },\n              },\n              {\n                name: 'footprint.attempt.gave_up',\n                unit: '{series}',\n                sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints: gave },\n              },\n            ],\n          },\n        ],\n      },\n    ],\n  };\n}\n"]}

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

@@ -0,0 +1,81 @@
+/**
+ * recorder/attemptSeries.ts — what a RECORDER keeps of a series: the one evidence predicate, the stop that gave up, and a
+ * per-series tally rebuilt from `onAttempt` records (design §5.1, P1c).
+ *
+ * WHY one module: seven built-in recorders account for attempts, and each must agree on two questions — "is this
+ * series worth a row?" and "did it give up?" — or a Topology node and a boundary count would disagree about the
+ * same run. Asked here, once.
+ *
+ * THE predicate (`isRetryEvidence`): a series is evidence when it RETRIED (some attempt was followed by another),
+ * GAVE UP while a retry was possible (it stopped `exhausted`, `declined` or `no-time-left` with `of > 1`, §3.9), or
+ * TIMED OUT (an attempt ran out of its cap or the deadline — P1b's lone timeout is the incident's own shape). A
+ * policy stage that succeeded first time — or that paused or was aborted on its first attempt — is
+ * indistinguishable from a stage with no policy in every recorder row, so a chart in which nothing retried keeps
+ * those rows byte-identical (law 2). So is a LONE attempt (`of: 1`, recorded for every stage of a run with a
+ * deadline, P1b) that merely failed: a stage error like any other, so a deadline alone never multiplies rows.
+ *
+ * Records arrive in order within a series, so the predicate is decided at the series' FIRST record: attempt 1 is
+ * evidence iff it did not end the series quietly, and every later attempt is evidence by being one.
+ *
+ * L5 (`recorder/**`), beside the stores: it imports the attempt vocabulary's types only (the L0 leaf), so
+ * `recorder/` never takes a runtime edge into `attempt/` — whose runner reaches `decide/` and `scope/`, which
+ * import `recorder/` (a module cycle).
+ */
+import type { AttemptOutcome, AttemptRecord, AttemptSummary } from '../attempt/types.js';
+/**
+ * One attempt, named — `series` (the stage execution's `runtimeStageId`) plus the 1-based `attempt`. The
+ * identity `AttemptRecord` carries until the engine stamps foottrace's attempt id (design §3.4).
+ */
+export interface AttemptRef {
+    readonly series: string;
+    readonly attempt: number;
+}
+/** Attempt counts per outcome — the shape `AttemptSummary` uses, without the series' end. */
+export type AttemptOutcomeCounts = Readonly<Record<AttemptOutcome, number>>;
+/** The series stopped on this record because retrying was given up (exhausted, declined or no time left). */
+export declare function gaveUp(record: Pick<AttemptRecord, 'next' | 'reason'>): boolean;
+/**
+ * The record belongs to a STAGE's series that retried, gave up or timed out — the one row predicate every recorder
+ * shares. A call's or an observed attempt (`scope.$call`, `observed()`, P2) is never a row here: these recorders keep
+ * one row per stage execution, and a call is counted per TARGET (the `attempts()` recorder, P7) — drawn as a stage's
+ * retry it would say the stage retried when only its call did.
+ */
+export declare function isRetryEvidence(record: AttemptRecord): boolean;
+/** Did the attempt itself fail — a failure, a timeout or the run's abort (not a success, not a pause)? */
+export declare function attemptFailed(record: AttemptRecord): boolean;
+/** The record's name. */
+export declare function attemptRef(record: AttemptRecord): AttemptRef;
+/**
+ * The path-prefixed id of the subflow an attempt's stage ran in (`'sf-outer/sf-inner'`), or `undefined` at the top
+ * level — read off the stage execution's `runtimeStageId` (the event's, else the series'), the one id that always
+ * carries it.
+ */
+export declare function subflowOfAttempt(event: {
+    readonly record: AttemptRecord;
+    readonly traversalContext?: {
+        readonly runtimeStageId: string;
+    };
+}): string | undefined;
+/** A zeroed per-outcome count. */
+export declare function emptyOutcomeCounts(): Record<AttemptOutcome, number>;
+/** What a recorder knows of one series so far. `summary` is present once the series ended. */
+export interface AttemptSeriesState {
+    readonly series: string;
+    /** The series' attempts, in order. */
+    readonly attempts: readonly AttemptRef[];
+    /**
+     * The series at a glance — the same value the runner stamps on `StageSnapshot.attemptSummary`, rebuilt from the
+     * records. Absent while the last record says `retry`: the series is in flight, or the run's signal cut its wait
+     * (no record follows; only the execution tree knows how it ended).
+     */
+    readonly summary?: AttemptSummary;
+}
+/**
+ * Per-series tallies, keyed by `series`, for the series that are evidence. `add` returns the series' state after
+ * the record, or `undefined` for a record that is not evidence (nothing to keep).
+ */
+export declare class AttemptSeriesBook {
+    private readonly bySeries;
+    add(record: AttemptRecord): AttemptSeriesState | undefined;
+    clear(): void;
+}