@pipeline-builder/pipeline-data 4.1.24 → 4.1.25

package/lib/api/reporting/failure-classifier.js

@@ -0,0 +1,179 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The rules, most specific first.
+ *
+ * Read this as the taxonomy itself. Each entry answers "what would somebody DO
+ * about this", which is why e.g. `permissions` and `authentication` are separate:
+ * one is a policy change, the other is a credential.
+ */
+const RULES = [
+    // Credentials and policy first: their messages often also contain words that
+    // would otherwise match `external_service` or `configuration`.
+    {
+        category: 'permissions',
+        patterns: [
+            /accessdenied/, /access denied/, /not authorized to perform/, /forbidden/,
+            /explicit deny/, /assumerole.*denied/, /iam.*permission/, /insufficient privileges/,
+        ],
+    },
+    {
+        category: 'authentication',
+        patterns: [
+            /unauthorized/, /401/, /authentication failed/, /invalid credentials/,
+            /expired token/, /token.*expired/, /no basic auth/, /bad credentials/,
+            /could not be authenticated/,
+        ],
+    },
+    {
+        category: 'source_checkout',
+        patterns: [
+            /could not resolve host: github/, /repository not found/, /fatal: could not read/,
+            /git clone.*failed/, /reference is not a tree/, /unable to access.*\.git/,
+            /source.*checkout.*failed/, /codecommit.*not found/,
+        ],
+    },
+    {
+        category: 'dependency',
+        patterns: [
+            /npm err!.*(?:e404|etarget|eresolve)/, /could not resolve dependency/,
+            /no matching version found/, /unable to resolve dependency tree/,
+            /could not find a version that satisfies/, /pip.*could not find/,
+            /go: .*: unknown revision/, /maven.*could not resolve dependencies/,
+            /bundler.*could not find/, /cargo.*failed to select a version/,
+            /peer dep/, /lockfile.*out of sync/,
+        ],
+    },
+    {
+        category: 'unit_test',
+        patterns: [/tests? failed/, /assertion(?:error)? failed/, /\d+ (?:tests?|specs?) failed/, /jest.*fail/, /pytest.*failed/],
+        action: /test|spec|jest|pytest|junit/i,
+    },
+    {
+        category: 'integration_test',
+        patterns: [/tests? failed/, /assertion(?:error)? failed/, /connection refused/],
+        action: /integration|e2e|smoke|acceptance|contract/i,
+    },
+    {
+        category: 'security_scan',
+        patterns: [
+            /vulnerabilit/, /cve-\d{4}/, /grype/, /trivy/, /sast/, /dependency check failed/,
+            /secret detected/, /license violation/, /policy violation.*scan/,
+        ],
+    },
+    {
+        category: 'timeout',
+        patterns: [
+            /timed? ?out/, /etimedout/, /deadline exceeded/, /exceeded the.*timeout/,
+            /build.*exceeded.*minutes/, /context deadline/,
+        ],
+    },
+    {
+        category: 'resource_exhaustion',
+        patterns: [
+            /out of memory/, /oomkilled/, /cannot allocate memory/, /no space left on device/,
+            /disk quota exceeded/, /enospc/, /too many open files/, /killed.*signal 9/,
+            /javascript heap out of memory/,
+        ],
+    },
+    {
+        category: 'deployment',
+        patterns: [
+            /cloudformation.*rollback/, /stack.*rollback_complete/, /create_failed/, /update_rollback/,
+            /cdk deploy.*failed/, /ecs.*deployment.*failed/, /deployment.*circuit breaker/,
+            /health check.*failed.*target group/,
+        ],
+    },
+    {
+        category: 'infrastructure',
+        patterns: [
+            /throttl/, /rate exceeded/, /limitexceeded/, /servicequotaexceeded/,
+            /capacity/, /insufficientinstancecapacity/, /host.*unreachable/,
+            /internal service error/, /5\d\d.*aws/,
+        ],
+    },
+    {
+        category: 'external_service',
+        patterns: [
+            /could not resolve host/, /enotfound/, /econnrefused/, /econnreset/,
+            /getaddrinfo/, /socket hang up/, /bad gateway/, /502|503|504/,
+            /upstream.*unavailable/, /registry.*unreachable/,
+        ],
+    },
+    {
+        category: 'configuration',
+        patterns: [
+            /is not defined/, /no such file or directory/, /enoent/, /invalid.*configuration/,
+            /missing required.*(?:variable|parameter|input)/,
+            // Both orders: "yaml parse error" and "error parsing YAML".
+            /yaml.*(?:parse|parsing|syntax)/, /(?:parse|parsing|syntax).*yaml/,
+            /unexpected token.*json/, /buildspec/, /command not found/,
+        ],
+    },
+    {
+        category: 'build',
+        patterns: [
+            /compilation (?:failed|error)/, /error ts\d+/, /syntax error/, /cannot find module/,
+            /undefined reference/, /build failed/, /webpack.*error/, /tsc.*error/,
+            /docker build.*failed/, /failed to solve/,
+        ],
+    },
+];
+/**
+ * The category for a failed action.
+ *
+ * `null` for anything that is not a failure — the caller stores nothing rather
+ * than labelling a success, so a category's presence always means "this broke".
+ */
+export function classifyFailure(input) {
+    const failed = /^(FAILED|FAILURE|ERROR|TIMED_OUT)$/i.test(input.status);
+    if (!failed)
+        return null;
+    const text = (input.errorMessage ?? '').toLowerCase();
+    const where = `${input.actionName ?? ''} ${input.stageName ?? ''}`;
+    for (const rule of RULES) {
+        if (rule.action && !rule.action.test(where))
+            continue;
+        if (rule.patterns.some((p) => p.test(text)))
+            return rule.category;
+    }
+    // Nothing matched. `other` rather than a guess, and counted, so the share of
+    // `other` measures how good the rules are and names the gap to close.
+    return 'other';
+}
+/**
+ * A human label for a category, for the report and the UI.
+ *
+ * Phrased as what broke rather than as an enum: a manager reading
+ * "Dependency resolution" understands it, and `integration_test` does not.
+ */
+export const FAILURE_CATEGORY_LABELS = {
+    source_checkout: 'Source checkout',
+    dependency: 'Dependency resolution',
+    build: 'Build / compile',
+    unit_test: 'Unit tests',
+    integration_test: 'Integration tests',
+    security_scan: 'Security scan',
+    infrastructure: 'Cloud infrastructure',
+    deployment: 'Deployment',
+    authentication: 'Authentication',
+    permissions: 'Permissions',
+    configuration: 'Configuration',
+    timeout: 'Timeout',
+    resource_exhaustion: 'Out of resources',
+    external_service: 'External service',
+    other: 'Unclassified',
+};
+/**
+ * Whether a category is something the TEAM can act on, as opposed to something
+ * that happened to them.
+ *
+ * Used by the failure-analysis section to separate the two, because a week whose
+ * failures were all cloud throttling is a different conversation from one whose
+ * failures were all broken tests — and presenting them in one ranked list invites
+ * exactly the wrong conclusion.
+ */
+export function isTeamActionable(category) {
+    return !['infrastructure', 'external_service'].includes(category);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"failure-classifier.js","sourceRoot":"","sources":["../../../src/api/reporting/failure-classifier.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * What KIND of thing broke.\n *\n * \"34 failures this week\" is not actionable. \"18 of them were dependency\n * resolution, and they are all in one pipeline\" is. That is the whole reason this\n * exists — and it is also why the classification happens at INGEST rather than at\n * read time: error text is scrubbed of AWS identifiers at the persistence boundary\n * and eventually swept by retention, so a category derived later would have\n * nothing left to read.\n *\n * THE RULES ARE DATA. A category is a provider/action match plus an ordered list\n * of patterns over the error text, in one table below, so the taxonomy can grow\n * from real misses without touching the classifier. Anything unmatched lands in\n * `other` and is counted, so the size of `other` is the measure of how good the\n * rules are.\n *\n * THE CATEGORIES OVERLAP THE PLUGIN-BUILD TAXONOMY ON PURPOSE. A dependency\n * failure is a dependency failure whether it happened building a plugin or running\n * one; two vocabularies for the same thing would make the report and the build\n * queue disagree about the same incident.\n *\n * WHAT THE AI EVER SEES is the category, never the raw error. Error text from a\n * customer's build is the last thing that should reach a model.\n */\n\nimport type { FailureCategory } from '../../database/schema/reporting-analytics.js';\n\n/** One classification rule: the category, and how to recognise it. */\ninterface Rule {\n  category: FailureCategory;\n  /**\n   * Ordered patterns over the lowercased error text. First rule with any match\n   * wins, so the table's ORDER is part of its meaning: the specific cases come\n   * before the general ones.\n   */\n  patterns: RegExp[];\n  /** When set, the rule only applies to an action/stage name matching this. */\n  action?: RegExp;\n}\n\n/**\n * The rules, most specific first.\n *\n * Read this as the taxonomy itself. Each entry answers \"what would somebody DO\n * about this\", which is why e.g. `permissions` and `authentication` are separate:\n * one is a policy change, the other is a credential.\n */\nconst RULES: Rule[] = [\n  // Credentials and policy first: their messages often also contain words that\n  // would otherwise match `external_service` or `configuration`.\n  {\n    category: 'permissions',\n    patterns: [\n      /accessdenied/, /access denied/, /not authorized to perform/, /forbidden/,\n      /explicit deny/, /assumerole.*denied/, /iam.*permission/, /insufficient privileges/,\n    ],\n  },\n  {\n    category: 'authentication',\n    patterns: [\n      /unauthorized/, /401/, /authentication failed/, /invalid credentials/,\n      /expired token/, /token.*expired/, /no basic auth/, /bad credentials/,\n      /could not be authenticated/,\n    ],\n  },\n  {\n    category: 'source_checkout',\n    patterns: [\n      /could not resolve host: github/, /repository not found/, /fatal: could not read/,\n      /git clone.*failed/, /reference is not a tree/, /unable to access.*\\.git/,\n      /source.*checkout.*failed/, /codecommit.*not found/,\n    ],\n  },\n  {\n    category: 'dependency',\n    patterns: [\n      /npm err!.*(?:e404|etarget|eresolve)/, /could not resolve dependency/,\n      /no matching version found/, /unable to resolve dependency tree/,\n      /could not find a version that satisfies/, /pip.*could not find/,\n      /go: .*: unknown revision/, /maven.*could not resolve dependencies/,\n      /bundler.*could not find/, /cargo.*failed to select a version/,\n      /peer dep/, /lockfile.*out of sync/,\n    ],\n  },\n  {\n    category: 'unit_test',\n    patterns: [/tests? failed/, /assertion(?:error)? failed/, /\\d+ (?:tests?|specs?) failed/, /jest.*fail/, /pytest.*failed/],\n    action: /test|spec|jest|pytest|junit/i,\n  },\n  {\n    category: 'integration_test',\n    patterns: [/tests? failed/, /assertion(?:error)? failed/, /connection refused/],\n    action: /integration|e2e|smoke|acceptance|contract/i,\n  },\n  {\n    category: 'security_scan',\n    patterns: [\n      /vulnerabilit/, /cve-\\d{4}/, /grype/, /trivy/, /sast/, /dependency check failed/,\n      /secret detected/, /license violation/, /policy violation.*scan/,\n    ],\n  },\n  {\n    category: 'timeout',\n    patterns: [\n      /timed? ?out/, /etimedout/, /deadline exceeded/, /exceeded the.*timeout/,\n      /build.*exceeded.*minutes/, /context deadline/,\n    ],\n  },\n  {\n    category: 'resource_exhaustion',\n    patterns: [\n      /out of memory/, /oomkilled/, /cannot allocate memory/, /no space left on device/,\n      /disk quota exceeded/, /enospc/, /too many open files/, /killed.*signal 9/,\n      /javascript heap out of memory/,\n    ],\n  },\n  {\n    category: 'deployment',\n    patterns: [\n      /cloudformation.*rollback/, /stack.*rollback_complete/, /create_failed/, /update_rollback/,\n      /cdk deploy.*failed/, /ecs.*deployment.*failed/, /deployment.*circuit breaker/,\n      /health check.*failed.*target group/,\n    ],\n  },\n  {\n    category: 'infrastructure',\n    patterns: [\n      /throttl/, /rate exceeded/, /limitexceeded/, /servicequotaexceeded/,\n      /capacity/, /insufficientinstancecapacity/, /host.*unreachable/,\n      /internal service error/, /5\\d\\d.*aws/,\n    ],\n  },\n  {\n    category: 'external_service',\n    patterns: [\n      /could not resolve host/, /enotfound/, /econnrefused/, /econnreset/,\n      /getaddrinfo/, /socket hang up/, /bad gateway/, /502|503|504/,\n      /upstream.*unavailable/, /registry.*unreachable/,\n    ],\n  },\n  {\n    category: 'configuration',\n    patterns: [\n      /is not defined/, /no such file or directory/, /enoent/, /invalid.*configuration/,\n      /missing required.*(?:variable|parameter|input)/,\n      // Both orders: \"yaml parse error\" and \"error parsing YAML\".\n      /yaml.*(?:parse|parsing|syntax)/, /(?:parse|parsing|syntax).*yaml/,\n      /unexpected token.*json/, /buildspec/, /command not found/,\n    ],\n  },\n  {\n    category: 'build',\n    patterns: [\n      /compilation (?:failed|error)/, /error ts\\d+/, /syntax error/, /cannot find module/,\n      /undefined reference/, /build failed/, /webpack.*error/, /tsc.*error/,\n      /docker build.*failed/, /failed to solve/,\n    ],\n  },\n];\n\n/**\n * The category for a failed action.\n *\n * `null` for anything that is not a failure — the caller stores nothing rather\n * than labelling a success, so a category's presence always means \"this broke\".\n */\nexport function classifyFailure(input: {\n  status: string;\n  errorMessage?: string | null;\n  actionName?: string | null;\n  stageName?: string | null;\n}): FailureCategory | null {\n  const failed = /^(FAILED|FAILURE|ERROR|TIMED_OUT)$/i.test(input.status);\n  if (!failed) return null;\n\n  const text = (input.errorMessage ?? '').toLowerCase();\n  const where = `${input.actionName ?? ''} ${input.stageName ?? ''}`;\n\n  for (const rule of RULES) {\n    if (rule.action && !rule.action.test(where)) continue;\n    if (rule.patterns.some((p) => p.test(text))) return rule.category;\n  }\n\n  // Nothing matched. `other` rather than a guess, and counted, so the share of\n  // `other` measures how good the rules are and names the gap to close.\n  return 'other';\n}\n\n/**\n * A human label for a category, for the report and the UI.\n *\n * Phrased as what broke rather than as an enum: a manager reading\n * \"Dependency resolution\" understands it, and `integration_test` does not.\n */\nexport const FAILURE_CATEGORY_LABELS: Record<FailureCategory, string> = {\n  source_checkout: 'Source checkout',\n  dependency: 'Dependency resolution',\n  build: 'Build / compile',\n  unit_test: 'Unit tests',\n  integration_test: 'Integration tests',\n  security_scan: 'Security scan',\n  infrastructure: 'Cloud infrastructure',\n  deployment: 'Deployment',\n  authentication: 'Authentication',\n  permissions: 'Permissions',\n  configuration: 'Configuration',\n  timeout: 'Timeout',\n  resource_exhaustion: 'Out of resources',\n  external_service: 'External service',\n  other: 'Unclassified',\n};\n\n/**\n * Whether a category is something the TEAM can act on, as opposed to something\n * that happened to them.\n *\n * Used by the failure-analysis section to separate the two, because a week whose\n * failures were all cloud throttling is a different conversation from one whose\n * failures were all broken tests — and presenting them in one ranked list invites\n * exactly the wrong conclusion.\n */\nexport function isTeamActionable(category: FailureCategory): boolean {\n  return !['infrastructure', 'external_service'].includes(category);\n}\n"]}

