@pipeline-builder/pipeline-data 4.1.23 → 4.1.25

package/lib/api/reporting/daily-rollup.d.ts

@@ -0,0 +1,41 @@
+/**
+ * How long after a day closes before it is rolled up (hours).
+ *
+ * Six by default, matching the report scheduler's own settle delay: both exist for
+ * the same reason, and a rollup that lagged the report would make a scheduled
+ * report read a half-built day.
+ */
+export declare function rollupSettleHours(): number;
+/** Rows per rebuild pass. Bounds the statement, not the backlog. */
+export declare function rollupBatchDays(): number;
+/** The UTC midnight that starts `d`'s day. */
+export declare function utcDayStart(d: Date): Date;
+/**
+ * Rebuild the rollup rows for one UTC day, for every org that had activity.
+ *
+ * ONE statement, computed entirely in Postgres. Deliberately not "select the
+ * events, aggregate in Node, write the rows": the whole point of the rollup is to
+ * avoid moving a day's events across the wire, and a job that did it to BUILD the
+ * rollup would just move the cost rather than remove it.
+ *
+ * Percentiles use `PERCENTILE_CONT`, which is the same function the on-demand
+ * queries use — so a rollup-backed number and a live number agree rather than
+ * differing by an interpolation rule.
+ */
+export declare function rebuildDay(day: Date): Promise<number>;
+/**
+ * One rollup pass: rebuild the most recent settled days.
+ *
+ * Rebuilding a WINDOW rather than only the newest day is what handles late
+ * events: the dead-letter redrive lands events for days already rolled up, and a
+ * job that only ever built "yesterday" would leave those days permanently wrong.
+ * Recomputing a week costs one statement per day and makes lateness self-healing
+ * instead of a support question.
+ *
+ * Never throws — the caller is a scheduler tick, and a failed pass must retry next
+ * tick rather than take the service's background work down with it.
+ */
+export declare function runRollupPass(now?: Date): Promise<{
+    days: number;
+    rows: number;
+}>;

package/lib/api/reporting/daily-rollup.js

