@wtfalch/reporting 0.7.0 → 0.8.1

package/README.md

@@ -64,6 +64,7 @@ await ensureRuntimeRole({
     'reporting_errors',
     'reporting_tenant_settings',
     'reporting_error_tenants',
+    'reporting_requests',
   ],
   grants: [ // the seven security definer functions, schema-qualified
     'myservice.reporting_prune_events(interval, integer)',
@@ -79,7 +80,7 @@ await ensureRuntimeRole({
 
 Run `ensureRuntimeRole` after every migration run: the lists apply to the
 tables that exist at that moment. `grants` entries are spliced into SQL, so
-they are trusted text. Without `noDelete` the role can delete from those five
+they are trusted text. Without `noDelete` the role can delete from those six
 tables. These are the privileges the
 package's own tests check, on a real Postgres, in a named schema.
 
@@ -98,6 +99,7 @@ await assertRuntimeRole(connection.database, {
     'myservice.reporting_errors',
     'myservice.reporting_tenant_settings',
     'myservice.reporting_error_tenants',
+    'myservice.reporting_requests',
   ],
 });
 ```
@@ -205,6 +207,31 @@ edit can shorten history to a week and no further. Pass `audit` to
 `createReporting` to have every change handed to your audit ledger after it
 commits.
 
+## Release health (0.8.0)
+
+With `REPORTING_RELEASE` (an image digest) and `REPORTING_COLOR` (`blue` or
+`green`) set, every event, analytics and error row carries both. Count each
+response and mount the read foundry judges a new color by:
+
+```ts
+// app/api/reporting/release-health/route.ts
+import { releaseHealthHandler } from '@wtfalch/reporting/next';
+export const GET = releaseHealthHandler({ db, reporting });
+
+// any route handler: counted per minute, color and release (status >= 500 is an error)
+import { withRequestCount } from '@wtfalch/reporting/next';
+export const POST = withRequestCount(reporting, async (req) => Response.json({ ok: true }));
+```
+
+`reporting.requests.record(status)` is the same count for a host that has no
+route handler to wrap. Counts sit in memory and are written once per minute
+bucket (every 10 seconds by default; `reporting.flush()` writes them now). The
+read needs `Authorization: Bearer $REPORTING_HEALTH_TOKEN`: 401 for a missing or
+wrong token, 503 when the variable is unset. It answers `from` and `to` (ISO,
+`from` before `to`, at most 8 days; otherwise 400) with request and 5xx counts
+per color and the per-day average of the 7 days before `from`. Counts only; no
+event content. Rows of `reporting_requests` are not pruned.
+
 ## Shutdown
 
 ```ts
@@ -291,11 +318,10 @@ the rollups hold nothing to erase. Call it in the host's erasure transaction.
 
 ## Tests
 
-```ts
-import { createFakeReporting } from '@wtfalch/reporting/fake';
-```
-
-Same validation, no database; `fake.rows` is the table.
+No package ships a stand-in for a service. `createFakeReporting` (same
+validation, no database, `fake.rows` is the table) is this package's own
+unexported test double, under `src/test/`, for its own test files only -- a
+host writes its own double, or runs this package against a real database.
 
 ## What this package never does
 

package/dist/analytics/write.js

@@ -1,7 +1,9 @@
+import { deployTags } from '../deploy.js';
 import { reportingAnalytics } from '../tables.js';
 export async function insertAnalytics(db, rows) {
     if (rows.length === 0)
         return;
+    const tags = deployTags();
     await db.insert(reportingAnalytics).values(rows.map((r) => ({
         occurredAt: r.occurredAt,
         receivedAt: r.receivedAt,
@@ -16,5 +18,6 @@ export async function insertAnalytics(db, rows) {
         device: r.device,
         country: r.country,
         props: r.props,
+        ...tags,
     })));
 }

package/dist/deploy.d.ts

@@ -0,0 +1,11 @@
+export type Color = 'blue' | 'green';
+export interface DeployTags {
+    readonly release: string | null;
+    readonly color: Color | null;
+}
+/**
+ * The release and color the platform gave this container
+ * (`REPORTING_RELEASE`, `REPORTING_COLOR`). A color that is not blue or green
+ * is null, so a bad value cannot fail a write on the column's CHECK.
+ */
+export declare function deployTags(env?: NodeJS.ProcessEnv): DeployTags;

package/dist/deploy.js

@@ -0,0 +1,13 @@
+/**
+ * The release and color the platform gave this container
+ * (`REPORTING_RELEASE`, `REPORTING_COLOR`). A color that is not blue or green
+ * is null, so a bad value cannot fail a write on the column's CHECK.
+ */
+export function deployTags(env = process.env) {
+    const color = env.REPORTING_COLOR;
+    const release = env.REPORTING_RELEASE?.slice(0, 128);
+    return {
+        release: release ? release : null,
+        color: color === 'blue' || color === 'green' ? color : null,
+    };
+}

package/dist/errors/capture.js

@@ -1,4 +1,5 @@
 import { eq, sql } from 'drizzle-orm';
+import { deployTags } from '../deploy.js';
 import { ERROR_RUNTIMES, KIND_PATTERN, LIMITS } from '../schema.js';
 import { reportingErrorTenants, reportingErrors } from '../tables.js';
 import { describe } from '../writer.js';
@@ -122,6 +123,7 @@ async function upsertGroup(db, site, s, log) {
             stack: s.stack,
             runtime: s.runtime,
             release: s.release,
+            color: s.color,
             environment: s.environment,
             firstSeenAt: s.at,
             lastSeenAt: s.at,
@@ -139,6 +141,7 @@ async function upsertGroup(db, site, s, log) {
                 tenantId: s.tenantId,
                 requestId: s.requestId,
                 release: s.release,
+                color: s.color,
                 environment: s.environment,
                 state: reopened,
                 resolvedAt: sql `case when ${reportingErrors.state} in ('resolved', 'ignored') then null else ${reportingErrors.resolvedAt} end`,
@@ -237,6 +240,7 @@ export function createCapture(o) {
                 stack,
                 runtime,
                 release,
+                color: deployTags().color,
                 environment,
                 tenantId,
                 requestId,

package/dist/errors/reader.js

@@ -35,6 +35,7 @@ function tenantColumns() {
         stack: sql `null`.as('stack'),
         runtime: sql `null`.as('runtime'),
         release: sql `null`.as('release'),
+        color: sql `null`.as('color'),
         requestId: sql `null`.as('request_id'),
         resolvedBy: sql `null`.as('resolved_by'),
         state: sql `null`.as('state'),

package/dist/index.js

@@ -4,6 +4,7 @@ import { ANALYTICS_NAME_PATTERN, normalisePath, propsSchema } from './analytics/
 import { insertAnalytics } from './analytics/write.js';
 import { createCapture } from './errors/capture.js';
 import { eventsPage } from './reader.js';
+import { RequestCounter } from './requests.js';
 import { environmentSchema, siteSchema } from './schema.js';
 import { getSettings, getTenantRetention, setSettings, setTenantRetention } from './settings.js';
 import { tables } from './tables.js';
@@ -54,6 +55,13 @@ export function createReporting(options) {
         batchSize: options.batchSize ?? 500,
         flushEveryMs: options.flushEveryMs ?? 1000,
     });
+    const requests = new RequestCounter({
+        db: options.db,
+        log: options.log,
+        site,
+        now,
+        flushEveryMs: options.requestFlushEveryMs ?? 10_000,
+    });
     // One alerting path, shared by `reporting.alert()` and a new-or-reopened
     // capture (errors/capture.ts's `alert` option): an `alert.<check>` row,
     // already indexed and pruned the same as everything else on the
@@ -91,7 +99,11 @@ export function createReporting(options) {
         event: (input) => writer.event(input),
         captureError: (error, context) => capture(error, context),
         alert: fireAlert,
-        flush: (opts) => writer.flush(opts),
+        flush: async (opts) => {
+            await writer.flush(opts);
+            await requests.flush();
+        },
+        requests: { record: (status) => requests.record(status) },
         events: { page: (opts) => eventsPage(options.db, opts) },
         settings: {
             get: () => getSettings(options.db),

package/dist/migrations/0009_release_color.sql

@@ -0,0 +1,33 @@
+-- @wtfalch/reporting 0.8.0: the release and color a row was written under.
+-- Mirrors src/tables.ts.
+--
+-- A blue/green deploy runs two copies of an app against one database. The
+-- host gets REPORTING_RELEASE (an image digest) and REPORTING_COLOR (blue or
+-- green) from its platform, and the package stamps both on every row it
+-- writes. Both are nullable: rows written before this file, and rows from an
+-- app with no color, carry null. reporting_errors already has `release`.
+--
+-- Same shape as 0004_environment.sql: `add column if not exists` takes only a
+-- catalog lock, and the CHECK goes in `not valid` then `validate constraint`
+-- so the scan of a large table does not hold ACCESS EXCLUSIVE. Every
+-- statement is idempotent; no backfill.
+
+alter table reporting_events add column if not exists release text;
+alter table reporting_events add column if not exists color text;
+alter table reporting_events drop constraint if exists reporting_events_color_check;
+alter table reporting_events add constraint reporting_events_color_check
+  check (color is null or color in ('blue', 'green')) not valid;
+alter table reporting_events validate constraint reporting_events_color_check;
+
+alter table reporting_analytics add column if not exists release text;
+alter table reporting_analytics add column if not exists color text;
+alter table reporting_analytics drop constraint if exists reporting_analytics_color_check;
+alter table reporting_analytics add constraint reporting_analytics_color_check
+  check (color is null or color in ('blue', 'green')) not valid;
+alter table reporting_analytics validate constraint reporting_analytics_color_check;
+
+alter table reporting_errors add column if not exists color text;
+alter table reporting_errors drop constraint if exists reporting_errors_color_check;
+alter table reporting_errors add constraint reporting_errors_color_check
+  check (color is null or color in ('blue', 'green')) not valid;
+alter table reporting_errors validate constraint reporting_errors_color_check;

package/dist/migrations/0010_requests.sql

@@ -0,0 +1,27 @@
+-- @wtfalch/reporting 0.8.0: a request counter, one row per minute.
+-- Mirrors src/tables.ts.
+--
+-- Blue/green judges a new color by its share of failed responses, which needs
+-- a count of all requests, not one event per request. The app counts in
+-- memory and writes one upsert per minute bucket, color and release.
+-- `errors` is responses with status >= 500. `color` and `release` are the
+-- empty string, not null, when the app has none, so they can sit in the
+-- primary key. Counts only; nothing here identifies a person or a request.
+-- Every statement is idempotent.
+--
+-- The table is new, so there are no live rows to scan and the CHECKs go in
+-- the plain way. Select, insert and update for the runtime role; nothing that
+-- deletes (the host's ensureRuntimeRole call sets that; see the README).
+
+create table if not exists reporting_requests (
+  bucket    timestamptz not null,
+  site      text not null,
+  color     text not null default '',
+  release   text not null default '',
+  requests  bigint not null default 0,
+  errors    bigint not null default 0,
+  constraint reporting_requests_pkey primary key (bucket, site, color, release),
+  constraint reporting_requests_site_check check (site ~ '^[a-z][a-z0-9-]{0,63}$'),
+  constraint reporting_requests_color_check check (color in ('', 'blue', 'green')),
+  constraint reporting_requests_counts_check check (requests >= 0 and errors between 0 and requests)
+);

package/dist/next/index.d.ts

@@ -3,6 +3,7 @@ import { deviceOf } from '../analytics/schema.js';
 import type { Reporting } from '../types.js';
 import { type ClientErrorCollectorOptions } from './client-errors.js';
 import { type EdgeErrorIngestOptions } from './edge-errors.js';
+export { releaseHealthHandler, withRequestCount, type ReleaseHealthOptions, } from './release-health.js';
 export { edgeErrorHandler, type EdgeCaptureOptions, type EdgeErrorReport } from './edge-errors.js';
 /**
  * The Next bindings: everything in the package that knows what a request is.

package/dist/next/index.js

@@ -6,6 +6,7 @@ import { createCollector } from '../analytics/collector.js';
 import { countryOf, deviceOf } from '../analytics/schema.js';
 import { createClientErrorCollector } from './client-errors.js';
 import { createEdgeErrorIngestCollector } from './edge-errors.js';
+export { releaseHealthHandler, withRequestCount, } from './release-health.js';
 export { edgeErrorHandler } from './edge-errors.js';
 /**
  * The Next bindings: everything in the package that knows what a request is.

package/dist/next/release-health.d.ts

@@ -0,0 +1,22 @@
+import type { Db, Reporting } from '../types.js';
+export interface ReleaseHealthOptions {
+    readonly db: Db;
+    readonly reporting: Pick<Reporting, 'site' | 'log'>;
+    /** Defaults to `process.env.REPORTING_HEALTH_TOKEN`, read on each request. */
+    readonly token?: () => string | undefined;
+}
+/**
+ * `GET /api/reporting/release-health?from=<ISO>&to=<ISO>`: the counts foundry
+ * judges a new color by. Request and 5xx totals per color over [from, to),
+ * and the per-day average of the seven days before `from`. Counts only; no
+ * event, error or request content is read. Bearer token from
+ * `REPORTING_HEALTH_TOKEN`: unset is 503, missing or wrong is 401.
+ */
+export declare function releaseHealthHandler(options: ReleaseHealthOptions): (request: Request) => Promise<Response>;
+/**
+ * Wraps a route handler so each response is counted. A handler that throws is
+ * counted as a 500 and the throw goes on. Next's own control-flow throws
+ * (`redirect()`, `notFound()` and the like) are counted as a request, not an
+ * error, so they cannot push a release toward rollback.
+ */
+export declare function withRequestCount<A extends unknown[]>(reporting: Pick<Reporting, 'requests'>, handler: (...args: A) => Promise<Response> | Response): (...args: A) => Promise<Response>;

package/dist/next/release-health.js

@@ -0,0 +1,122 @@
+import { timingSafeEqual } from 'node:crypto';
+import { and, gte, lt, sql } from 'drizzle-orm';
+import { unstable_rethrow } from 'next/navigation';
+import { connection } from 'next/server';
+import { z } from 'zod';
+import { reportingRequests } from '../tables.js';
+const DAY_MS = 86_400_000;
+const BASELINE_DAYS = 7;
+const MAX_RANGE_MS = 8 * DAY_MS;
+const iso = z.iso.datetime({ offset: true });
+function tokenMatches(provided, expected) {
+    const a = Buffer.from(provided);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+function json(body, status) {
+    return Response.json(body, { status, headers: { 'cache-control': 'no-store' } });
+}
+/**
+ * `GET /api/reporting/release-health?from=<ISO>&to=<ISO>`: the counts foundry
+ * judges a new color by. Request and 5xx totals per color over [from, to),
+ * and the per-day average of the seven days before `from`. Counts only; no
+ * event, error or request content is read. Bearer token from
+ * `REPORTING_HEALTH_TOKEN`: unset is 503, missing or wrong is 401.
+ */
+export function releaseHealthHandler(options) {
+    const token = options.token ?? (() => process.env.REPORTING_HEALTH_TOKEN);
+    const site = options.reporting.site;
+    return async (request) => {
+        await connection();
+        const expected = token();
+        if (!expected)
+            return json({ error: 'not configured' }, 503);
+        const header = request.headers.get('authorization') ?? '';
+        const match = /^Bearer (.+)$/.exec(header);
+        if (!match?.[1] || !tokenMatches(match[1], expected)) {
+            return json({ error: 'unauthorized' }, 401);
+        }
+        const params = new URL(request.url).searchParams;
+        const fromRaw = iso.safeParse(params.get('from'));
+        const toRaw = iso.safeParse(params.get('to'));
+        if (!fromRaw.success || !toRaw.success) {
+            return json({ error: 'from and to must be ISO timestamps' }, 400);
+        }
+        const from = new Date(fromRaw.data);
+        const to = new Date(toRaw.data);
+        if (!(from.getTime() < to.getTime()) || to.getTime() - from.getTime() > MAX_RANGE_MS) {
+            return json({ error: 'from must be before to, at most 8 days apart' }, 400);
+        }
+        try {
+            const sums = {
+                requests: sql `coalesce(sum(${reportingRequests.requests}), 0)`,
+                errors: sql `coalesce(sum(${reportingRequests.errors}), 0)`,
+            };
+            const inSite = sql `${reportingRequests.site} = ${site}`;
+            const byColor = await options.db
+                .select({ color: reportingRequests.color, ...sums })
+                .from(reportingRequests)
+                .where(and(inSite, gte(reportingRequests.bucket, from), lt(reportingRequests.bucket, to)))
+                .groupBy(reportingRequests.color);
+            const baselineFrom = new Date(from.getTime() - BASELINE_DAYS * DAY_MS);
+            const [baseline] = await options.db
+                .select(sums)
+                .from(reportingRequests)
+                .where(and(inSite, gte(reportingRequests.bucket, baselineFrom), lt(reportingRequests.bucket, from)));
+            const colors = {
+                blue: { requests: 0, errors: 0 },
+                green: { requests: 0, errors: 0 },
+            };
+            for (const row of byColor) {
+                if (row.color === 'blue' || row.color === 'green') {
+                    colors[row.color] = { requests: Number(row.requests), errors: Number(row.errors) };
+                }
+            }
+            return json({
+                colors,
+                daily: {
+                    days: BASELINE_DAYS,
+                    requestsPerDay: Number(baseline?.requests ?? 0) / BASELINE_DAYS,
+                    errorsPerDay: Number(baseline?.errors ?? 0) / BASELINE_DAYS,
+                },
+                from: from.toISOString(),
+                to: to.toISOString(),
+            }, 200);
+        }
+        catch (error) {
+            options.reporting.log.error({ err: error instanceof Error ? error.name : 'unknown' }, 'reporting: release health read failed');
+            return json({ error: 'read failed' }, 500);
+        }
+    };
+}
+// Any status under 500: the request is counted, and not as an error.
+const CONTROL_FLOW_STATUS = 307;
+function isNextControlFlow(error) {
+    try {
+        unstable_rethrow(error);
+        return false;
+    }
+    catch {
+        // unstable_rethrow throws only for Next's internal control-flow errors.
+        return true;
+    }
+}
+/**
+ * Wraps a route handler so each response is counted. A handler that throws is
+ * counted as a 500 and the throw goes on. Next's own control-flow throws
+ * (`redirect()`, `notFound()` and the like) are counted as a request, not an
+ * error, so they cannot push a release toward rollback.
+ */
+export function withRequestCount(reporting, handler) {
+    return async (...args) => {
+        try {
+            const response = await handler(...args);
+            reporting.requests.record(response.status);
+            return response;
+        }
+        catch (error) {
+            reporting.requests.record(isNextControlFlow(error) ? CONTROL_FLOW_STATUS : 500);
+            throw error;
+        }
+    };
+}

package/dist/requests.d.ts

@@ -0,0 +1,22 @@
+import type { Db, Logger } from './types.js';
+export interface RequestCounterOptions {
+    db: Db;
+    log: Logger;
+    site: string;
+    now: () => Date;
+    flushEveryMs: number;
+}
+/**
+ * Counts responses in memory and writes one upsert per minute bucket, so a
+ * request costs a map increment and the database sees a handful of rows a
+ * minute. `errors` is status >= 500. A failed write puts its counts back for
+ * the next one; the process dying loses at most `flushEveryMs` of counts.
+ */
+export declare class RequestCounter {
+    private readonly o;
+    private readonly buckets;
+    private timer;
+    constructor(o: RequestCounterOptions);
+    record(status: number): void;
+    flush(): Promise<void>;
+}

package/dist/requests.js

@@ -0,0 +1,72 @@
+import { sql } from 'drizzle-orm';
+import { deployTags } from './deploy.js';
+import { reportingRequests } from './tables.js';
+/**
+ * Counts responses in memory and writes one upsert per minute bucket, so a
+ * request costs a map increment and the database sees a handful of rows a
+ * minute. `errors` is status >= 500. A failed write puts its counts back for
+ * the next one; the process dying loses at most `flushEveryMs` of counts.
+ */
+export class RequestCounter {
+    o;
+    buckets = new Map();
+    timer = null;
+    constructor(o) {
+        this.o = o;
+    }
+    record(status) {
+        const minute = Math.floor(this.o.now().getTime() / 60_000) * 60_000;
+        const b = this.buckets.get(minute) ?? { requests: 0, errors: 0 };
+        b.requests += 1;
+        if (status >= 500)
+            b.errors += 1;
+        this.buckets.set(minute, b);
+        if (!this.timer) {
+            this.timer = setTimeout(() => {
+                this.timer = null;
+                void this.flush();
+            }, this.o.flushEveryMs);
+            this.timer.unref?.();
+        }
+    }
+    async flush() {
+        if (this.buckets.size === 0)
+            return;
+        const taken = [...this.buckets];
+        this.buckets.clear();
+        const { color, release } = deployTags();
+        try {
+            await this.o.db
+                .insert(reportingRequests)
+                .values(taken.map(([minute, c]) => ({
+                bucket: new Date(minute),
+                site: this.o.site,
+                color: color ?? '',
+                release: release ?? '',
+                requests: c.requests,
+                errors: c.errors,
+            })))
+                .onConflictDoUpdate({
+                target: [
+                    reportingRequests.bucket,
+                    reportingRequests.site,
+                    reportingRequests.color,
+                    reportingRequests.release,
+                ],
+                set: {
+                    requests: sql `${reportingRequests.requests} + excluded.requests`,
+                    errors: sql `${reportingRequests.errors} + excluded.errors`,
+                },
+            });
+        }
+        catch (error) {
+            for (const [minute, c] of taken) {
+                const b = this.buckets.get(minute) ?? { requests: 0, errors: 0 };
+                b.requests += c.requests;
+                b.errors += c.errors;
+                this.buckets.set(minute, b);
+            }
+            this.o.log.error({ err: error instanceof Error ? error.name : 'unknown' }, 'reporting: request counter flush failed');
+        }
+    }
+}

package/dist/tables.d.ts

@@ -130,6 +130,40 @@ export declare const reportingEvents: import("drizzle-orm/pg-core").PgTableWithC
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        release: import("drizzle-orm/pg-core").PgColumn<{
+            name: "release";
+            tableName: "reporting_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        color: import("drizzle-orm/pg-core").PgColumn<{
+            name: "color";
+            tableName: "reporting_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         tenantId: import("drizzle-orm/pg-core").PgColumn<{
             name: "tenant_id";
             tableName: "reporting_events";
@@ -878,6 +912,40 @@ export declare const reportingAnalytics: import("drizzle-orm/pg-core").PgTableWi
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        release: import("drizzle-orm/pg-core").PgColumn<{
+            name: "release";
+            tableName: "reporting_analytics";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        color: import("drizzle-orm/pg-core").PgColumn<{
+            name: "color";
+            tableName: "reporting_analytics";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;
@@ -1494,6 +1562,23 @@ export declare const reportingErrors: import("drizzle-orm/pg-core").PgTableWithC
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        color: import("drizzle-orm/pg-core").PgColumn<{
+            name: "color";
+            tableName: "reporting_errors";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         firstSeenAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "first_seen_at";
             tableName: "reporting_errors";
@@ -1741,17 +1826,128 @@ export type ReportingErrorRow = typeof reportingErrors.$inferSelect;
  * Counts, times and
  * `tenantId` are the tenant's own (reporting_error_tenants).
  */
-export type TenantErrorRow = Omit<ReportingErrorRow, 'message' | 'stack' | 'runtime' | 'release' | 'requestId' | 'resolvedBy' | 'state' | 'resolvedAt'> & {
+export type TenantErrorRow = Omit<ReportingErrorRow, 'message' | 'stack' | 'runtime' | 'release' | 'color' | 'requestId' | 'resolvedBy' | 'state' | 'resolvedAt'> & {
     readonly message: null;
     readonly stack: null;
     readonly runtime: null;
     readonly release: null;
+    readonly color: null;
     readonly requestId: null;
     readonly resolvedBy: null;
     /** Triage state is shared across tenants, so a tenant cannot see it. */
     readonly state: null;
     readonly resolvedAt: null;
 };
+/** Request and 5xx counts per minute, color and release; mirrored from migrations/0010_requests.sql. */
+export declare const reportingRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "reporting_requests";
+    schema: undefined;
+    columns: {
+        bucket: import("drizzle-orm/pg-core").PgColumn<{
+            name: "bucket";
+            tableName: "reporting_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        site: import("drizzle-orm/pg-core").PgColumn<{
+            name: "site";
+            tableName: "reporting_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        color: import("drizzle-orm/pg-core").PgColumn<{
+            name: "color";
+            tableName: "reporting_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        release: import("drizzle-orm/pg-core").PgColumn<{
+            name: "release";
+            tableName: "reporting_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "requests";
+            tableName: "reporting_requests";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        errors: import("drizzle-orm/pg-core").PgColumn<{
+            name: "errors";
+            tableName: "reporting_requests";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export declare const tables: {
     events: import("drizzle-orm/pg-core").PgTableWithColumns<{
         name: "reporting_events";
@@ -1878,6 +2074,40 @@ export declare const tables: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            release: import("drizzle-orm/pg-core").PgColumn<{
+                name: "release";
+                tableName: "reporting_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            color: import("drizzle-orm/pg-core").PgColumn<{
+                name: "color";
+                tableName: "reporting_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             tenantId: import("drizzle-orm/pg-core").PgColumn<{
                 name: "tenant_id";
                 tableName: "reporting_events";
@@ -2624,6 +2854,40 @@ export declare const tables: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            release: import("drizzle-orm/pg-core").PgColumn<{
+                name: "release";
+                tableName: "reporting_analytics";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            color: import("drizzle-orm/pg-core").PgColumn<{
+                name: "color";
+                tableName: "reporting_analytics";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: "pg";
     }>;
@@ -3237,6 +3501,23 @@ export declare const tables: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            color: import("drizzle-orm/pg-core").PgColumn<{
+                name: "color";
+                tableName: "reporting_errors";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
             firstSeenAt: import("drizzle-orm/pg-core").PgColumn<{
                 name: "first_seen_at";
                 tableName: "reporting_errors";
@@ -3468,4 +3749,113 @@ export declare const tables: {
         };
         dialect: "pg";
     }>;
+    requests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "reporting_requests";
+        schema: undefined;
+        columns: {
+            bucket: import("drizzle-orm/pg-core").PgColumn<{
+                name: "bucket";
+                tableName: "reporting_requests";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            site: import("drizzle-orm/pg-core").PgColumn<{
+                name: "site";
+                tableName: "reporting_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            color: import("drizzle-orm/pg-core").PgColumn<{
+                name: "color";
+                tableName: "reporting_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            release: import("drizzle-orm/pg-core").PgColumn<{
+                name: "release";
+                tableName: "reporting_requests";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            requests: import("drizzle-orm/pg-core").PgColumn<{
+                name: "requests";
+                tableName: "reporting_requests";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            errors: import("drizzle-orm/pg-core").PgColumn<{
+                name: "errors";
+                tableName: "reporting_requests";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
 };

package/dist/tables.js

@@ -15,6 +15,8 @@ export const reportingEvents = pgTable('reporting_events', {
     kindNs: text('kind_ns').generatedAlwaysAs(sql `split_part(kind, '.', 1)`),
     site: text('site').notNull(),
     environment: text('environment'),
+    release: text('release'),
+    color: text('color'),
     tenantId: uuid('tenant_id'),
     actorClass: text('actor_class'),
     actorId: text('actor_id'),
@@ -91,6 +93,8 @@ export const reportingAnalytics = pgTable('reporting_analytics', {
         .notNull()
         .default(sql `'{}'::jsonb`),
     schemaVersion: smallint('schema_version').notNull().default(1),
+    release: text('release'),
+    color: text('color'),
 }, (t) => [
     index('reporting_analytics_site_time_idx').on(t.site, t.occurredAt.desc(), t.id.desc()),
     index('reporting_analytics_tenant_time_idx')
@@ -162,6 +166,7 @@ export const reportingErrors = pgTable('reporting_errors', {
     stack: text('stack'),
     runtime: text('runtime').notNull(),
     release: text('release'),
+    color: text('color'),
     firstSeenAt: timestamp('first_seen_at', { withTimezone: true }).notNull(),
     lastSeenAt: timestamp('last_seen_at', { withTimezone: true }).notNull(),
     occurrences: bigint('occurrences', { mode: 'number' }).notNull().default(1),
@@ -187,6 +192,20 @@ export const reportingErrorTenants = pgTable('reporting_error_tenants', {
     primaryKey({ name: 'reporting_error_tenants_pkey', columns: [t.fingerprint, t.tenantId] }),
     index('reporting_error_tenants_tenant_idx').on(t.tenantId, t.lastSeenAt.desc()),
 ]);
+/** Request and 5xx counts per minute, color and release; mirrored from migrations/0010_requests.sql. */
+export const reportingRequests = pgTable('reporting_requests', {
+    bucket: timestamp('bucket', { withTimezone: true }).notNull(),
+    site: text('site').notNull(),
+    color: text('color').notNull().default(''),
+    release: text('release').notNull().default(''),
+    requests: bigint('requests', { mode: 'number' }).notNull().default(0),
+    errors: bigint('errors', { mode: 'number' }).notNull().default(0),
+}, (t) => [
+    primaryKey({
+        name: 'reporting_requests_pkey',
+        columns: [t.bucket, t.site, t.color, t.release],
+    }),
+]);
 export const tables = {
     events: reportingEvents,
     tasks: reportingTasks,
@@ -197,4 +216,5 @@ export const tables = {
     analyticsWeekly: reportingAnalyticsWeekly,
     errors: reportingErrors,
     errorTenants: reportingErrorTenants,
+    requests: reportingRequests,
 };

package/dist/types.d.ts

@@ -81,6 +81,8 @@ export interface ReportingOptions {
     batchSize?: number;
     /** Timer flush interval, ms. Default 1,000. */
     flushEveryMs?: number;
+    /** How often counted requests are written, ms. Default 10,000. */
+    requestFlushEveryMs?: number;
 }
 export interface EventsPageOptions {
     readonly limit?: number;
@@ -198,6 +200,10 @@ export interface Reporting {
     readonly site: string;
     readonly log: Logger;
     readonly analytics: Analytics;
+    /** Counts one response for the release-health read; `flush` writes the counts. Never throws. */
+    readonly requests: {
+        record(status: number): void;
+    };
     stats(): Stats;
 }
 export type { Actor, EventInput, FlatData, Level };

package/dist/writer.js

@@ -1,3 +1,4 @@
+import { deployTags } from './deploy.js';
 import { eventInputSchema } from './schema.js';
 import { reportingEvents } from './tables.js';
 export class Writer {
@@ -55,6 +56,7 @@ export class Writer {
             kind: v.kind,
             site: this.o.site,
             environment: this.o.environment,
+            ...deployTags(),
             tenantId: v.tenantId ?? null,
             actorClass: v.actor?.class ?? null,
             actorId: v.actor?.id ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtfalch/reporting",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "The estate's operational event log and housekeeping tick: a writer that never fails a request, a claim protocol that needs no scheduler, and the readers an operator opens. Per-app Postgres, host-supplied logger, framework-neutral core with a Next entry.",
   "repository": {
     "type": "git",
@@ -26,10 +26,6 @@
       "types": "./dist/next/index.d.ts",
       "default": "./dist/next/index.js"
     },
-    "./fake": {
-      "types": "./dist/fake/index.d.ts",
-      "default": "./dist/fake/index.js"
-    },
     "./browser": {
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"

package/dist/fake/index.d.ts

@@ -1,22 +0,0 @@
-import type { ReportingEventRow } from '../tables.js';
-import type { AlertFinding, Logger, Reporting, TrackInput } from '../types.js';
-/**
- * An in-memory `Reporting` for a host's unit tests: same validation, same
- * shape, no database. `rows` is the table; `alerts` is what `onAlert` would
- * have received. Validation failures throw, as in development.
- */
-export interface FakeReporting extends Reporting {
-    readonly rows: ReportingEventRow[];
-    readonly alerts: AlertFinding[];
-    /** What `analytics.track` received. */
-    readonly tracked: (TrackInput & {
-        site: string;
-    })[];
-    reset(): void;
-}
-export declare function createFakeReporting(opts?: {
-    site?: string;
-    log?: Logger;
-    redactEnvVars?: readonly string[];
-    environment?: string | null;
-}): FakeReporting;

package/dist/fake/index.js

@@ -1,157 +0,0 @@
-import { alertRow } from '../alerts.js';
-import { createCapture } from '../errors/capture.js';
-import { eventInputSchema } from '../schema.js';
-import { DEFAULT_SETTINGS, RETENTION_BOUNDS } from '../settings.js';
-import { tables } from '../tables.js';
-const silent = { info() { }, warn() { }, error() { } };
-export function createFakeReporting(opts = {}) {
-    const site = opts.site ?? 'test';
-    const environment = opts.environment ?? null;
-    const log = opts.log ?? silent;
-    const rows = [];
-    const alerts = [];
-    const tracked = [];
-    let settings = { ...DEFAULT_SETTINGS };
-    const tenantRetention = new Map();
-    let id = 0;
-    // No group table to fake, so the upsert never runs (`defer` is a no-op);
-    // the timeline row through `fake.event` is what a host's test asserts on.
-    const capture = createCapture({
-        db: undefined,
-        log,
-        site,
-        now: () => new Date(),
-        defer: () => { },
-        event: (input) => fake.event(input),
-        redactEnvVars: opts.redactEnvVars,
-    });
-    const fake = {
-        site,
-        log,
-        tables,
-        rows,
-        alerts,
-        tracked,
-        event(input) {
-            const v = eventInputSchema.parse(input);
-            id += 1;
-            rows.push({
-                id,
-                occurredAt: v.occurredAt ?? new Date(),
-                level: v.level,
-                kind: v.kind,
-                kindNs: v.kind.split('.')[0] ?? '',
-                site,
-                environment,
-                tenantId: v.tenantId ?? null,
-                actorClass: v.actor?.class ?? null,
-                actorId: v.actor?.id ?? null,
-                requestId: v.requestId ?? null,
-                targetType: v.target?.type ?? null,
-                targetId: v.target?.id ?? null,
-                message: v.message,
-                data: v.data,
-                schemaVersion: 1,
-            });
-        },
-        alert(finding) {
-            fake.event(alertRow(finding));
-            alerts.push(finding);
-        },
-        captureError: (error, context) => capture(error, context),
-        async flush() { },
-        events: {
-            async page(o = {}) {
-                const limit = Math.max(1, Math.min(o.limit ?? 50, 200));
-                let list = [...rows].sort((a, b) => b.occurredAt.getTime() - a.occurredAt.getTime() || b.id - a.id);
-                if (o.level)
-                    list = list.filter((r) => r.level === o.level);
-                if (o.kindNs)
-                    list = list.filter((r) => r.kindNs === o.kindNs);
-                if (o.tenantId)
-                    list = list.filter((r) => r.tenantId === o.tenantId);
-                if (o.site)
-                    list = list.filter((r) => r.site === o.site);
-                if (o.requestId)
-                    list = list.filter((r) => r.requestId === o.requestId);
-                if (o.environment)
-                    list = list.filter((r) => r.environment === o.environment);
-                if (o.after) {
-                    const { occurredAt, id: afterId } = o.after;
-                    list = list.filter((r) => r.occurredAt.getTime() < occurredAt.getTime() ||
-                        (r.occurredAt.getTime() === occurredAt.getTime() && r.id < afterId));
-                }
-                const items = list.slice(0, limit);
-                const last = items.at(-1);
-                return {
-                    items,
-                    next: list.length > limit && last ? { occurredAt: last.occurredAt, id: last.id } : null,
-                };
-            },
-        },
-        settings: {
-            async get() {
-                return settings;
-            },
-            async set(patch, by) {
-                const before = settings;
-                for (const [key, value] of Object.entries(patch)) {
-                    if (typeof value !== 'number' ||
-                        !Number.isInteger(value) ||
-                        value < RETENTION_BOUNDS.min ||
-                        value > RETENTION_BOUNDS.max) {
-                        throw new Error(`reporting.settings: ${key} out of bounds`);
-                    }
-                }
-                settings = { ...settings, ...patch };
-                const changed = Object.keys(patch).filter((k) => before[k] !== settings[k]);
-                return { before, after: settings, by, changed };
-            },
-        },
-        tenantSettings: {
-            async get(tenantId) {
-                const out = {};
-                for (const key of ['events.retention_days', 'analytics.retention_days']) {
-                    const value = tenantRetention.get(`${tenantId}:${key}`);
-                    if (value !== undefined)
-                        out[key] = value;
-                }
-                return out;
-            },
-            async set(tenantId, key, days) {
-                const mapKey = `${tenantId}:${key}`;
-                if (days === null) {
-                    tenantRetention.delete(mapKey);
-                    return;
-                }
-                if (!Number.isInteger(days) || days < RETENTION_BOUNDS.min || days > RETENTION_BOUNDS.max) {
-                    throw new Error(`reporting.tenantSettings: ${key} out of bounds`);
-                }
-                tenantRetention.set(mapKey, days);
-            },
-        },
-        analytics: {
-            async track(input) {
-                tracked.push({ ...input, site });
-            },
-            async series() {
-                return [];
-            },
-            async weekly() {
-                return [];
-            },
-            async recent() {
-                return [];
-            },
-        },
-        stats: () => ({ queued: 0, dropped: 0, invalid: 0, flushed: rows.length }),
-        reset() {
-            rows.length = 0;
-            alerts.length = 0;
-            settings = { ...DEFAULT_SETTINGS };
-            tenantRetention.clear();
-            id = 0;
-        },
-    };
-    return fake;
-}