package/lib/api/reporting/ingest.d.ts

@@ -1,4 +1,4 @@
-import type { IngestEvent, IngestMetric, IngestResult } from './types.js';
+import type { IngestCaller, IngestEvent, IngestMetric, IngestResult } from './types.js';
 /**
  * Resolve incoming events against the pipeline registry, batch-insert the
  * matched ones, and invalidate reporting caches for affected orgs.
@@ -8,4 +8,4 @@ import type { IngestEvent, IngestMetric, IngestResult } from './types.js';
  *
  * Returns counts + a sample of unregistered pipeline ids for observability.
  */
-export declare function ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult>;
+export declare function ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void, caller?: IngestCaller): Promise<IngestResult>;

package/lib/api/reporting/ingest.js

@@ -10,6 +10,8 @@
 import { createLogger, errorMessage, scrubAwsIdentifiers } from '@pipeline-builder/api-core';
 import { inArray } from 'drizzle-orm';
 import { invalidateOrgReports } from './caches.js';
+import { upsertDeployments } from './deploy-rollup.js';
+import { classifyFailure } from './failure-classifier.js';
 import { scrubOptional } from './sql-helpers.js';
 import { schema } from '../../database/drizzle-schema.js';
 import { withTenantTx } from '../../database/tenancy.js';
