fix(webapp): don't emit zeroed engine metrics when $metrics read fails

A failed $metrics.json() previously zero-filled every engine-derived value, so
the batch observer reported spurious zeros — including for cumulative counters
(db.client.queries.total, db.datasource.queries.total,
db.pool.connections.opened/closed.total), which reads as a counter reset and
corrupts rate math. Restore the old fail-quiet behavior per client: the
collector now signals engineMetricsAvailable and leaves engine-derived fields
(counters/gauges/histograms, and quaint pool figures) undefined on failure, and
the tracer skips those instruments for that client. Adapter clients still emit
live pg.Pool figures because those don't depend on $metrics.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KHjfL7qXHia5DTnxi1RePS

Author: ericallam

apps/webapp/app/utils/databaseMetrics.server.test.ts

@@ -47,6 +47,7 @@ describe("normalizeDatabaseMetrics", () => {
 
     expect(result.driver).toBe("quaint");
     expect(result.clientType).toBe("writer");
+    expect(result.engineMetricsAvailable).toBe(true);
     expect(result.pool).toEqual({
       open: 9,
       busy: 4,
@@ -72,6 +73,7 @@ describe("normalizeDatabaseMetrics", () => {
     const result = normalizeDatabaseMetrics(source, quaintJson());
 
     expect(result.driver).toBe("pg-adapter");
+    expect(result.engineMetricsAvailable).toBe(true);
     expect(result.pool).toEqual({
       open: 8,
       busy: 5,
@@ -94,10 +96,10 @@ describe("normalizeDatabaseMetrics", () => {
 
     const result = normalizeDatabaseMetrics(source, quaintJson());
 
-    expect(result.pool.busy).toBe(0);
+    expect(result.pool?.busy).toBe(0);
   });
 
-  it("falls back to zeroed query/pool metrics when $metrics is unavailable for a quaint client", () => {
+  it("omits engine-derived metrics and pool when $metrics is unavailable for a quaint client", () => {
     const source: DatabaseMetricsSource = {
       clientType: "writer",
       usesDriverAdapter: false,
@@ -106,19 +108,14 @@ describe("normalizeDatabaseMetrics", () => {
 
     const result = normalizeDatabaseMetrics(source, undefined);
 
-    expect(result.pool).toEqual({
-      open: 0,
-      busy: 0,
-      idle: 0,
-      waiting: 0,
-      openedTotal: 0,
-      closedTotal: 0,
-    });
-    expect(result.counters).toEqual({ queriesTotal: 0, datasourceQueriesTotal: 0 });
+    expect(result.engineMetricsAvailable).toBe(false);
+    expect(result.pool).toBeUndefined();
+    expect(result.counters).toBeUndefined();
+    expect(result.gauges).toBeUndefined();
     expect(result.histograms.queriesDuration).toBeUndefined();
   });
 
-  it("keeps adapter pool figures even when $metrics is unavailable", () => {
+  it("keeps pg.Pool figures but omits engine metrics when $metrics is unavailable for an adapter client", () => {
     const source: DatabaseMetricsSource = {
       clientType: "control-plane-writer",
       usesDriverAdapter: true,
@@ -129,6 +126,7 @@ describe("normalizeDatabaseMetrics", () => {
 
     const result = normalizeDatabaseMetrics(source, undefined);
 
+    expect(result.engineMetricsAvailable).toBe(false);
     expect(result.pool).toEqual({
       open: 7,
       busy: 5,
@@ -137,6 +135,7 @@ describe("normalizeDatabaseMetrics", () => {
       openedTotal: 9,
       closedTotal: 2,
     });
-    expect(result.counters).toEqual({ queriesTotal: 0, datasourceQueriesTotal: 0 });
+    expect(result.counters).toBeUndefined();
+    expect(result.gauges).toBeUndefined();
   });
 });

apps/webapp/app/utils/databaseMetrics.server.ts

@@ -42,9 +42,10 @@ export type NormalizedPoolMetrics = {
 export type NormalizedDatabaseMetrics = {
   clientType: string;
   driver: "pg-adapter" | "quaint";
-  pool: NormalizedPoolMetrics;
-  counters: { queriesTotal: number; datasourceQueriesTotal: number };
-  gauges: { queriesActive: number; queriesWait: number };
+  engineMetricsAvailable: boolean;
+  pool?: NormalizedPoolMetrics;
+  counters?: { queriesTotal: number; datasourceQueriesTotal: number };
+  gauges?: { queriesActive: number; queriesWait: number };
   histograms: {
     queriesWait?: MetricHistogramValue;
     queriesDuration?: MetricHistogramValue;
@@ -78,16 +79,11 @@ export function normalizeDatabaseMetrics(
   source: DatabaseMetricsSource,
   json: PrismaMetricsJson | undefined
 ): NormalizedDatabaseMetrics {
-  const counters = json ? indexByKey(json.counters) : {};
-  const gauges = json ? indexByKey(json.gauges) : {};
-  const histograms: Record<string, MetricHistogramValue> = {};
-  if (json) {
-    for (const histogram of json.histograms) {
-      histograms[histogram.key] = histogram.value;
-    }
-  }
+  const driver = source.usesDriverAdapter ? ("pg-adapter" as const) : ("quaint" as const);
+  const counters = json ? indexByKey(json.counters) : undefined;
+  const gauges = json ? indexByKey(json.gauges) : undefined;
 
-  let pool: NormalizedPoolMetrics;
+  let pool: NormalizedPoolMetrics | undefined;
   if (source.usesDriverAdapter && source.pool) {
     const total = source.pool.totalCount;
     const idle = source.pool.idleCount;
@@ -99,7 +95,7 @@ export function normalizeDatabaseMetrics(
       openedTotal: source.poolCounters?.opened() ?? 0,
       closedTotal: source.poolCounters?.closed() ?? 0,
     };
-  } else {
+  } else if (counters && gauges) {
     pool = {
       open: gauges["prisma_pool_connections_open"] ?? 0,
       busy: gauges["prisma_pool_connections_busy"] ?? 0,
@@ -110,24 +106,35 @@ export function normalizeDatabaseMetrics(
     };
   }
 
-  return {
+  const result: NormalizedDatabaseMetrics = {
     clientType: source.clientType,
-    driver: source.usesDriverAdapter ? "pg-adapter" : "quaint",
+    driver,
+    engineMetricsAvailable: json !== undefined,
     pool,
-    counters: {
+    histograms: {},
+  };
+
+  if (json && counters && gauges) {
+    const histograms: Record<string, MetricHistogramValue> = {};
+    for (const histogram of json.histograms) {
+      histograms[histogram.key] = histogram.value;
+    }
+    result.counters = {
       queriesTotal: counters["prisma_client_queries_total"] ?? 0,
       datasourceQueriesTotal: counters["prisma_datasource_queries_total"] ?? 0,
-    },
-    gauges: {
+    };
+    result.gauges = {
       queriesActive: gauges["prisma_client_queries_active"] ?? 0,
       queriesWait: gauges["prisma_client_queries_wait"] ?? 0,
-    },
-    histograms: {
+    };
+    result.histograms = {
       queriesWait: histograms["prisma_client_queries_wait_histogram_ms"],
       queriesDuration: histograms["prisma_client_queries_duration_histogram_ms"],
       datasourceQueriesDuration: histograms["prisma_datasource_queries_duration_histogram_ms"],
-    },
-  };
+    };
+  }
+
+  return result;
 }
 
 export async function collectDatabaseClientMetrics(): Promise<NormalizedDatabaseMetrics[]> {

apps/webapp/app/v3/tracer.server.ts

@@ -521,17 +521,23 @@ function configurePrismaMetrics({ meter }: { meter: Meter }) {
         const attributes = { db_client: client.clientType, db_driver: client.driver };
         const { pool, counters, gauges, histograms } = client;
 
+        if (pool) {
+          res.observe(connectionsOpenedTotal, pool.openedTotal, attributes);
+          res.observe(connectionsClosedTotal, pool.closedTotal, attributes);
+          res.observe(totalGauge, pool.open, attributes);
+          res.observe(busyGauge, pool.busy, attributes);
+          res.observe(freeGauge, pool.idle, attributes);
+          res.observe(waitingGauge, pool.waiting, attributes);
+        }
+
+        if (!counters || !gauges) {
+          continue;
+        }
+
         res.observe(queriesTotal, counters.queriesTotal, attributes);
         res.observe(datasourceQueriesTotal, counters.datasourceQueriesTotal, attributes);
-        res.observe(connectionsOpenedTotal, pool.openedTotal, attributes);
-        res.observe(connectionsClosedTotal, pool.closedTotal, attributes);
-
         res.observe(queriesActive, gauges.queriesActive, attributes);
         res.observe(queriesWait, gauges.queriesWait, attributes);
-        res.observe(totalGauge, pool.open, attributes);
-        res.observe(busyGauge, pool.busy, attributes);
-        res.observe(freeGauge, pool.idle, attributes);
-        res.observe(waitingGauge, pool.waiting, attributes);
 
         if (histograms.queriesWait) {
           res.observe(queriesWaitTimeCount, histograms.queriesWait.count, attributes);