fix(bench): include successful query logging in database workload

Create the QueryLog fixture schema and its indexes so stock Stacks persists diagnostics instead of measuring failed inserts against a missing table. Clear accumulated logs before each repetition outside warmup and measurement, preserving read data.

Add an isolated real-query regression that reproduces the missing table failure, verifies persistence, and checks reset integrity. Document the asymmetric logging workload and that earlier failed-write results are not comparable.

Validation: four benchmark tests, 366 unit tests, lint, framework types, and two independent reviews passed. Three native oha repetitions passed response parity with zero errors and actual persisted logs. Local results are directional only.

Author: chrisbbreuer

bench/routing/README.md

@@ -78,6 +78,13 @@ papered over. `post-validate` has the same shape: Elysia uses its `t` schema,
 Hono a hand-written check behind its own `validator()` seam, and both are
 cheaper than a compiled rule set.
 
+The fixture includes `query_logs` and its indexes, so stock Stacks query logging
+performs successful writes. Those writes are part of the database workload;
+the bare SQLite targets do not provide query logging. Accumulated logs are
+cleared before each repetition, outside warm-up and measurement, while the
+seeded read data stays unchanged. Results from the earlier fixture without
+`query_logs` measured failed logging writes and are not comparable.
+
 ## Profiles
 
 Stacks appears three times on purpose. The gap between the first and the third

bench/routing/fixture.test.ts

@@ -0,0 +1,58 @@
+import { Database } from 'bun:sqlite'
+import { expect, it } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { createFixture, FIXTURE_ROWS, resetFixtureLogs } from './fixture'
+
+it('supports real query logging in the isolated benchmark database', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'stacks-routing-fixture-'))
+  const file = join(dir, 'bench.sqlite')
+  try {
+    createFixture(file)
+    const child = Bun.spawn([
+      process.execPath,
+      `--config=${join(import.meta.dir, 'bunfig.toml')}`,
+      join(import.meta.dir, 'fixtures/query-logging.ts'),
+      file,
+    ], {
+      env: { ...process.env, APP_ENV: 'test', DB_CONNECTION: 'sqlite', DB_DATABASE_PATH: file, DB_QUERY_LOGGING_ENABLED: 'true' },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const [exitCode, stdout, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+    ])
+    expect(exitCode, stderr).toBe(0)
+    expect(stdout).toContain('fixture-query-logging-ok')
+
+    const db = new Database(file)
+    try {
+      expect(db.query('SELECT COUNT(*) AS count FROM bench_items').get()).toEqual({ count: FIXTURE_ROWS })
+      expect(db.query('SELECT status FROM query_logs').all()).toEqual([{ status: 'completed' }])
+    }
+    finally {
+      db.close()
+    }
+    resetFixtureLogs(file)
+    const reset = new Database(file)
+    try {
+      expect(reset.query('SELECT COUNT(*) AS count FROM query_logs').get()).toEqual({ count: 0 })
+      expect(reset.query('SELECT COUNT(*) AS count FROM bench_items').get()).toEqual({ count: FIXTURE_ROWS })
+      expect(reset.query('SELECT * FROM bench_items WHERE id = 1').get()).toEqual({ id: 1, name: 'item-1' })
+      expect(reset.query("SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'query_logs' ORDER BY name").all()).toEqual([
+        { name: 'query_logs_duration_index' },
+        { name: 'query_logs_executed_at_index' },
+        { name: 'query_logs_status_index' },
+      ])
+    }
+    finally {
+      reset.close()
+    }
+  }
+  finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})

bench/routing/fixture.ts