@@ -47,6 +49,50 @@ async function loadStepPlugins(tx, attributable) {
         .where(inArray(schema.pipelineStepManifest.pipelineId, pipelineIds));
     return new Map(rows.map((m) => [stepKey(m.pipelineId, m.stageName, m.actionName), m]));
 }
+/**
+ * Allowance for clock skew between an AWS event's source clock and ours. A real
+ * CodePipeline event can carry a timestamp a little ahead of our `now`; without
+ * some tolerance the validation below would drop healthy events during normal
+ * NTP drift, which is far worse than admitting a few seconds of skew.
+ */
+const CLOCK_SKEW_TOLERANCE_MS = 5 * 60 * 1000;
+/**
+ * Why this event's timestamps are impossible, or null when they are usable.
+ *
+ * Checked at INGEST — the durable boundary — rather than clamped when the metrics
+ * are computed. A negative duration or a future deploy used to be clamped to 0
+ * downstream, which reported a broken clock as an instant deploy and quietly
+ * moved deployment frequency, change-failure rate and lead time for the org.
+ *
+ * NOT checked here: commit time vs deploy completion. `commit_timestamp` rides the
+ * PIPELINE/source event while the deploy's `completed_at` is on a separate STAGE
+ * row, joined by `execution_id` only when DORA is queried — so no single event
+ * carries both, and that ordering can only be guarded where the two meet.
+ */
+function invalidEventTimes(event, nowMs) {
+    const ceiling = nowMs + CLOCK_SKEW_TOLERANCE_MS;
+    const parsed = [];
+    for (const field of ['startedAt', 'completedAt', 'commitTimestamp']) {
+        const raw = event[field];
+        if (raw === undefined || raw === null)
+            continue;
+        const ms = Date.parse(String(raw));
+        if (!Number.isFinite(ms))
+            return `${field} is not a parseable timestamp`;
+        if (ms > ceiling)
+            return `${field} is in the future`;
+        parsed.push([field, ms]);
+    }
+    const started = parsed.find(([f]) => f === 'startedAt')?.[1];
+    const completed = parsed.find(([f]) => f === 'completedAt')?.[1];
+    if (started !== undefined && completed !== undefined && completed < started) {
+        return 'completedAt is before startedAt';
+    }
+    if (event.durationMs !== undefined && event.durationMs !== null && event.durationMs < 0) {
+        return 'durationMs is negative';
+    }
+    return null;
+}
 /**
  * The persisted row for one ingested event. This is the DURABLE persistence
  * boundary: every user/AWS-derived free-form string is scrubbed here, and
@@ -87,6 +133,16 @@ function toEventRow(event, registry, plugin) {
         pluginPublisherId: plugin?.pluginPublisherId ?? null,
         pluginName: plugin?.pluginName ?? null,
         pluginVersion: plugin?.pluginVersion ?? null,
+        // WHAT KIND of thing broke, classified here rather than at read time: the
+        // error text is scrubbed above and eventually swept by retention, so a
+        // category derived later would have nothing left to read. NULL for anything
+        // that is not a failure, so its presence always means "this broke".
+        failureCategory: classifyFailure({
+            status: event.status,
+            errorMessage: scrubOptional(event.errorMessage),
+            actionName: scrubOptional(event.actionName),
+            stageName: scrubOptional(event.stageName),
+        }),
         detail: event.detail !== undefined ? scrubAwsIdentifiers(event.detail) : undefined,
     };
 }
@@ -118,7 +174,19 @@ function emitStageMetrics(rows, onMetric) {
  *
  * Returns counts + a sample of unregistered pipeline ids for observability.
  */