@@ -0,0 +1,173 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Building `execution_daily_rollups` from events.
+ *
+ * Every section that says "runs", "success rate", "p95" or "build minutes" reads
+ * these rows, so a quarterly report over a busy org costs a few hundred rows
+ * instead of a few hundred thousand — and keeps working after retention has swept
+ * the events it was built from.
+ *
+ * TWO PROPERTIES THE JOB HAS TO HAVE, and both shape the code:
+ *
+ *  - IDEMPOTENT PER DAY. A day is recomputed WHOLESALE and upserted, never
+ *    incremented. Incrementing is how a redelivered event, a retried tick or a
+ *    crashed half-run silently inflates a count, and an inflated success rate is
+ *    worse than a missing one because nobody can tell.
+ *  - REBUILDS A DAY WHEN LATE EVENTS ARRIVE. The ingest's dead-letter queue is
+ *    redriven hours later, so yesterday's numbers legitimately change. The
+ *    `computed_at` stamp is what makes that visible rather than mysterious.
+ *
+ * THE SETTLE DELAY lives here too: a day is only rolled up once it has been closed
+ * long enough for in-flight executions to finish. Rolling up a day at 00:01 counts
+ * every execution still running at midnight as neither a success nor a failure.
+ */
+import { createLogger, errorMessage, envInt } from '@pipeline-builder/api-core';
+import { sql } from 'drizzle-orm';
+import { withTenantTx } from '../../database/tenancy.js';
+const logger = createLogger('daily-rollup');
+/**
+ * How long after a day closes before it is rolled up (hours).
+ *
+ * Six by default, matching the report scheduler's own settle delay: both exist for
+ * the same reason, and a rollup that lagged the report would make a scheduled
+ * report read a half-built day.
+ */
+export function rollupSettleHours() {
+    return envInt('REPORTING_ROLLUP_SETTLE_HOURS', 6, { min: 0 });
+}
+/** Rows per rebuild pass. Bounds the statement, not the backlog. */
+export function rollupBatchDays() {
+    return envInt('REPORTING_ROLLUP_BATCH_DAYS', 7, { min: 1 });
+}
+/** The UTC midnight that starts `d`'s day. */
+export function utcDayStart(d) {
+    return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+}
+/**
+ * Rebuild the rollup rows for one UTC day, for every org that had activity.
+ *
+ * ONE statement, computed entirely in Postgres. Deliberately not "select the
+ * events, aggregate in Node, write the rows": the whole point of the rollup is to
+ * avoid moving a day's events across the wire, and a job that did it to BUILD the
+ * rollup would just move the cost rather than remove it.
+ *
+ * Percentiles use `PERCENTILE_CONT`, which is the same function the on-demand
+ * queries use — so a rollup-backed number and a live number agree rather than
+ * differing by an interpolation rule.
+ */
+export async function rebuildDay(day) {
+    const dayStart = utcDayStart(day);
+    const dayEnd = new Date(dayStart.getTime() + 24 * 3600_000);
+    // TWO GRAINS, one scan, and no GROUPING SETS needed: a PIPELINE event carries
+    // no stage name, so it collapses to the `''` pipeline-level row, and a STAGE
+    // event lands on its own stage row. The event shape gives the hierarchy for
+    // free.
+    //
+    // CTEs rather than window functions, because `PERCENTILE_CONT` is an ordered-set
+    // aggregate and cannot be used as a window function at all — the shape that
+    // looks natural here does not run.
+    const result = await withTenantTx((tx) => tx.execute(sql `
+    WITH ev AS (
+      SELECT
+        org_id,
+        pipeline_id::text AS pipeline_id,
+        COALESCE(stage_name, '') AS stage_name,
+        status,
+        failure_category,
+        duration_ms
+      FROM pipeline_events
+      WHERE created_at >= ${dayStart} AND created_at < ${dayEnd}
+        AND pipeline_id IS NOT NULL
+        AND event_type IN ('PIPELINE', 'STAGE')
+    ),
+    cats AS (
+      SELECT org_id, pipeline_id, stage_name,
+             jsonb_object_agg(failure_category, n) AS failures_by_category
+      FROM (
+        SELECT org_id, pipeline_id, stage_name, failure_category, COUNT(*)::int AS n
+        FROM ev
+        WHERE failure_category IS NOT NULL
+        GROUP BY 1, 2, 3, 4
+      ) t
+      GROUP BY 1, 2, 3
+    ),
+    agg AS (
+      SELECT
+        org_id, pipeline_id, stage_name,
+        COUNT(*)::int AS runs,
+        COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'SUCCESS'))::int AS succeeded,
+        COUNT(*) FILTER (WHERE status IN ('FAILED', 'FAILURE', 'ERROR', 'TIMED_OUT'))::int AS failed,
+        -- NULL durations are ignored by PERCENTILE_CONT, which is what we want: an
+        -- event with no duration has no timing to contribute, and treating it as
+        -- zero would drag every percentile down.
+        PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::int AS p50_ms,
+        PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY duration_ms)::int AS p90_ms,
+        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY duration_ms)::int AS p95_ms,
+        (SUM(COALESCE(duration_ms, 0)) / 1000)::int AS build_seconds
+      FROM ev
+      GROUP BY 1, 2, 3
+    )
+    INSERT INTO execution_daily_rollups (
+      org_id, day, pipeline_id, stage_name,
+      runs, succeeded, failed, failures_by_category,
+      p50_ms, p90_ms, p95_ms, build_seconds, computed_at
+    )
+    SELECT
+      a.org_id, ${dayStart}::timestamptz, a.pipeline_id, a.stage_name,
+      a.runs, a.succeeded, a.failed,
+      COALESCE(c.failures_by_category, '{}'::jsonb),
+      a.p50_ms, a.p90_ms, a.p95_ms, a.build_seconds, NOW()
+    FROM agg a
+    LEFT JOIN cats c
+      ON c.org_id = a.org_id AND c.pipeline_id = a.pipeline_id AND c.stage_name = a.stage_name
+    ON CONFLICT (org_id, day, pipeline_id, stage_name) DO UPDATE SET
+      runs = excluded.runs,
+      succeeded = excluded.succeeded,
+      failed = excluded.failed,
+      failures_by_category = excluded.failures_by_category,
+      p50_ms = excluded.p50_ms,
+      p90_ms = excluded.p90_ms,
+      p95_ms = excluded.p95_ms,
+      build_seconds = excluded.build_seconds,
+      computed_at = excluded.computed_at
+  `));
+    const rows = result.rowCount ?? 0;
+    logger.debug('Rolled up a day', { day: dayStart.toISOString().slice(0, 10), rows });
+    return rows;
+}
+/**
+ * One rollup pass: rebuild the most recent settled days.
+ *
+ * Rebuilding a WINDOW rather than only the newest day is what handles late
+ * events: the dead-letter redrive lands events for days already rolled up, and a
+ * job that only ever built "yesterday" would leave those days permanently wrong.
+ * Recomputing a week costs one statement per day and makes lateness self-healing
+ * instead of a support question.
+ *
+ * Never throws — the caller is a scheduler tick, and a failed pass must retry next
+ * tick rather than take the service's background work down with it.
+ */
+export async function runRollupPass(now = new Date()) {
+    const settleMs = rollupSettleHours() * 3600_000;
+    // The newest day that has settled. A day is only built once everything that
+    // started in it has had time to finish.
+    const newest = utcDayStart(new Date(now.getTime() - settleMs));
+    let rows = 0;
+    let days = 0;
+    for (let i = 0; i < rollupBatchDays(); i++) {
+        const day = new Date(newest.getTime() - i * 24 * 3600_000);
+        try {
+            rows += await rebuildDay(day);
+            days++;
+        }
+        catch (err) {
+            logger.warn('Rollup pass failed for a day; it will be retried next pass', {
+                day: day.toISOString().slice(0, 10),
+                error: errorMessage(err),
+            });
+        }
+    }
+    return { days, rows };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daily-rollup.js","sourceRoot":"","sources":["../../../src/api/reporting/daily-rollup.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,MAAM,CAAC,+BAA+B,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAChE,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,eAAe;IAC7B,OAAO,MAAM,CAAC,6BAA6B,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,WAAW,CAAC,CAAO;IACjC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,GAAS;IACxC,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAClC,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC;IAE5D,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,QAAQ;IACR,EAAE;IACF,iFAAiF;IACjF,4EAA4E;IAC5E,mCAAmC;IACnC,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;;;;4BAU9B,QAAQ,qBAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqC7C,QAAQ;;;;;;;;;;;;;;;;;GAiBvB,CAAC,CAAC,CAAC;IACJ,MAAM,IAAI,GAAI,MAA2C,CAAC,QAAQ,IAAI,CAAC,CAAC;IACxE,MAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACpF,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,GAAG,GAAS,IAAI,IAAI,EAAE;IACxD,MAAM,QAAQ,GAAG,iBAAiB,EAAE,GAAG,QAAQ,CAAC;IAChD,4EAA4E;IAC5E,wCAAwC;IACxC,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC;IAC/D,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC;QAC3D,IAAI,CAAC;YACH,IAAI,IAAI,MAAM,UAAU,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,EAAE,CAAC;QACT,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,4DAA4D,EAAE;gBACxE,GAAG,EAAE,GAAG,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;gBACnC,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC;aACzB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AACxB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Building `execution_daily_rollups` from events.\n *\n * Every section that says \"runs\", \"success rate\", \"p95\" or \"build minutes\" reads\n * these rows, so a quarterly report over a busy org costs a few hundred rows\n * instead of a few hundred thousand — and keeps working after retention has swept\n * the events it was built from.\n *\n * TWO PROPERTIES THE JOB HAS TO HAVE, and both shape the code:\n *\n *  - IDEMPOTENT PER DAY. A day is recomputed WHOLESALE and upserted, never\n *    incremented. Incrementing is how a redelivered event, a retried tick or a\n *    crashed half-run silently inflates a count, and an inflated success rate is\n *    worse than a missing one because nobody can tell.\n *  - REBUILDS A DAY WHEN LATE EVENTS ARRIVE. The ingest's dead-letter queue is\n *    redriven hours later, so yesterday's numbers legitimately change. The\n *    `computed_at` stamp is what makes that visible rather than mysterious.\n *\n * THE SETTLE DELAY lives here too: a day is only rolled up once it has been closed\n * long enough for in-flight executions to finish. Rolling up a day at 00:01 counts\n * every execution still running at midnight as neither a success nor a failure.\n */\n\nimport { createLogger, errorMessage, envInt } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { withTenantTx } from '../../database/tenancy.js';\n\nconst logger = createLogger('daily-rollup');\n\n/**\n * How long after a day closes before it is rolled up (hours).\n *\n * Six by default, matching the report scheduler's own settle delay: both exist for\n * the same reason, and a rollup that lagged the report would make a scheduled\n * report read a half-built day.\n */\nexport function rollupSettleHours(): number {\n  return envInt('REPORTING_ROLLUP_SETTLE_HOURS', 6, { min: 0 });\n}\n\n/** Rows per rebuild pass. Bounds the statement, not the backlog. */\nexport function rollupBatchDays(): number {\n  return envInt('REPORTING_ROLLUP_BATCH_DAYS', 7, { min: 1 });\n}\n\n/** The UTC midnight that starts `d`'s day. */\nexport function utcDayStart(d: Date): Date {\n  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));\n}\n\n/**\n * Rebuild the rollup rows for one UTC day, for every org that had activity.\n *\n * ONE statement, computed entirely in Postgres. Deliberately not \"select the\n * events, aggregate in Node, write the rows\": the whole point of the rollup is to\n * avoid moving a day's events across the wire, and a job that did it to BUILD the\n * rollup would just move the cost rather than remove it.\n *\n * Percentiles use `PERCENTILE_CONT`, which is the same function the on-demand\n * queries use — so a rollup-backed number and a live number agree rather than\n * differing by an interpolation rule.\n */\nexport async function rebuildDay(day: Date): Promise<number> {\n  const dayStart = utcDayStart(day);\n  const dayEnd = new Date(dayStart.getTime() + 24 * 3600_000);\n\n  // TWO GRAINS, one scan, and no GROUPING SETS needed: a PIPELINE event carries\n  // no stage name, so it collapses to the `''` pipeline-level row, and a STAGE\n  // event lands on its own stage row. The event shape gives the hierarchy for\n  // free.\n  //\n  // CTEs rather than window functions, because `PERCENTILE_CONT` is an ordered-set\n  // aggregate and cannot be used as a window function at all — the shape that\n  // looks natural here does not run.\n  const result = await withTenantTx((tx) => tx.execute(sql`\n    WITH ev AS (\n      SELECT\n        org_id,\n        pipeline_id::text AS pipeline_id,\n        COALESCE(stage_name, '') AS stage_name,\n        status,\n        failure_category,\n        duration_ms\n      FROM pipeline_events\n      WHERE created_at >= ${dayStart} AND created_at < ${dayEnd}\n        AND pipeline_id IS NOT NULL\n        AND event_type IN ('PIPELINE', 'STAGE')\n    ),\n    cats AS (\n      SELECT org_id, pipeline_id, stage_name,\n             jsonb_object_agg(failure_category, n) AS failures_by_category\n      FROM (\n        SELECT org_id, pipeline_id, stage_name, failure_category, COUNT(*)::int AS n\n        FROM ev\n        WHERE failure_category IS NOT NULL\n        GROUP BY 1, 2, 3, 4\n      ) t\n      GROUP BY 1, 2, 3\n    ),\n    agg AS (\n      SELECT\n        org_id, pipeline_id, stage_name,\n        COUNT(*)::int AS runs,\n        COUNT(*) FILTER (WHERE status IN ('SUCCEEDED', 'SUCCESS'))::int AS succeeded,\n        COUNT(*) FILTER (WHERE status IN ('FAILED', 'FAILURE', 'ERROR', 'TIMED_OUT'))::int AS failed,\n        -- NULL durations are ignored by PERCENTILE_CONT, which is what we want: an\n        -- event with no duration has no timing to contribute, and treating it as\n        -- zero would drag every percentile down.\n        PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY duration_ms)::int AS p50_ms,\n        PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY duration_ms)::int AS p90_ms,\n        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY duration_ms)::int AS p95_ms,\n        (SUM(COALESCE(duration_ms, 0)) / 1000)::int AS build_seconds\n      FROM ev\n      GROUP BY 1, 2, 3\n    )\n    INSERT INTO execution_daily_rollups (\n      org_id, day, pipeline_id, stage_name,\n      runs, succeeded, failed, failures_by_category,\n      p50_ms, p90_ms, p95_ms, build_seconds, computed_at\n    )\n    SELECT\n      a.org_id, ${dayStart}::timestamptz, a.pipeline_id, a.stage_name,\n      a.runs, a.succeeded, a.failed,\n      COALESCE(c.failures_by_category, '{}'::jsonb),\n      a.p50_ms, a.p90_ms, a.p95_ms, a.build_seconds, NOW()\n    FROM agg a\n    LEFT JOIN cats c\n      ON c.org_id = a.org_id AND c.pipeline_id = a.pipeline_id AND c.stage_name = a.stage_name\n    ON CONFLICT (org_id, day, pipeline_id, stage_name) DO UPDATE SET\n      runs = excluded.runs,\n      succeeded = excluded.succeeded,\n      failed = excluded.failed,\n      failures_by_category = excluded.failures_by_category,\n      p50_ms = excluded.p50_ms,\n      p90_ms = excluded.p90_ms,\n      p95_ms = excluded.p95_ms,\n      build_seconds = excluded.build_seconds,\n      computed_at = excluded.computed_at\n  `));\n  const rows = (result as unknown as { rowCount?: number }).rowCount ?? 0;\n  logger.debug('Rolled up a day', { day: dayStart.toISOString().slice(0, 10), rows });\n  return rows;\n}\n\n/**\n * One rollup pass: rebuild the most recent settled days.\n *\n * Rebuilding a WINDOW rather than only the newest day is what handles late\n * events: the dead-letter redrive lands events for days already rolled up, and a\n * job that only ever built \"yesterday\" would leave those days permanently wrong.\n * Recomputing a week costs one statement per day and makes lateness self-healing\n * instead of a support question.\n *\n * Never throws — the caller is a scheduler tick, and a failed pass must retry next\n * tick rather than take the service's background work down with it.\n */\nexport async function runRollupPass(now: Date = new Date()): Promise<{ days: number; rows: number }> {\n  const settleMs = rollupSettleHours() * 3600_000;\n  // The newest day that has settled. A day is only built once everything that\n  // started in it has had time to finish.\n  const newest = utcDayStart(new Date(now.getTime() - settleMs));\n  let rows = 0;\n  let days = 0;\n  for (let i = 0; i < rollupBatchDays(); i++) {\n    const day = new Date(newest.getTime() - i * 24 * 3600_000);\n    try {\n      rows += await rebuildDay(day);\n      days++;\n    } catch (err) {\n      logger.warn('Rollup pass failed for a day; it will be retried next pass', {\n        day: day.toISOString().slice(0, 10),\n        error: errorMessage(err),\n      });\n    }\n  }\n  return { days, rows };\n}\n"]}