@@ -28,6 +28,40 @@ export function createFixture(file: string): void {
     db.exec('DROP TABLE IF EXISTS bench_items')
     db.exec('CREATE TABLE bench_items (id INTEGER PRIMARY KEY, name TEXT NOT NULL)')
 
+    // Match the built-in QueryLog model, including its write-side indexes.
+    // Stock Stacks logs the SELECT; a missing table measures a failed INSERT.
+    db.exec('DROP TABLE IF EXISTS query_logs')
+    db.exec(`CREATE TABLE query_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT,
+      query TEXT NOT NULL,
+      normalized_query TEXT,
+      duration REAL DEFAULT 0,
+      connection TEXT DEFAULT 'unknown',
+      status TEXT DEFAULT 'completed' CHECK (status IN ('completed', 'failed', 'slow')),
+      error TEXT,
+      executed_at TEXT NOT NULL,
+      bindings TEXT,
+      trace TEXT,
+      model TEXT,
+      method TEXT,
+      file TEXT,
+      line INTEGER,
+      memory_usage REAL,
+      rows_affected INTEGER,
+      transaction_id TEXT,
+      tags TEXT,
+      affected_tables TEXT,
+      indexes_used TEXT,
+      missing_indexes TEXT,
+      explain_plan TEXT,
+      optimization_suggestions TEXT
+    )`)
+    db.exec('CREATE INDEX query_logs_executed_at_index ON query_logs (executed_at)')
+    db.exec('CREATE INDEX query_logs_status_index ON query_logs (status)')
+    db.exec('CREATE INDEX query_logs_duration_index ON query_logs (duration)')
+
     const insert = db.prepare('INSERT INTO bench_items (id, name) VALUES (?, ?)')
     const seed = db.transaction((count: number) => {
       for (let i = 1; i <= count; i++) insert.run(i, `item-${i}`)
@@ -38,3 +72,16 @@ export function createFixture(file: string): void {
     db.close()
   }
 }
+
+/** Reset accumulated diagnostics outside the timed workload, keeping seed rows. */
+export function resetFixtureLogs(file: string): void {
+  const db = new Database(file)
+  try {
+    db.exec('DELETE FROM query_logs')
+    db.exec("DELETE FROM sqlite_sequence WHERE name = 'query_logs'")
+    db.exec('PRAGMA wal_checkpoint(TRUNCATE)')
+  }
+  finally {
+    db.close()
+  }
+}

bench/routing/fixtures/query-logging.ts

@@ -0,0 +1,39 @@
+const file = process.argv[2]!
+const { config, overridesReady } = await import('@stacksjs/config')
+const { db, ensureDatabaseConfigLoaded, initializeDbConfig, resetDatabaseConnection } = await import('../../../storage/framework/core/database/src/utils')
+
+await overridesReady
+await ensureDatabaseConfigLoaded()
+initializeDbConfig({
+  app: { env: 'test' },
+  database: { default: 'sqlite', connections: { sqlite: { database: file } } },
+})
+config.database.queryLogging = {
+  ...config.database.queryLogging,
+  enabled: true,
+  excludedQueries: [],
+  analysis: { ...config.database.queryLogging?.analysis, enabled: false },
+}
+
+try {
+  const rows = await db.selectFrom('bench_items').select(['id', 'name']).where('id', '=', 1).limit(1).execute()
+  if (JSON.stringify(rows) !== '[{"id":1,"name":"item-1"}]')
+    throw new Error('Unexpected benchmark query result')
+
+  const deadline = Date.now() + 2000
+  for (;;) {
+    const records = await db.unsafe('SELECT query, status FROM query_logs').execute()
+    if (records.length > 0) {
+      if (records.length !== 1 || !String(records[0]?.query).includes('bench_items') || records[0]?.status !== 'completed')
+        throw new Error('Unexpected benchmark query log')
+      break
+    }
+    if (Date.now() > deadline)
+      throw new Error('Benchmark query was never logged')
+    await Bun.sleep(10)
+  }
+  console.log('fixture-query-logging-ok')
+}
+finally {
+  resetDatabaseConnection()
+}

bench/routing/run.ts

@@ -20,7 +20,7 @@ import { join } from 'node:path'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 import { pickDriver } from './drivers'
-import { createFixture } from './fixture'
+import { createFixture, resetFixtureLogs } from './fixture'
 import { renderReport } from './report'
 import { assertParity, boot, FIXTURE, headersFor, PORT, stop } from './runtime'
 import { SCENARIOS } from './scenarios'
@@ -188,6 +188,8 @@ async function main(): Promise<void> {
         const cpuReadings: number[] = []
 
         for (let run = 1; run <= opts.runs; run++) {
+          if (scenario.requiresDb)
+            resetFixtureLogs(FIXTURE)
           const finishCpu = await measureCpu(booted.pid)
           const result = await driver.run({
             url: `http://127.0.0.1:${PORT}${scenario.path}`,