-export async function ingestEvents(events, onMetric) {
+export async function ingestEvents(events, onMetric, caller) {
+    // TENANCY. An event's org comes from the pipeline REGISTRY, not the token, so
+    // the scope check alone let any `reporting:ingest` holder post events for
+    // another org's pipeline id and have them attributed there. `caller` carries
+    // the org ids this token may write for; anything else is dropped below.
+    //
+    // `caller` is optional only so in-process callers that already run
+    // cross-tenant (tests, backfills) keep working — an ABSENT caller means "no
+    // restriction", and the route always supplies one. A caller with an EMPTY
+    // allow-list and no crossTenant flag therefore drops everything, which is the
+    // right answer when the route could not establish who is writing.
+    const unrestricted = caller === undefined || caller.crossTenant === true;
+    const allowed = new Set(caller?.allowedOrgIds ?? []);
     // Multi-org batch insert: the caller resolves to multiple orgs via the
     // pipeline-registry lookup below, so the route layer MUST establish a
     // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling
@@ -129,7 +197,7 @@ export async function ingestEvents(events, onMetric) {
     // Caches are invalidated AFTER the tx resolves: doing it inside held the pg
     // locks open across unrelated cache round-trips. The TTL is 2-5 min, so a
     // fire-and-forget post-commit invalidation is an acceptable trade.
-    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, insertedRows } = await withTenantTx(async (tx) => {
+    const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, droppedForeignOrg, droppedInvalidTime, insertedRows } = await withTenantTx(async (tx) => {
         // Batch-resolve all unique pipeline ids in one query
         const uniqueIds = [...new Set(events.map(e => e.pipelineId))];
         const registryRows = await tx
@@ -144,7 +212,14 @@ export async function ingestEvents(events, onMetric) {
         // Build insert batch (skip events whose pipeline isn't registered)
         const rows = [];
         let skippedLocal = 0;
+        let foreignLocal = 0;
+        let invalidTimeLocal = 0;
+        const invalidTimeReasons = new Set();
+        const foreignOrgIds = new Set();
         const unregisteredLocal = [];
+        // One `now` for the whole batch: per-event clocks would let an event pass or
+        // fail depending on where it sat in the loop.
+        const nowMs = Date.now();
         for (const event of events) {
             const registry = idMap.get(event.pipelineId);
             if (!registry) {
@@ -152,6 +227,22 @@ export async function ingestEvents(events, onMetric) {
                 unregisteredLocal.push(event.pipelineId);
                 continue;
             }
+            // The pipeline resolves to an org this caller may not write for. Counted
+            // separately from `skipped` (an unregistered id is a producer running
+            // ahead of registration; this is a tenancy refusal) and never inserted.
+            if (!unrestricted && !allowed.has(registry.orgId)) {
+                foreignLocal++;
+                foreignOrgIds.add(registry.orgId);
+                continue;
+            }
+            // Impossible timestamps are refused at the boundary, so no downstream
+            // metric has to clamp a negative gap and call it zero.
+            const badTime = invalidEventTimes(event, nowMs);
+            if (badTime) {
+                invalidTimeLocal++;
+                invalidTimeReasons.add(badTime);
+                continue;
+            }
             const stageName = scrubOptional(event.stageName);
             const actionName = scrubOptional(event.actionName);
             const step = isAttributable(event) && stageName && actionName
@@ -176,18 +267,52 @@ export async function ingestEvents(events, onMetric) {
                 status: schema.pipelineEvent.status,
                 stageName: schema.pipelineEvent.stageName,
                 environment: schema.pipelineEvent.environment,
+                // For the per-deploy rollup below: everything `dora_deployments` needs,
+                // taken from the rows that ACTUALLY landed so a re-delivery cannot
+                // produce a second deploy.
+                executionId: schema.pipelineEvent.executionId,
+                commitSha: schema.pipelineEvent.commitSha,
+                commitTimestamp: schema.pipelineEvent.commitTimestamp,
+                commitCount: schema.pipelineEvent.commitCount,
+                completedAt: schema.pipelineEvent.completedAt,
+                startedAt: schema.pipelineEvent.startedAt,
+                createdAt: schema.pipelineEvent.createdAt,
+                detail: schema.pipelineEvent.detail,
             })
             : [];
+        // Log inside the tx scope while the org set is in hand. WARN, not error:
+        // a misrouted producer is the common cause, but the same line is the only
+        // signal of an injection attempt, so it names the orgs it refused.
+        if (foreignLocal > 0) {
+            logger.warn('Dropped ingest events for orgs the caller may not write for', {
+                dropped: foreignLocal,
+                foreignOrgIds: [...foreignOrgIds],
+                allowedOrgIds: [...allowed],
+            });
+        }
+        if (invalidTimeLocal > 0) {
+            logger.warn('Dropped ingest events with impossible timestamps', {
+                dropped: invalidTimeLocal,
+                reasons: [...invalidTimeReasons],
+            });
+        }
         return {
             inserted: landed.length,
             skipped: skippedLocal,
             unregisteredPipelineIds: unregisteredLocal,
             affectedOrgs: [...new Set(landed.map(r => r.orgId))],
+            droppedForeignOrg: foreignLocal,
+            droppedInvalidTime: invalidTimeLocal,
             insertedRows: landed,
         };
     });
     if (onMetric)
         emitStageMetrics(insertedRows, onMetric);
+    // Per-deploy rollup. AFTER the events commit and outside their transaction: the
+    // events are the durable record and `dora_deployments` is derived from them, so
+    // a rollup failure must not roll back an ingest that succeeded. Rebuildable
+    // either way. `upsertDeployments` never throws for that reason.
+    await upsertDeployments(insertedRows);
     // Surface the silent skip: an unregistered pipeline id usually means the
     // pipeline hasn't called POST /pipelines/registry yet (or its
     // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it
@@ -205,6 +330,6 @@ export async function ingestEvents(events, onMetric) {
             logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });
         })));
     }