package/lib/api/reporting/deploy-rollup.d.ts

@@ -0,0 +1,78 @@
+import type { LeadTimeGap } from '../../database/schema/reporting-analytics.js';
+/** The fields of an inserted event row this module needs. */
+export interface DeployCandidate {
+    orgId: string;
+    pipelineId: string | null;
+    executionId: string | null;
+    eventType: string;
+    status: string;
+    stageName: string | null;
+    environment: string | null;
+    commitSha?: string | null;
+    commitTimestamp?: Date | null;
+    commitCount?: number | null;
+    completedAt?: Date | null;
+    startedAt?: Date | null;
+    createdAt?: Date | null;
+}
+/**
+ * Is this row a deploy?
+ *
+ * A STAGE event with an environment, in a terminal state. `IN_PROGRESS` rows are
+ * skipped deliberately: a deploy that has started has no duration, no outcome and
+ * no place in a deployment-frequency count, and writing it would make every
+ * in-flight deploy look like a successful one until its next event landed.
+ */
+export declare function isDeployEvent(row: DeployCandidate): boolean;
+/**
+ * Why lead time is absent for a deploy that has no commit timestamp.
+ *
+ * `no_commit_data` is the honest default: the forwarder resolves the commit range
+ * in-account and reports the reason it could not, so anything else here would be
+ * this module guessing. The reason it DID report rides on the event's `detail`.
+ */
+export declare function leadTimeGapOf(row: DeployCandidate & {
+    detail?: Record<string, unknown> | null;
+}): LeadTimeGap | null;
+/**
+ * Upsert the deploy rows for a batch of freshly-inserted events.
+ *
+ * ONE ROW PER (execution, environment), so a redelivered event refreshes the row
+ * rather than adding a second deploy — the same at-least-once problem the event
+ * insert solves with its partial unique index.
+ *
+ * The conflict update deliberately does NOT touch `failed_at` / `restored_at`:
+ * those are set by the post-deploy outcome markers and by incident correlation,
+ * and a late redelivery of the original deploy event must not erase a recorded
+ * production failure.
+ *
+ * Never throws. An ingest batch that landed its events has done the durable part
+ * of its job; failing the whole batch because a derived row could not be written
+ * would turn a rollup bug into data loss, and the backfill can rebuild these from
+ * the events while they exist.
+ */
+export declare function upsertDeployments(rows: ReadonlyArray<DeployCandidate & {
+    detail?: Record<string, unknown> | null;
+}>): Promise<number>;
+/**
+ * Record a post-deploy outcome against the deploy it concerns.
+ *
+ * Denormalized onto `dora_deployments` so change-failure rate and
+ * time-to-restore are one scan over the window instead of a join per read. The
+ * `deployment_outcomes` table stays the authority — this is the copy the
+ * aggregates use, and it is rebuildable from it.
+ */
+export declare function applyDeployOutcome(orgId: string, executionId: string, outcome: 'failed' | 'restored', at: Date, environment?: string): Promise<void>;
+/**
+ * Attribute an incident to the most recent successful deploy to its environment
+ * within the correlation window, and label how confident that link is.
+ *
+ * The confidence is the point. "This deploy broke production" and "an incident
+ * opened eleven hours after this deploy, and the window happens to be twelve" are
+ * different claims, and a manager acts differently on each — so the report shows
+ * which one it is rather than presenting both as a change failure.
+ */
+export declare function correlateIncident(orgId: string, environment: string, openedAt: Date, windowHours: number): Promise<{
+    executionId: string;
+    confidence: 'high' | 'medium' | 'low';
+} | null>;

