@wtfalch/reporting 0.7.0 → 0.9.0

package/dist/requests.js

@@ -0,0 +1,82 @@
+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;
+    }
+    /** Counts one response. */
+    record(status) {
+        this.add(status >= 500 ? 1 : 0, 1);
+    }
+    /**
+     * Counts one 5xx for a request already counted by `record`, such as a page
+     * that threw after the proxy let it through. Adds no request.
+     */
+    recordError() {
+        this.add(1, 0);
+    }
+    add(errors, requests) {
+        const minute = Math.floor(this.o.now().getTime() / 60_000) * 60_000;
+        const b = this.buckets.get(minute) ?? { requests: 0, errors: 0 };
+        b.requests += requests;
+        b.errors += errors;
+        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,11 @@ 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;
+        recordError(): 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.9.0",
   "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;