-    return { inserted, skipped, unregisteredPipelineIds, affectedOrgs };
+    return { inserted, skipped, unregisteredPipelineIds, affectedOrgs, droppedForeignOrg, droppedInvalidTime };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../../../src/api/reporting/ingest.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Event ingest: the WRITE half of reporting. Resolves incoming pipeline events\n * against the pipeline registry, scrubs every free-form string, batch-inserts\n * the matched rows idempotently, and invalidates the affected orgs' report\n * caches. Separate from the report queries because this is reporting's only\n * durable persistence boundary — everything else in the service only reads.\n */\n\nimport { createLogger, errorMessage, scrubAwsIdentifiers } from '@pipeline-builder/api-core';\nimport { inArray } from 'drizzle-orm';\nimport { invalidateOrgReports } from './caches.js';\nimport { scrubOptional } from './sql-helpers.js';\nimport type { IngestEvent, IngestMetric, IngestResult } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx } from '../../database/tenancy.js';\nimport type { CrudTx } from '../crud-service.js';\n\nconst logger = createLogger('reporting-ingest');\n\ntype PipelineEventInsert = typeof schema.pipelineEvent.$inferInsert;\n\n\n/** The plugin a pipeline step runs, from the step manifest its last deploy registered. */\ninterface StepPlugin {\n  orgId: string;\n  pluginPublisher: string | null;\n  pluginPublisherId: string | null;\n  pluginName: string | null;\n  pluginVersion: string | null;\n}\n\n/** An action/build event that can be attributed to a plugin step. */\nfunction isAttributable(e: IngestEvent): boolean {\n  return (e.eventType === 'ACTION' || e.eventType === 'BUILD')\n    && (e.eventSource === 'codepipeline' || e.eventSource === 'codebuild')\n    && !!e.stageName && !!e.actionName;\n}\n\nfunction stepKey(pipelineId: string, stageName: string, actionName: string): string {\n  return `${pipelineId}\\u0000${stageName}\\u0000${actionName}`;\n}\n\n/**\n * Plugin attribution: the step manifests of every pipeline with an attributable\n * event, in ONE read per batch, keyed for an in-memory join. Names are compared\n * post-scrub on both sides (the manifest stores them scrubbed the same way).\n */\nasync function loadStepPlugins(tx: CrudTx, attributable: IngestEvent[]): Promise<Map<string, StepPlugin>> {\n  const pipelineIds = [...new Set(attributable.map((e) => e.pipelineId))];\n  if (pipelineIds.length === 0) return new Map();\n  const rows = await tx\n    .select({\n      pipelineId: schema.pipelineStepManifest.pipelineId,\n      orgId: schema.pipelineStepManifest.orgId,\n      stageName: schema.pipelineStepManifest.stageName,\n      actionName: schema.pipelineStepManifest.actionName,\n      pluginPublisher: schema.pipelineStepManifest.pluginPublisher,\n      pluginPublisherId: schema.pipelineStepManifest.pluginPublisherId,\n      pluginName: schema.pipelineStepManifest.pluginName,\n      pluginVersion: schema.pipelineStepManifest.pluginVersion,\n    })\n    .from(schema.pipelineStepManifest)\n    .where(inArray(schema.pipelineStepManifest.pipelineId, pipelineIds));\n  return new Map(rows.map((m) => [stepKey(m.pipelineId, m.stageName, m.actionName), m]));\n}\n\n/**\n * The persisted row for one ingested event. This is the DURABLE persistence\n * boundary: every user/AWS-derived free-form string is scrubbed here, and\n * tenancy comes from the pipeline registry, never the caller's claimed org.\n */\nfunction toEventRow(event: IngestEvent, registry: { pipelineId: string; orgId: string }, plugin: StepPlugin | undefined): PipelineEventInsert {\n  return {\n    // registry.pipelineId === event.pipelineId; the registry's is always a row\n    // that exists (FK) and its orgId is the trusted tenant.\n    pipelineId: registry.pipelineId,\n    orgId: registry.orgId,\n    eventSource: event.eventSource,\n    eventType: event.eventType,\n    status: event.status,\n    // An AWS-ASSIGNED UUID, not free-form text: it can't carry an account id,\n    // and scrubbing a 12-digit run inside it would corrupt the correlation key.\n    executionId: event.executionId,\n    // USER-AUTHORED pipeline-structure names — same untrusted origin as\n    // errorMessage, so scrubbed (a stage named with an ARN must not persist).\n    stageName: scrubOptional(event.stageName),\n    actionName: scrubOptional(event.actionName),\n    // HARD CONSTRAINT: an AWS account id must NEVER be persisted. Failure detail\n    // and messages routinely carry ARNs and bare 12-digit account ids.\n    errorMessage: scrubOptional(event.errorMessage),\n    startedAt: event.startedAt ? new Date(event.startedAt) : undefined,\n    completedAt: event.completedAt ? new Date(event.completedAt) : undefined,\n    durationMs: event.durationMs,\n    // Deploy attribution — scrubbed like the other free-form strings.\n    commitSha: scrubOptional(event.commitSha),\n    commitRef: scrubOptional(event.commitRef),\n    environment: scrubOptional(event.environment),\n    // Measured lead time: the oldest unshipped commit's time + the count. An\n    // SCM-derived instant and a plain integer — nothing to scrub.\n    commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,\n    commitCount: event.commitCount,\n    // NULL for non-plugin actions and for pipelines deployed without a manifest.\n    pluginPublisher: plugin?.pluginPublisher ?? null,\n    pluginPublisherId: plugin?.pluginPublisherId ?? null,\n    pluginName: plugin?.pluginName ?? null,\n    pluginVersion: plugin?.pluginVersion ?? null,\n    detail: event.detail !== undefined ? scrubAwsIdentifiers(event.detail) : undefined,\n  };\n}\n\n/**\n * Fan terminal STAGE outcomes into the route's metric hook (pipeline-data can't\n * import api-server's registry) after the insert commits. Driven off the\n * INSERTED rows, so a re-delivered event the dedup index swallowed is never\n * counted twice. A non-null environment marks a deploy.\n */\nfunction emitStageMetrics(\n  rows: ReadonlyArray<{ orgId: string; pipelineId: string | null; eventType: string; status: string; stageName: string | null; environment: string | null }>,\n  onMetric: (m: IngestMetric) => void,\n): void {\n  for (const r of rows) {\n    if (r.eventType !== 'STAGE' || (r.status !== 'SUCCEEDED' && r.status !== 'FAILED') || !r.pipelineId) continue;\n    onMetric({\n      pipelineId: r.pipelineId,\n      orgId: r.orgId,\n      stage: r.stageName ?? '',\n      environment: r.environment ?? null,\n      result: r.status === 'SUCCEEDED' ? 'succeeded' : 'failed',\n    });\n  }\n}\n\n/**\n * Resolve incoming events against the pipeline registry, batch-insert the\n * matched ones, and invalidate reporting caches for affected orgs.\n * Events for unregistered pipeline ids are dropped (and logged at WARN\n * with sample ids so an operator can see when EventBridge is delivering\n * events for pipelines that haven't called POST /pipelines/registry yet).\n *\n * Returns counts + a sample of unregistered pipeline ids for observability.\n */\nexport async function ingestEvents(events: IngestEvent[], onMetric?: (m: IngestMetric) => void): Promise<IngestResult> {\n  // Multi-org batch insert: the caller resolves to multiple orgs via the\n  // pipeline-registry lookup below, so the route layer MUST establish a\n  // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling\n  // this function. Under FORCE'd RLS, a single tx with `app.org_id = <one\n  // org>` could only write events for that org; bypass via sysadmin is\n  // the right gate for this server-internal cross-tenant endpoint. See\n  // api/reporting/src/routes/event-ingest.ts for the wrapper.\n  // Caches are invalidated AFTER the tx resolves: doing it inside held the pg\n  // locks open across unrelated cache round-trips. The TTL is 2-5 min, so a\n  // fire-and-forget post-commit invalidation is an acceptable trade.\n  const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, insertedRows } = await withTenantTx(async (tx) => {\n    // Batch-resolve all unique pipeline ids in one query\n    const uniqueIds = [...new Set(events.map(e => e.pipelineId))];\n    const registryRows = await tx\n      .select({\n        pipelineId: schema.pipelineRegistry.pipelineId,\n        orgId: schema.pipelineRegistry.orgId,\n      })\n      .from(schema.pipelineRegistry)\n      .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));\n\n    const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));\n    const stepPlugins = await loadStepPlugins(tx, events.filter((e) => isAttributable(e) && idMap.has(e.pipelineId)));\n\n    // Build insert batch (skip events whose pipeline isn't registered)\n    const rows: PipelineEventInsert[] = [];\n    let skippedLocal = 0;\n    const unregisteredLocal: string[] = [];\n\n    for (const event of events) {\n      const registry = idMap.get(event.pipelineId);\n      if (!registry) {\n        skippedLocal++;\n        unregisteredLocal.push(event.pipelineId);\n        continue;\n      }\n      const stageName = scrubOptional(event.stageName);\n      const actionName = scrubOptional(event.actionName);\n      const step = isAttributable(event) && stageName && actionName\n        ? stepPlugins.get(stepKey(registry.pipelineId, stageName, actionName))\n        : undefined;\n      // Same-org guard: a manifest row is only ever written by the org that\n      // owns the pipeline, but the ingest runs cross-tenant, so don't lean on it.\n      rows.push(toEventRow(event, registry, step && step.orgId === registry.orgId ? step : undefined));\n    }\n\n    // SQS is at-least-once, so EventBridge can deliver the same state-change\n    // twice. `onConflictDoNothing` + the partial unique index on\n    // (pipeline_id, execution_id, event_type, status, stage_name, action_name)\n    // makes re-delivery idempotent. `returning` gives the REAL inserted set so\n    // counts, metrics and cache invalidation all ignore duplicates.\n    const landed = rows.length > 0\n      ? await tx.insert(schema.pipelineEvent).values(rows)\n        .onConflictDoNothing()\n        .returning({\n          orgId: schema.pipelineEvent.orgId,\n          pipelineId: schema.pipelineEvent.pipelineId,\n          eventType: schema.pipelineEvent.eventType,\n          status: schema.pipelineEvent.status,\n          stageName: schema.pipelineEvent.stageName,\n          environment: schema.pipelineEvent.environment,\n        })\n      : [];\n\n    return {\n      inserted: landed.length,\n      skipped: skippedLocal,\n      unregisteredPipelineIds: unregisteredLocal,\n      affectedOrgs: [...new Set(landed.map(r => r.orgId))],\n      insertedRows: landed,\n    };\n  });\n\n  if (onMetric) emitStageMetrics(insertedRows, onMetric);\n\n  // Surface the silent skip: an unregistered pipeline id usually means the\n  // pipeline hasn't called POST /pipelines/registry yet (or its\n  // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it\n  // makes a broken join visible instead of looking like \"no activity\".\n  if (unregisteredPipelineIds.length > 0) {\n    logger.warn('Pipeline events skipped: pipeline id not found in registry', {\n      count: unregisteredPipelineIds.length,\n      sample: unregisteredPipelineIds.slice(0, 3),\n    });\n  }\n\n  // Post-commit cache invalidation. Fire-and-forget with logging — TTL is\n  // short enough that a missed invalidation self-heals.\n  if (affectedOrgs.length > 0) {\n    void Promise.all(affectedOrgs.map((org) =>\n      invalidateOrgReports(org).catch((err) => {\n        logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n      }),\n    ));\n  }\n\n  return { inserted, skipped, unregisteredPipelineIds, affectedOrgs };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../../../src/api/reporting/ingest.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Event ingest: the WRITE half of reporting. Resolves incoming pipeline events\n * against the pipeline registry, scrubs every free-form string, batch-inserts\n * the matched rows idempotently, and invalidates the affected orgs' report\n * caches. Separate from the report queries because this is reporting's only\n * durable persistence boundary — everything else in the service only reads.\n */\n\nimport { createLogger, errorMessage, scrubAwsIdentifiers } from '@pipeline-builder/api-core';\nimport { inArray } from 'drizzle-orm';\nimport { invalidateOrgReports } from './caches.js';\nimport { upsertDeployments } from './deploy-rollup.js';\nimport { classifyFailure } from './failure-classifier.js';\nimport { scrubOptional } from './sql-helpers.js';\nimport type { IngestCaller, IngestEvent, IngestMetric, IngestResult } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { withTenantTx } from '../../database/tenancy.js';\nimport type { CrudTx } from '../crud-service.js';\n\nconst logger = createLogger('reporting-ingest');\n\ntype PipelineEventInsert = typeof schema.pipelineEvent.$inferInsert;\n\n\n/** The plugin a pipeline step runs, from the step manifest its last deploy registered. */\ninterface StepPlugin {\n  orgId: string;\n  pluginPublisher: string | null;\n  pluginPublisherId: string | null;\n  pluginName: string | null;\n  pluginVersion: string | null;\n}\n\n/** An action/build event that can be attributed to a plugin step. */\nfunction isAttributable(e: IngestEvent): boolean {\n  return (e.eventType === 'ACTION' || e.eventType === 'BUILD')\n    && (e.eventSource === 'codepipeline' || e.eventSource === 'codebuild')\n    && !!e.stageName && !!e.actionName;\n}\n\nfunction stepKey(pipelineId: string, stageName: string, actionName: string): string {\n  return `${pipelineId}\\u0000${stageName}\\u0000${actionName}`;\n}\n\n/**\n * Plugin attribution: the step manifests of every pipeline with an attributable\n * event, in ONE read per batch, keyed for an in-memory join. Names are compared\n * post-scrub on both sides (the manifest stores them scrubbed the same way).\n */\nasync function loadStepPlugins(tx: CrudTx, attributable: IngestEvent[]): Promise<Map<string, StepPlugin>> {\n  const pipelineIds = [...new Set(attributable.map((e) => e.pipelineId))];\n  if (pipelineIds.length === 0) return new Map();\n  const rows = await tx\n    .select({\n      pipelineId: schema.pipelineStepManifest.pipelineId,\n      orgId: schema.pipelineStepManifest.orgId,\n      stageName: schema.pipelineStepManifest.stageName,\n      actionName: schema.pipelineStepManifest.actionName,\n      pluginPublisher: schema.pipelineStepManifest.pluginPublisher,\n      pluginPublisherId: schema.pipelineStepManifest.pluginPublisherId,\n      pluginName: schema.pipelineStepManifest.pluginName,\n      pluginVersion: schema.pipelineStepManifest.pluginVersion,\n    })\n    .from(schema.pipelineStepManifest)\n    .where(inArray(schema.pipelineStepManifest.pipelineId, pipelineIds));\n  return new Map(rows.map((m) => [stepKey(m.pipelineId, m.stageName, m.actionName), m]));\n}\n\n/**\n * Allowance for clock skew between an AWS event's source clock and ours. A real\n * CodePipeline event can carry a timestamp a little ahead of our `now`; without\n * some tolerance the validation below would drop healthy events during normal\n * NTP drift, which is far worse than admitting a few seconds of skew.\n */\nconst CLOCK_SKEW_TOLERANCE_MS = 5 * 60 * 1000;\n\n/**\n * Why this event's timestamps are impossible, or null when they are usable.\n *\n * Checked at INGEST — the durable boundary — rather than clamped when the metrics\n * are computed. A negative duration or a future deploy used to be clamped to 0\n * downstream, which reported a broken clock as an instant deploy and quietly\n * moved deployment frequency, change-failure rate and lead time for the org.\n *\n * NOT checked here: commit time vs deploy completion. `commit_timestamp` rides the\n * PIPELINE/source event while the deploy's `completed_at` is on a separate STAGE\n * row, joined by `execution_id` only when DORA is queried — so no single event\n * carries both, and that ordering can only be guarded where the two meet.\n */\nfunction invalidEventTimes(event: IngestEvent, nowMs: number): string | null {\n  const ceiling = nowMs + CLOCK_SKEW_TOLERANCE_MS;\n  const parsed: Array<[string, number]> = [];\n  for (const field of ['startedAt', 'completedAt', 'commitTimestamp'] as const) {\n    const raw = event[field];\n    if (raw === undefined || raw === null) continue;\n    const ms = Date.parse(String(raw));\n    if (!Number.isFinite(ms)) return `${field} is not a parseable timestamp`;\n    if (ms > ceiling) return `${field} is in the future`;\n    parsed.push([field, ms]);\n  }\n  const started = parsed.find(([f]) => f === 'startedAt')?.[1];\n  const completed = parsed.find(([f]) => f === 'completedAt')?.[1];\n  if (started !== undefined && completed !== undefined && completed < started) {\n    return 'completedAt is before startedAt';\n  }\n  if (event.durationMs !== undefined && event.durationMs !== null && event.durationMs < 0) {\n    return 'durationMs is negative';\n  }\n  return null;\n}\n\n/**\n * The persisted row for one ingested event. This is the DURABLE persistence\n * boundary: every user/AWS-derived free-form string is scrubbed here, and\n * tenancy comes from the pipeline registry, never the caller's claimed org.\n */\nfunction toEventRow(event: IngestEvent, registry: { pipelineId: string; orgId: string }, plugin: StepPlugin | undefined): PipelineEventInsert {\n  return {\n    // registry.pipelineId === event.pipelineId; the registry's is always a row\n    // that exists (FK) and its orgId is the trusted tenant.\n    pipelineId: registry.pipelineId,\n    orgId: registry.orgId,\n    eventSource: event.eventSource,\n    eventType: event.eventType,\n    status: event.status,\n    // An AWS-ASSIGNED UUID, not free-form text: it can't carry an account id,\n    // and scrubbing a 12-digit run inside it would corrupt the correlation key.\n    executionId: event.executionId,\n    // USER-AUTHORED pipeline-structure names — same untrusted origin as\n    // errorMessage, so scrubbed (a stage named with an ARN must not persist).\n    stageName: scrubOptional(event.stageName),\n    actionName: scrubOptional(event.actionName),\n    // HARD CONSTRAINT: an AWS account id must NEVER be persisted. Failure detail\n    // and messages routinely carry ARNs and bare 12-digit account ids.\n    errorMessage: scrubOptional(event.errorMessage),\n    startedAt: event.startedAt ? new Date(event.startedAt) : undefined,\n    completedAt: event.completedAt ? new Date(event.completedAt) : undefined,\n    durationMs: event.durationMs,\n    // Deploy attribution — scrubbed like the other free-form strings.\n    commitSha: scrubOptional(event.commitSha),\n    commitRef: scrubOptional(event.commitRef),\n    environment: scrubOptional(event.environment),\n    // Measured lead time: the oldest unshipped commit's time + the count. An\n    // SCM-derived instant and a plain integer — nothing to scrub.\n    commitTimestamp: event.commitTimestamp ? new Date(event.commitTimestamp) : undefined,\n    commitCount: event.commitCount,\n    // NULL for non-plugin actions and for pipelines deployed without a manifest.\n    pluginPublisher: plugin?.pluginPublisher ?? null,\n    pluginPublisherId: plugin?.pluginPublisherId ?? null,\n    pluginName: plugin?.pluginName ?? null,\n    pluginVersion: plugin?.pluginVersion ?? null,\n    // WHAT KIND of thing broke, classified here rather than at read time: the\n    // error text is scrubbed above and eventually swept by retention, so a\n    // category derived later would have nothing left to read. NULL for anything\n    // that is not a failure, so its presence always means \"this broke\".\n    failureCategory: classifyFailure({\n      status: event.status,\n      errorMessage: scrubOptional(event.errorMessage),\n      actionName: scrubOptional(event.actionName),\n      stageName: scrubOptional(event.stageName),\n    }),\n    detail: event.detail !== undefined ? scrubAwsIdentifiers(event.detail) : undefined,\n  };\n}\n\n/**\n * Fan terminal STAGE outcomes into the route's metric hook (pipeline-data can't\n * import api-server's registry) after the insert commits. Driven off the\n * INSERTED rows, so a re-delivered event the dedup index swallowed is never\n * counted twice. A non-null environment marks a deploy.\n */\nfunction emitStageMetrics(\n  rows: ReadonlyArray<{ orgId: string; pipelineId: string | null; eventType: string; status: string; stageName: string | null; environment: string | null }>,\n  onMetric: (m: IngestMetric) => void,\n): void {\n  for (const r of rows) {\n    if (r.eventType !== 'STAGE' || (r.status !== 'SUCCEEDED' && r.status !== 'FAILED') || !r.pipelineId) continue;\n    onMetric({\n      pipelineId: r.pipelineId,\n      orgId: r.orgId,\n      stage: r.stageName ?? '',\n      environment: r.environment ?? null,\n      result: r.status === 'SUCCEEDED' ? 'succeeded' : 'failed',\n    });\n  }\n}\n\n/**\n * Resolve incoming events against the pipeline registry, batch-insert the\n * matched ones, and invalidate reporting caches for affected orgs.\n * Events for unregistered pipeline ids are dropped (and logged at WARN\n * with sample ids so an operator can see when EventBridge is delivering\n * events for pipelines that haven't called POST /pipelines/registry yet).\n *\n * Returns counts + a sample of unregistered pipeline ids for observability.\n */\nexport async function ingestEvents(\n  events: IngestEvent[],\n  onMetric?: (m: IngestMetric) => void,\n  caller?: IngestCaller,\n): Promise<IngestResult> {\n  // TENANCY. An event's org comes from the pipeline REGISTRY, not the token, so\n  // the scope check alone let any `reporting:ingest` holder post events for\n  // another org's pipeline id and have them attributed there. `caller` carries\n  // the org ids this token may write for; anything else is dropped below.\n  //\n  // `caller` is optional only so in-process callers that already run\n  // cross-tenant (tests, backfills) keep working — an ABSENT caller means \"no\n  // restriction\", and the route always supplies one. A caller with an EMPTY\n  // allow-list and no crossTenant flag therefore drops everything, which is the\n  // right answer when the route could not establish who is writing.\n  const unrestricted = caller === undefined || caller.crossTenant === true;\n  const allowed = new Set(caller?.allowedOrgIds ?? []);\n  // Multi-org batch insert: the caller resolves to multiple orgs via the\n  // pipeline-registry lookup below, so the route layer MUST establish a\n  // `runWithTenantContext({ isSuperAdmin: true }, ...)` scope before calling\n  // this function. Under FORCE'd RLS, a single tx with `app.org_id = <one\n  // org>` could only write events for that org; bypass via sysadmin is\n  // the right gate for this server-internal cross-tenant endpoint. See\n  // api/reporting/src/routes/event-ingest.ts for the wrapper.\n  // Caches are invalidated AFTER the tx resolves: doing it inside held the pg\n  // locks open across unrelated cache round-trips. The TTL is 2-5 min, so a\n  // fire-and-forget post-commit invalidation is an acceptable trade.\n  const { inserted, skipped, unregisteredPipelineIds, affectedOrgs, droppedForeignOrg, droppedInvalidTime, insertedRows } = await withTenantTx(async (tx) => {\n    // Batch-resolve all unique pipeline ids in one query\n    const uniqueIds = [...new Set(events.map(e => e.pipelineId))];\n    const registryRows = await tx\n      .select({\n        pipelineId: schema.pipelineRegistry.pipelineId,\n        orgId: schema.pipelineRegistry.orgId,\n      })\n      .from(schema.pipelineRegistry)\n      .where(inArray(schema.pipelineRegistry.pipelineId, uniqueIds));\n\n    const idMap = new Map(registryRows.map(r => [r.pipelineId, r]));\n    const stepPlugins = await loadStepPlugins(tx, events.filter((e) => isAttributable(e) && idMap.has(e.pipelineId)));\n\n    // Build insert batch (skip events whose pipeline isn't registered)\n    const rows: PipelineEventInsert[] = [];\n    let skippedLocal = 0;\n    let foreignLocal = 0;\n    let invalidTimeLocal = 0;\n    const invalidTimeReasons = new Set<string>();\n    const foreignOrgIds = new Set<string>();\n    const unregisteredLocal: string[] = [];\n    // One `now` for the whole batch: per-event clocks would let an event pass or\n    // fail depending on where it sat in the loop.\n    const nowMs = Date.now();\n\n    for (const event of events) {\n      const registry = idMap.get(event.pipelineId);\n      if (!registry) {\n        skippedLocal++;\n        unregisteredLocal.push(event.pipelineId);\n        continue;\n      }\n      // The pipeline resolves to an org this caller may not write for. Counted\n      // separately from `skipped` (an unregistered id is a producer running\n      // ahead of registration; this is a tenancy refusal) and never inserted.\n      if (!unrestricted && !allowed.has(registry.orgId)) {\n        foreignLocal++;\n        foreignOrgIds.add(registry.orgId);\n        continue;\n      }\n      // Impossible timestamps are refused at the boundary, so no downstream\n      // metric has to clamp a negative gap and call it zero.\n      const badTime = invalidEventTimes(event, nowMs);\n      if (badTime) {\n        invalidTimeLocal++;\n        invalidTimeReasons.add(badTime);\n        continue;\n      }\n      const stageName = scrubOptional(event.stageName);\n      const actionName = scrubOptional(event.actionName);\n      const step = isAttributable(event) && stageName && actionName\n        ? stepPlugins.get(stepKey(registry.pipelineId, stageName, actionName))\n        : undefined;\n      // Same-org guard: a manifest row is only ever written by the org that\n      // owns the pipeline, but the ingest runs cross-tenant, so don't lean on it.\n      rows.push(toEventRow(event, registry, step && step.orgId === registry.orgId ? step : undefined));\n    }\n\n    // SQS is at-least-once, so EventBridge can deliver the same state-change\n    // twice. `onConflictDoNothing` + the partial unique index on\n    // (pipeline_id, execution_id, event_type, status, stage_name, action_name)\n    // makes re-delivery idempotent. `returning` gives the REAL inserted set so\n    // counts, metrics and cache invalidation all ignore duplicates.\n    const landed = rows.length > 0\n      ? await tx.insert(schema.pipelineEvent).values(rows)\n        .onConflictDoNothing()\n        .returning({\n          orgId: schema.pipelineEvent.orgId,\n          pipelineId: schema.pipelineEvent.pipelineId,\n          eventType: schema.pipelineEvent.eventType,\n          status: schema.pipelineEvent.status,\n          stageName: schema.pipelineEvent.stageName,\n          environment: schema.pipelineEvent.environment,\n          // For the per-deploy rollup below: everything `dora_deployments` needs,\n          // taken from the rows that ACTUALLY landed so a re-delivery cannot\n          // produce a second deploy.\n          executionId: schema.pipelineEvent.executionId,\n          commitSha: schema.pipelineEvent.commitSha,\n          commitTimestamp: schema.pipelineEvent.commitTimestamp,\n          commitCount: schema.pipelineEvent.commitCount,\n          completedAt: schema.pipelineEvent.completedAt,\n          startedAt: schema.pipelineEvent.startedAt,\n          createdAt: schema.pipelineEvent.createdAt,\n          detail: schema.pipelineEvent.detail,\n        })\n      : [];\n\n    // Log inside the tx scope while the org set is in hand. WARN, not error:\n    // a misrouted producer is the common cause, but the same line is the only\n    // signal of an injection attempt, so it names the orgs it refused.\n    if (foreignLocal > 0) {\n      logger.warn('Dropped ingest events for orgs the caller may not write for', {\n        dropped: foreignLocal,\n        foreignOrgIds: [...foreignOrgIds],\n        allowedOrgIds: [...allowed],\n      });\n    }\n\n    if (invalidTimeLocal > 0) {\n      logger.warn('Dropped ingest events with impossible timestamps', {\n        dropped: invalidTimeLocal,\n        reasons: [...invalidTimeReasons],\n      });\n    }\n\n    return {\n      inserted: landed.length,\n      skipped: skippedLocal,\n      unregisteredPipelineIds: unregisteredLocal,\n      affectedOrgs: [...new Set(landed.map(r => r.orgId))],\n      droppedForeignOrg: foreignLocal,\n      droppedInvalidTime: invalidTimeLocal,\n      insertedRows: landed,\n    };\n  });\n\n  if (onMetric) emitStageMetrics(insertedRows, onMetric);\n\n  // Per-deploy rollup. AFTER the events commit and outside their transaction: the\n  // events are the durable record and `dora_deployments` is derived from them, so\n  // a rollup failure must not roll back an ingest that succeeded. Rebuildable\n  // either way. `upsertDeployments` never throws for that reason.\n  await upsertDeployments(insertedRows);\n\n  // Surface the silent skip: an unregistered pipeline id usually means the\n  // pipeline hasn't called POST /pipelines/registry yet (or its\n  // pb.pipeline-id tag is missing/unreadable by the Lambda). Logging it\n  // makes a broken join visible instead of looking like \"no activity\".\n  if (unregisteredPipelineIds.length > 0) {\n    logger.warn('Pipeline events skipped: pipeline id not found in registry', {\n      count: unregisteredPipelineIds.length,\n      sample: unregisteredPipelineIds.slice(0, 3),\n    });\n  }\n\n  // Post-commit cache invalidation. Fire-and-forget with logging — TTL is\n  // short enough that a missed invalidation self-heals.\n  if (affectedOrgs.length > 0) {\n    void Promise.all(affectedOrgs.map((org) =>\n      invalidateOrgReports(org).catch((err) => {\n        logger.warn('Reporting cache invalidation failed', { orgId: org, error: errorMessage(err) });\n      }),\n    ));\n  }\n\n  return { inserted, skipped, unregisteredPipelineIds, affectedOrgs, droppedForeignOrg, droppedInvalidTime };\n}\n"]}

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

@@ -0,0 +1,31 @@
+import type { IngestCaller } from './types.js';
+/** The bound, or nulls when this pipeline has no recorded deploy carrying a commit. */
+export interface LastDeployedCommit {
+    /** Commit sha of the most recent successful deploy to the environment. */
+    commitSha: string | null;
+    /** When that deploy completed, ISO text — for the caller's own logging. */
+    deployedAt: string | null;
+}
+/**
+ * The commit sha of the most recent SUCCEEDED deploy-stage execution for this
+ * pipeline — narrowed to one `environment` when given.
+ *
+ * Two steps, because the two facts live on different rows: `environment` is
+ * stamped on the deploy STAGE event, while `commit_sha` rides the source
+ * ACTION/PIPELINE event of the same execution. They are joined by `execution_id`,
+ * exactly as the DORA lead-time query does it.
+ *
+ * `environment` is OPTIONAL because of who asks. The events Lambda resolves a
+ * commit while handling the SOURCE event, and a source stage carries no
+ * environment — the execution has not reached a deploy stage yet, so at that
+ * moment the environment is genuinely unknown. Omitting it answers "what did this
+ * pipeline last ship anywhere", which is the right lower bound for an SCM range;
+ * passing it answers per-environment, for callers that know.
+ *
+ * TENANCY. `caller` is enforced the same way as {@link ingestEvents}: the org
+ * comes from the pipeline REGISTRY, never from the caller, and a pipeline outside
+ * the caller's allow-list returns nothing. Without this the endpoint would hand
+ * any `reporting:ingest` holder another tenant's commit history — the same hole
+ * the ingest tenancy check closes on the write side.
+ */
+export declare function getLastDeployedCommit(pipelineId: string, environment?: string, caller?: IngestCaller): Promise<LastDeployedCommit>;