package/lib/api/reporting/deploy-rollup.js

@@ -0,0 +1,203 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Writing `dora_deployments` at ingest.
+ *
+ * Every DORA number used to be derived by scanning `pipeline_events` per read.
+ * Two things were wrong with that, and only one of them was speed:
+ *
+ *  1. LEAD TIME WAS DOUBLE-COUNTED IN WAITING. A deploy emits a STAGE event and
+ *     an ACTION event, and both carry the same resolved commit range. Any
+ *     aggregate over events therefore counted one deploy's lead time twice the
+ *     moment somebody added the ACTION rows to a query. Storing it once per
+ *     execution makes that mistake unavailable rather than merely unmade.
+ *  2. THE NUMBERS DID NOT SURVIVE RETENTION. The sweep purges raw events by
+ *     tier, so a quarterly report could not be recomputed once its events were
+ *     gone — which is exactly when someone asks about it.
+ *
+ * A deploy is a STAGE event carrying an `environment`: the same predicate the
+ * DORA queries have always used, now applied once at write time.
+ */
+import { createLogger, errorMessage } from '@pipeline-builder/api-core';
+import { and, eq, isNull, sql } from 'drizzle-orm';
+import { schema } from '../../database/drizzle-schema.js';
+import { withTenantTx } from '../../database/tenancy.js';
+const logger = createLogger('deploy-rollup');
+/** Statuses an event uses for "this finished, and it worked". */
+const SUCCEEDED = new Set(['SUCCEEDED', 'SUCCESS']);
+/** …and for "this finished, and it did not". */
+const FAILED = new Set(['FAILED', 'FAILURE', 'CANCELED', 'CANCELLED', 'STOPPED', 'TIMED_OUT']);
+/**
+ * Is this row a deploy?
+ *
+ * A STAGE event with an environment, in a terminal state. `IN_PROGRESS` rows are
+ * skipped deliberately: a deploy that has started has no duration, no outcome and
+ * no place in a deployment-frequency count, and writing it would make every
+ * in-flight deploy look like a successful one until its next event landed.
+ */
+export function isDeployEvent(row) {
+    return row.eventType === 'STAGE'
+        && !!row.environment
+        && !!row.executionId
+        && (SUCCEEDED.has(row.status) || FAILED.has(row.status));
+}
+/**
+ * Why lead time is absent for a deploy that has no commit timestamp.
+ *
+ * `no_commit_data` is the honest default: the forwarder resolves the commit range
+ * in-account and reports the reason it could not, so anything else here would be
+ * this module guessing. The reason it DID report rides on the event's `detail`.
+ */
+export function leadTimeGapOf(row) {
+    if (row.commitTimestamp)
+        return null;
+    const reported = row.detail?.leadTimeGap;
+    if (reported === 'no_token' || reported === 'rate_limited' || reported === 'unsupported_source')
+        return reported;
+    return 'no_commit_data';
+}
+/** When the deploy finished. Falls back through the event's own timestamps. */
+function deployedAtOf(row) {
+    return row.completedAt ?? row.startedAt ?? row.createdAt ?? null;
+}
+/**
+ * Upsert the deploy rows for a batch of freshly-inserted events.
+ *
+ * ONE ROW PER (execution, environment), so a redelivered event refreshes the row
+ * rather than adding a second deploy — the same at-least-once problem the event
+ * insert solves with its partial unique index.
+ *
+ * The conflict update deliberately does NOT touch `failed_at` / `restored_at`:
+ * those are set by the post-deploy outcome markers and by incident correlation,
+ * and a late redelivery of the original deploy event must not erase a recorded
+ * production failure.
+ *
+ * Never throws. An ingest batch that landed its events has done the durable part
+ * of its job; failing the whole batch because a derived row could not be written
+ * would turn a rollup bug into data loss, and the backfill can rebuild these from
+ * the events while they exist.
+ */
+export async function upsertDeployments(rows) {
+    const deploys = rows.filter(isDeployEvent);
+    if (deploys.length === 0)
+        return 0;
+    const values = deploys.flatMap((row) => {
+        const deployedAt = deployedAtOf(row);
+        if (!deployedAt)
+            return [];
+        const succeeded = SUCCEEDED.has(row.status);
+        const earliestCommitAt = row.commitTimestamp ?? null;
+        // Lead time is commit → deploy, and only when both ends are real. A negative
+        // gap means the two timestamps came from different clocks; it is dropped
+        // rather than clamped to zero, because "0 seconds" is a claim and "unknown"
+        // is the truth.
+        const leadSeconds = earliestCommitAt
+            ? Math.round((deployedAt.getTime() - earliestCommitAt.getTime()) / 1000)
+            : null;
+        return [{
+                orgId: row.orgId,
+                executionId: row.executionId,
+                environment: row.environment,
+                pipelineId: row.pipelineId,
+                deployedAt,
+                succeeded,
+                earliestCommitAt,
+                leadTimeSeconds: leadSeconds !== null && leadSeconds >= 0 ? leadSeconds : null,
+                commitCount: row.commitCount ?? null,
+                commitSha: row.commitSha ?? null,
+                leadTimeGap: leadTimeGapOf(row),
+            }];
+    });
+    if (values.length === 0)
+        return 0;
+    try {
+        const landed = await withTenantTx((tx) => tx.insert(schema.doraDeployment).values(values)
+            .onConflictDoUpdate({
+            target: [schema.doraDeployment.executionId, schema.doraDeployment.environment],
+            set: {
+                succeeded: sql `excluded.succeeded`,
+                deployedAt: sql `excluded.deployed_at`,
+                pipelineId: sql `COALESCE(excluded.pipeline_id, ${schema.doraDeployment.pipelineId})`,
+                // A later event may resolve a commit range the first one could not, so
+                // these fill in — but never blank out what was already measured.
+                earliestCommitAt: sql `COALESCE(excluded.earliest_commit_at, ${schema.doraDeployment.earliestCommitAt})`,
+                leadTimeSeconds: sql `COALESCE(excluded.lead_time_seconds, ${schema.doraDeployment.leadTimeSeconds})`,
+                commitCount: sql `COALESCE(excluded.commit_count, ${schema.doraDeployment.commitCount})`,
+                commitSha: sql `COALESCE(excluded.commit_sha, ${schema.doraDeployment.commitSha})`,
+                // The gap is cleared once a commit timestamp arrives: a resolved lead
+                // time and a reason it could not be resolved must never coexist.
+                leadTimeGap: sql `CASE WHEN COALESCE(excluded.earliest_commit_at, ${schema.doraDeployment.earliestCommitAt}) IS NOT NULL
+            THEN NULL ELSE excluded.lead_time_gap END`,
+                updatedAt: new Date(),
+            },
+        })
+            .returning({ executionId: schema.doraDeployment.executionId }));
+        return landed.length;
+    }
+    catch (err) {
+        logger.warn('Deploy rollup upsert failed; the events landed and a rebuild can recover it', {
+            deploys: values.length,
+            error: errorMessage(err),
+        });
+        return 0;
+    }
+}
+/**
+ * Record a post-deploy outcome against the deploy it concerns.
+ *
+ * Denormalized onto `dora_deployments` so change-failure rate and
+ * time-to-restore are one scan over the window instead of a join per read. The
+ * `deployment_outcomes` table stays the authority — this is the copy the
+ * aggregates use, and it is rebuildable from it.
+ */
+export async function applyDeployOutcome(orgId, executionId, outcome, at, environment) {
+    const where = environment
+        ? and(eq(schema.doraDeployment.executionId, executionId), eq(schema.doraDeployment.environment, environment), eq(schema.doraDeployment.orgId, orgId))
+        : and(eq(schema.doraDeployment.executionId, executionId), eq(schema.doraDeployment.orgId, orgId));
+    // A `restored` marker only means something for a deploy that was marked failed;
+    // recording a restore with no failure would produce a negative time-to-restore.
+    const set = outcome === 'failed'
+        ? { failedAt: at, updatedAt: new Date() }
+        : { restoredAt: at, updatedAt: new Date() };
+    await withTenantTx((tx) => tx.update(schema.doraDeployment).set(set)
+        .where(outcome === 'restored'
+        ? and(where, sql `${schema.doraDeployment.failedAt} IS NOT NULL`)
+        : where));
+}
+/**
+ * Attribute an incident to the most recent successful deploy to its environment
+ * within the correlation window, and label how confident that link is.
+ *
+ * The confidence is the point. "This deploy broke production" and "an incident
+ * opened eleven hours after this deploy, and the window happens to be twelve" are
+ * different claims, and a manager acts differently on each — so the report shows
+ * which one it is rather than presenting both as a change failure.
+ */
+export async function correlateIncident(orgId, environment, openedAt, windowHours) {
+    const windowStart = new Date(openedAt.getTime() - windowHours * 3600_000);
+    const rows = await withTenantTx((tx) => tx.select({
+        executionId: schema.doraDeployment.executionId,
+        deployedAt: schema.doraDeployment.deployedAt,
+    }).from(schema.doraDeployment)
+        .where(and(eq(schema.doraDeployment.orgId, orgId), eq(schema.doraDeployment.environment, environment), eq(schema.doraDeployment.succeeded, true), sql `${schema.doraDeployment.deployedAt} <= ${openedAt}`, sql `${schema.doraDeployment.deployedAt} >= ${windowStart}`))
+        .orderBy(sql `${schema.doraDeployment.deployedAt} DESC`)
+        .limit(1));
+    const deploy = rows[0];
+    if (!deploy)
+        return null;
+    // Confidence by how early in the window it fell. The thirds are a judgement,
+    // and a stated one: an incident within the first third of the window after a
+    // deploy is the case the DORA definition is actually about.
+    const elapsed = openedAt.getTime() - deploy.deployedAt.getTime();
+    const windowMs = windowHours * 3600_000;
+    const confidence = elapsed <= windowMs / 3 ? 'high' : elapsed <= (windowMs * 2) / 3 ? 'medium' : 'low';
+    await withTenantTx((tx) => tx.update(schema.doraDeployment)
+        .set({ failedAt: openedAt, correlationConfidence: confidence, updatedAt: new Date() })
+        .where(and(eq(schema.doraDeployment.executionId, deploy.executionId), eq(schema.doraDeployment.environment, environment), 
+    // Do not overwrite a failure already attributed: the FIRST incident linked
+    // to a deploy is the one that made it a change failure, and a later one
+    // re-dating it would move time-to-restore.
+    isNull(schema.doraDeployment.failedAt))));
+    return { executionId: deploy.executionId, confidence };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-rollup.js","sourceRoot":"","sources":["../../../src/api/reporting/deploy-rollup.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Writing `dora_deployments` at ingest.\n *\n * Every DORA number used to be derived by scanning `pipeline_events` per read.\n * Two things were wrong with that, and only one of them was speed:\n *\n *  1. LEAD TIME WAS DOUBLE-COUNTED IN WAITING. A deploy emits a STAGE event and\n *     an ACTION event, and both carry the same resolved commit range. Any\n *     aggregate over events therefore counted one deploy's lead time twice the\n *     moment somebody added the ACTION rows to a query. Storing it once per\n *     execution makes that mistake unavailable rather than merely unmade.\n *  2. THE NUMBERS DID NOT SURVIVE RETENTION. The sweep purges raw events by\n *     tier, so a quarterly report could not be recomputed once its events were\n *     gone — which is exactly when someone asks about it.\n *\n * A deploy is a STAGE event carrying an `environment`: the same predicate the\n * DORA queries have always used, now applied once at write time.\n */\n\nimport { createLogger, errorMessage } from '@pipeline-builder/api-core';\nimport { and, eq, isNull, sql } from 'drizzle-orm';\nimport { schema } from '../../database/drizzle-schema.js';\nimport type { LeadTimeGap } from '../../database/schema/reporting-analytics.js';\nimport { withTenantTx } from '../../database/tenancy.js';\n\nconst logger = createLogger('deploy-rollup');\n\n/** The fields of an inserted event row this module needs. */\nexport interface DeployCandidate {\n  orgId: string;\n  pipelineId: string | null;\n  executionId: string | null;\n  eventType: string;\n  status: string;\n  stageName: string | null;\n  environment: string | null;\n  commitSha?: string | null;\n  commitTimestamp?: Date | null;\n  commitCount?: number | null;\n  completedAt?: Date | null;\n  startedAt?: Date | null;\n  createdAt?: Date | null;\n}\n\n/** Statuses an event uses for \"this finished, and it worked\". */\nconst SUCCEEDED = new Set(['SUCCEEDED', 'SUCCESS']);\n/** …and for \"this finished, and it did not\". */\nconst FAILED = new Set(['FAILED', 'FAILURE', 'CANCELED', 'CANCELLED', 'STOPPED', 'TIMED_OUT']);\n\n/**\n * Is this row a deploy?\n *\n * A STAGE event with an environment, in a terminal state. `IN_PROGRESS` rows are\n * skipped deliberately: a deploy that has started has no duration, no outcome and\n * no place in a deployment-frequency count, and writing it would make every\n * in-flight deploy look like a successful one until its next event landed.\n */\nexport function isDeployEvent(row: DeployCandidate): boolean {\n  return row.eventType === 'STAGE'\n    && !!row.environment\n    && !!row.executionId\n    && (SUCCEEDED.has(row.status) || FAILED.has(row.status));\n}\n\n/**\n * Why lead time is absent for a deploy that has no commit timestamp.\n *\n * `no_commit_data` is the honest default: the forwarder resolves the commit range\n * in-account and reports the reason it could not, so anything else here would be\n * this module guessing. The reason it DID report rides on the event's `detail`.\n */\nexport function leadTimeGapOf(row: DeployCandidate & { detail?: Record<string, unknown> | null }): LeadTimeGap | null {\n  if (row.commitTimestamp) return null;\n  const reported = row.detail?.leadTimeGap;\n  if (reported === 'no_token' || reported === 'rate_limited' || reported === 'unsupported_source') return reported;\n  return 'no_commit_data';\n}\n\n/** When the deploy finished. Falls back through the event's own timestamps. */\nfunction deployedAtOf(row: DeployCandidate): Date | null {\n  return row.completedAt ?? row.startedAt ?? row.createdAt ?? null;\n}\n\n/**\n * Upsert the deploy rows for a batch of freshly-inserted events.\n *\n * ONE ROW PER (execution, environment), so a redelivered event refreshes the row\n * rather than adding a second deploy — the same at-least-once problem the event\n * insert solves with its partial unique index.\n *\n * The conflict update deliberately does NOT touch `failed_at` / `restored_at`:\n * those are set by the post-deploy outcome markers and by incident correlation,\n * and a late redelivery of the original deploy event must not erase a recorded\n * production failure.\n *\n * Never throws. An ingest batch that landed its events has done the durable part\n * of its job; failing the whole batch because a derived row could not be written\n * would turn a rollup bug into data loss, and the backfill can rebuild these from\n * the events while they exist.\n */\nexport async function upsertDeployments(\n  rows: ReadonlyArray<DeployCandidate & { detail?: Record<string, unknown> | null }>,\n): Promise<number> {\n  const deploys = rows.filter(isDeployEvent);\n  if (deploys.length === 0) return 0;\n\n  const values = deploys.flatMap((row) => {\n    const deployedAt = deployedAtOf(row);\n    if (!deployedAt) return [];\n    const succeeded = SUCCEEDED.has(row.status);\n    const earliestCommitAt = row.commitTimestamp ?? null;\n    // Lead time is commit → deploy, and only when both ends are real. A negative\n    // gap means the two timestamps came from different clocks; it is dropped\n    // rather than clamped to zero, because \"0 seconds\" is a claim and \"unknown\"\n    // is the truth.\n    const leadSeconds = earliestCommitAt\n      ? Math.round((deployedAt.getTime() - earliestCommitAt.getTime()) / 1000)\n      : null;\n    return [{\n      orgId: row.orgId,\n      executionId: row.executionId as string,\n      environment: row.environment as string,\n      pipelineId: row.pipelineId,\n      deployedAt,\n      succeeded,\n      earliestCommitAt,\n      leadTimeSeconds: leadSeconds !== null && leadSeconds >= 0 ? leadSeconds : null,\n      commitCount: row.commitCount ?? null,\n      commitSha: row.commitSha ?? null,\n      leadTimeGap: leadTimeGapOf(row),\n    }];\n  });\n  if (values.length === 0) return 0;\n\n  try {\n    const landed = await withTenantTx((tx) => tx.insert(schema.doraDeployment).values(values)\n      .onConflictDoUpdate({\n        target: [schema.doraDeployment.executionId, schema.doraDeployment.environment],\n        set: {\n          succeeded: sql`excluded.succeeded`,\n          deployedAt: sql`excluded.deployed_at`,\n          pipelineId: sql`COALESCE(excluded.pipeline_id, ${schema.doraDeployment.pipelineId})`,\n          // A later event may resolve a commit range the first one could not, so\n          // these fill in — but never blank out what was already measured.\n          earliestCommitAt: sql`COALESCE(excluded.earliest_commit_at, ${schema.doraDeployment.earliestCommitAt})`,\n          leadTimeSeconds: sql`COALESCE(excluded.lead_time_seconds, ${schema.doraDeployment.leadTimeSeconds})`,\n          commitCount: sql`COALESCE(excluded.commit_count, ${schema.doraDeployment.commitCount})`,\n          commitSha: sql`COALESCE(excluded.commit_sha, ${schema.doraDeployment.commitSha})`,\n          // The gap is cleared once a commit timestamp arrives: a resolved lead\n          // time and a reason it could not be resolved must never coexist.\n          leadTimeGap: sql`CASE WHEN COALESCE(excluded.earliest_commit_at, ${schema.doraDeployment.earliestCommitAt}) IS NOT NULL\n            THEN NULL ELSE excluded.lead_time_gap END`,\n          updatedAt: new Date(),\n        },\n      })\n      .returning({ executionId: schema.doraDeployment.executionId }));\n    return (landed as unknown[]).length;\n  } catch (err) {\n    logger.warn('Deploy rollup upsert failed; the events landed and a rebuild can recover it', {\n      deploys: values.length,\n      error: errorMessage(err),\n    });\n    return 0;\n  }\n}\n\n/**\n * Record a post-deploy outcome against the deploy it concerns.\n *\n * Denormalized onto `dora_deployments` so change-failure rate and\n * time-to-restore are one scan over the window instead of a join per read. The\n * `deployment_outcomes` table stays the authority — this is the copy the\n * aggregates use, and it is rebuildable from it.\n */\nexport async function applyDeployOutcome(\n  orgId: string,\n  executionId: string,\n  outcome: 'failed' | 'restored',\n  at: Date,\n  environment?: string,\n): Promise<void> {\n  const where = environment\n    ? and(\n      eq(schema.doraDeployment.executionId, executionId),\n      eq(schema.doraDeployment.environment, environment),\n      eq(schema.doraDeployment.orgId, orgId),\n    )\n    : and(\n      eq(schema.doraDeployment.executionId, executionId),\n      eq(schema.doraDeployment.orgId, orgId),\n    );\n  // A `restored` marker only means something for a deploy that was marked failed;\n  // recording a restore with no failure would produce a negative time-to-restore.\n  const set = outcome === 'failed'\n    ? { failedAt: at, updatedAt: new Date() }\n    : { restoredAt: at, updatedAt: new Date() };\n  await withTenantTx((tx) => tx.update(schema.doraDeployment).set(set)\n    .where(outcome === 'restored'\n      ? and(where, sql`${schema.doraDeployment.failedAt} IS NOT NULL`)\n      : where));\n}\n\n/**\n * Attribute an incident to the most recent successful deploy to its environment\n * within the correlation window, and label how confident that link is.\n *\n * The confidence is the point. \"This deploy broke production\" and \"an incident\n * opened eleven hours after this deploy, and the window happens to be twelve\" are\n * different claims, and a manager acts differently on each — so the report shows\n * which one it is rather than presenting both as a change failure.\n */\nexport async function correlateIncident(\n  orgId: string,\n  environment: string,\n  openedAt: Date,\n  windowHours: number,\n): Promise<{ executionId: string; confidence: 'high' | 'medium' | 'low' } | null> {\n  const windowStart = new Date(openedAt.getTime() - windowHours * 3600_000);\n  const rows = await withTenantTx((tx) => tx.select({\n    executionId: schema.doraDeployment.executionId,\n    deployedAt: schema.doraDeployment.deployedAt,\n  }).from(schema.doraDeployment)\n    .where(and(\n      eq(schema.doraDeployment.orgId, orgId),\n      eq(schema.doraDeployment.environment, environment),\n      eq(schema.doraDeployment.succeeded, true),\n      sql`${schema.doraDeployment.deployedAt} <= ${openedAt}`,\n      sql`${schema.doraDeployment.deployedAt} >= ${windowStart}`,\n    ))\n    .orderBy(sql`${schema.doraDeployment.deployedAt} DESC`)\n    .limit(1));\n  const deploy = (rows as Array<{ executionId: string; deployedAt: Date }>)[0];\n  if (!deploy) return null;\n\n  // Confidence by how early in the window it fell. The thirds are a judgement,\n  // and a stated one: an incident within the first third of the window after a\n  // deploy is the case the DORA definition is actually about.\n  const elapsed = openedAt.getTime() - deploy.deployedAt.getTime();\n  const windowMs = windowHours * 3600_000;\n  const confidence = elapsed <= windowMs / 3 ? 'high' : elapsed <= (windowMs * 2) / 3 ? 'medium' : 'low';\n\n  await withTenantTx((tx) => tx.update(schema.doraDeployment)\n    .set({ failedAt: openedAt, correlationConfidence: confidence, updatedAt: new Date() })\n    .where(and(\n      eq(schema.doraDeployment.executionId, deploy.executionId),\n      eq(schema.doraDeployment.environment, environment),\n      // Do not overwrite a failure already attributed: the FIRST incident linked\n      // to a deploy is the one that made it a change failure, and a later one\n      // re-dating it would move time-to-restore.\n      isNull(schema.doraDeployment.failedAt),\n    )));\n  return { executionId: deploy.executionId, confidence };\n}\n"]}

package/lib/api/reporting/dora-scoring.d.ts

@@ -64,6 +64,20 @@ export declare function round(value: number, digits: number): number;
  * fixture tests able to prove the metric math without a live Postgres).
  */
 export declare function median(values: number[]): number | null;
+/**
+ * The `p`-th percentile of a sample (0 < p < 100), or `null` when empty.
+ *
+ * Linear interpolation between order statistics — the same definition as
+ * Postgres's `PERCENTILE_CONT`, so a reader comparing this to a hand-written SQL
+ * query gets the same number. {@link median} is p50 by this definition too; it
+ * stays a separate function because it is the level-scoring input and is read in
+ * far more places.
+ *
+ * Tails matter here: a median lead time of 2 hours with a p95 of 3 weeks is a
+ * team with a fast path and a stuck queue, and the median alone hides that
+ * entirely. That is why the plan asks for p90/p95 rather than more levels.
+ */
+export declare function percentile(values: number[], p: number): number | null;
 /**
  * Roll a group of deploy/stage events (grouped per execution) up to one terminal
  * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).