46cceb8 · 1a35937
@@ -291,6 +291,17 @@
fixture; all three caches hit):
The anonymous door (1.5 ms, 10 statements), the app shelf, and the
"On you" card. Each costs less than its cache's key would.
## Telemetry does not invalidate (#7896)
The write clock counts every row the connection changes, and a signed-in
visit itself writes: route timings a second after the request, usage
counts, flag reads, the session's last-seen time, the home visit, page
vitals, machine and memory samples. Counted, they kept every cache cold
for the next visitor. These writers run inside `quietly` (`core/write_clock.ts`),
which leaves their rows out of the stamp. Wrap only a write to a table no
cached page is built from; a page that shows telemetry is bounded by the
30 seconds a cache entry lives. `test/write-clock-quiet.test.ts` proves it.
## The writes that invalidate
Each row is an action (or, for a push, the post-receive hook, the one
@@ -8,6 +8,7 @@
import type { Database } from "bun:sqlite";
import { heapStats } from "bun:jsc";
import type { App } from "../app.ts";
import { quietly } from "../core/write_clock.ts";
export const MEMORY_EVERY_MS = 60_000;
export const HOUR_MS = 3_600_000;
@@ -29,7 +30,7 @@
const valid = (n: number) => Number.isFinite(n) && n >= 0;
export function recordMemory(db: Database, rss: number, heap: number, now: number): void {
  if (!valid(rss) || !valid(heap) || !valid(now)) return;
  const hour = Math.floor(now / HOUR_MS) * HOUR_MS;
  db.transaction(() => {
  db.transaction(() => quietly(db, () => {
    db.run(
      `INSERT INTO memory_hour (hour, samples, rss_sum, rss_max, heap_sum, heap_max) VALUES (?, 1, ?, ?, ?, ?)
       ON CONFLICT(hour) DO UPDATE SET samples = samples + 1, rss_sum = rss_sum + excluded.rss_sum,
@@ -38,7 +39,7 @@
export function recordMemory(db: Database, rss: number, heap: number, now: numbe
      [hour, rss, rss, heap, heap],
    );
    db.run("DELETE FROM memory_hour WHERE hour < ?", [hour - KEEP_MS]);
  })();
  }))();
}
/** The hours in the `hours` before `now` (the current one included), oldest first. */
@@ -7,6 +7,7 @@
 */
import type { Database } from "bun:sqlite";
import { withoutWaiting } from "../kernel/db.ts";
import { quietly } from "../core/write_clock.ts";
export const FINE_MS = 15_000;
export const COARSE_MS = 300_000;
@@ -104,7 +105,7 @@
export function record(db: Database, points: readonly Point[], now: number): voi
        lag_ms, lag_ms_max, checks, agents)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
  );
  withoutWaiting(db, db.transaction(() => {
  withoutWaiting(db, db.transaction(() => quietly(db, () => {
    for (const p of points) {
      const c = p.celsius ?? null;
      const lag = p.lagMs ?? null;
@@ -137,5 +138,5 @@
export function record(db: Database, points: readonly Point[], now: number): voi
    }
    db.query("DELETE FROM machine_sample WHERE step = 15 AND at < ?").run(iso(now - FINE_KEEP_MS));
    db.query("DELETE FROM machine_sample WHERE step = 300 AND at < ?").run(iso(now - COARSE_KEEP_MS));
  }));
  })));
}
@@ -17,6 +17,7 @@
 */
import type { Database } from "bun:sqlite";
import { quietly } from "./write_clock.ts";
export type FlagDecl = {
  /** One line: what the flag switches and why it exists. */
@@ -274,12 +275,12 @@
export function makeFlags<const D extends Record<string, FlagDecl>>(decls: D) {
          `INSERT INTO flag_use (day, flag, variant, n) VALUES (?1, ?2, ?3, ?4)
           ON CONFLICT (day, flag, variant) DO UPDATE SET n = n + excluded.n`,
        );
        db.transaction(() => {
        db.transaction(() => quietly(db, () => {
          for (const [key, n] of taken) {
            const [day, flag, variant] = key.split("\t");
            up.run(day!, flag!, Number(variant), n);
          }
        })();
        }))();
      } catch {
        for (const [key, n] of taken) pending.set(key, (pending.get(key) ?? 0) + n);
      }
@@ -5,6 +5,7 @@
 */
import type { Database } from "bun:sqlite";
import { quietly } from "./write_clock.ts";
export const VISIT_WRITE_GAP_MS = 60 * 1000;
@@ -16,9 +17,11 @@
export function lastVisit(db: Database, userId: string): number | undefined {
export function noteVisit(db: Database, userId: string, now: number): number | undefined {
  const before = lastVisit(db, userId);
  if (before === undefined || now - before >= VISIT_WRITE_GAP_MS)
    db.query(
      "INSERT INTO home_visit (user_id, at) VALUES (?1, ?2) ON CONFLICT(user_id) DO UPDATE SET at = excluded.at",
    ).run(userId, now);
    quietly(db, () =>
      db
        .query("INSERT INTO home_visit (user_id, at) VALUES (?1, ?2) ON CONFLICT(user_id) DO UPDATE SET at = excluded.at")
        .run(userId, now),
    );
  return before;
}
@@ -0,0 +1,1 @@
6f100057a211ae106d96d29d3e46bdd6afe425297b44c6206bf4135bdf42a434
@@ -0,0 +1,12 @@
// The home and a repository page read the whole issue table cold (#7896):
// the open counts of every repository, the open pulls, the newest comment of
// every open issue. Each now walks an index and not the table: the counts
// are answered by `issue_counts` alone, open pulls by a partial index of
// just them, a time window of pulls by `issue_created`, and an issue's
// newest comment by its place in `comment_issue_at`. Additive.
export default `
  CREATE INDEX issue_counts ON issue(repo_id, state, sealed, kind);
  CREATE INDEX issue_open_pull ON issue(repo_id) WHERE state = 'open' AND kind = 'pull';
  CREATE INDEX issue_created ON issue(created_at);
  CREATE INDEX comment_issue_at ON comment(issue_id, created_at, id);
  `;
@@ -20,6 +20,7 @@
import type { Database } from "bun:sqlite";
import { withoutWaiting } from "../kernel/db.ts";
import { quietly } from "./write_clock.ts";
/** Upper edges in ms; bucket `i` holds durations `<= EDGES_MS[i]`, the last is everything slower. */
export const EDGES_MS = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500] as const;
@@ -129,7 +130,7 @@
export function createRouteTiming(
      );
      const hourNo = Math.floor(now() / HOUR_MS);
      // Behind another process's lock this throws at once and the records go back (#6957).
      withoutWaiting(db, db.transaction(() => {
      withoutWaiting(db, db.transaction(() => quietly(db, () => {
        for (const [key, v] of batch) {
          const [h, pattern, b] = key.split(SEP) as [string, string, string];
          upsert.run(hourText(Number(h)), pattern, Number(b), v.n, v.us);
@@ -140,7 +141,7 @@
export function createRouteTiming(
          );
          prunedHour = hourNo;
        }
      }));
      })));
    } catch (err) {
      prunedHour = -1;
      for (const [key, v] of batch) {
@@ -8,6 +8,7 @@
import { sha256 } from "../kernel/hash.ts";
import { id as newId, secret } from "../kernel/id.ts";
import { err, ok, type Result } from "../kernel/result.ts";
import { getUserById, isActive, type User } from "./users.ts";
import { quietly } from "./write_clock.ts";
const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
/** How stale a session's last-seen time may get before a request moves it. */
@@ -70,9 +71,11 @@
export function sessionOf(
  // At most one write a minute per browser, however busy it is.
  const stale = new Date(now.getTime() - SEEN_EVERY_MS).toISOString();
  if (row.last_seen_at === null || row.last_seen_at < stale)
    db.query("UPDATE session SET last_seen_at = ?1 WHERE token_hash = ?2").run(
      now.toISOString(),
      hash,
    quietly(db, () =>
      db.query("UPDATE session SET last_seen_at = ?1 WHERE token_hash = ?2").run(
        now.toISOString(),
        hash,
      ),
    );
  return ok({ user, id: row.id });
}
@@ -15,6 +15,7 @@
import type { Database } from "bun:sqlite";
import { withoutWaiting } from "../kernel/db.ts";
import { quietly } from "./write_clock.ts";
export const ROLES = ["anon", "user", "admin", "agent"] as const;
export const SURFACES = ["api", "mcp", "web"] as const;
@@ -125,14 +126,14 @@
export function createUsageCounter(
         DO UPDATE SET n = n + excluded.n`,
      );
      // Behind another process's lock this throws at once and the counts go back (#6957).
      withoutWaiting(db, db.transaction(() => {
      withoutWaiting(db, db.transaction(() => quietly(db, () => {
        for (const [key, n] of batch) {
          const [hour, pattern, method, status, role, surface] = key.split(
            SEP,
          ) as [string, string, string, string, string, string];
          upsert.run(hour, pattern, method, status, role, surface, n);
        }
      }));
      })));
    } catch (err) {
      // Put the counts back so a failed write loses nothing.
      for (const [key, n] of batch)
@@ -20,6 +20,13 @@
 * `limb_place` writes do not. A coarse clock costs hit rate; a wrong one
 * would cost a stale page. We pay the first.
 *
 * Telemetry is not a write the pages can show: route timings, usage counts,
 * flag reads, a session's last-seen time, page vitals, samples. They land
 * on this connection every second or so and would keep every cache cold
 * forever (#7896), so the writers that only record how the forge is used
 * run inside `quietly`, and the stamp does not count their rows. A page
 * that shows telemetry is bounded by its cache's age (30 s), not by the clock.
 *
 * Inside an open transaction there is no stamp: a rolled-back write leaves
 * `total_changes` where it went, so a value read mid-transaction could
 * outlive the rows it saw.
@@ -27,6 +34,25 @@
import type { Database } from "bun:sqlite";
      
        junipercrew
        12d ago
        
      
      Module-level WeakMap of quiet counts is unguarded: a loud write inside write() is silently subtracted. Add a test/guard (item 5).
    
const quiet = new WeakMap<Database, number>();
const changesOf = (db: Database): number =>
  db.query<{ n: number }, []>("SELECT total_changes() AS n").get()?.n ?? 0;
/**
 * Run a telemetry write: the rows it changes (kept or rolled back) are left
 * out of the stamp. Wrap only statements that touch tables no cached page
 * is built from; anything else written inside would go unseen by the caches.
 */
export function quietly<T>(db: Database, write: () => T): T {
  const before = changesOf(db);
  try {
    return write();
  } finally {
    quiet.set(db, (quiet.get(db) ?? 0) + changesOf(db) - before);
  }
}
/** The forge's write clock now, or undefined inside a transaction (cache nothing). */
export function writeStamp(db: Database): string | undefined {
  if (db.inTransaction) return undefined;
@@ -35,5 +61,5 @@
export function writeStamp(db: Database): string | undefined {
      "SELECT total_changes() AS n, (SELECT data_version FROM pragma_data_version) AS v",
    )
    .get();
  return row === null ? undefined : `${row.v}.${row.n}`;
  return row === null ? undefined : `${row.v}.${row.n - (quiet.get(db) ?? 0)}`;
}
@@ -81,12 +81,10 @@
export function breakerParked(
  // `at` is when the note was left: what a dismissal of the park is compared with.
  return db
    .query<{ issueId: string; repoId: string; at: string }, string[]>(
      `SELECT issueId, repoId, at FROM (
         SELECT i.id AS issueId, i.repo_id AS repoId, c.body AS body, c.created_at AS at,
                ROW_NUMBER() OVER (PARTITION BY i.id ORDER BY c.created_at DESC, c.id DESC) AS rn
         FROM issue i JOIN comment c ON c.issue_id = i.id
         WHERE i.state = 'open' AND i.repo_id IN (${marks})
       ) WHERE rn = 1 AND body IN (?${repoIds.length + 1}, ?${repoIds.length + 2})`,
      `SELECT i.id AS issueId, i.repo_id AS repoId, c.created_at AS at
         FROM issue i JOIN comment c ON c.id = (SELECT id FROM comment WHERE issue_id = i.id
                                                ORDER BY created_at DESC, id DESC LIMIT 1)
         WHERE i.state = 'open' AND i.repo_id IN (${marks}) AND c.body IN (?${repoIds.length + 1}, ?${repoIds.length + 2})`,
    )
    .all(...repoIds, ...WAITING_NOTES);
}
@@ -99,11 +99,13 @@
function waitingTally(db: Database, sql: string, ...args: string[]): Tally {
  return { waiting: r?.n ?? 0, active: 0, oldest: r?.oldest ?? null };
}
// CROSS JOIN keeps SQLite's order: the ask's runs, their branch's pulls by
// `pull_head_branch`, then each pull's issue, never every open issue (#3693).
// CROSS JOIN keeps SQLite's order: the repositories that run themselves, then
// their open issues by `issue_repo_kind_state_number`, never every issue
// (#7896); and the ask's runs, their branch's pulls by `pull_head_branch`,
// then each pull's issue, never every open issue (#3693).
const READY = `
  SELECT i.created_at AS since
    FROM issue i JOIN repo r ON r.id = i.repo_id
    FROM repo r CROSS JOIN issue i ON i.repo_id = r.id
   WHERE i.kind = 'issue' AND i.state = 'open' AND r.autonomy != 'off'
     AND (r.direction_issue_id IS NULL OR r.direction_issue_id != i.id)
     AND NOT EXISTS (SELECT 1 FROM issue_dependency d JOIN issue b ON b.id = d.blocked_by_id
@@ -71,7 +71,7 @@
export function readVitals(db: Database, now = new Date(), publicOnly = false):
    .query<Omit<Vitals, "conflicted" | "red" | "queued" | "oldestApprovedHours" | "strandedUsd" | "gateMinutes1h" | "pullCheckMinutes1h" | "batches6h" | "redBatchRate">, [string, string, string, number]>(
      `SELECT
         (SELECT COUNT(*) FROM pull p JOIN issue i ON i.id = p.issue_id JOIN repo r ON r.id = i.repo_id
           WHERE (?4 = 0 OR r.visibility = 'public') AND i.state = 'open' AND p.merged_at IS NULL) AS open,
           WHERE (?4 = 0 OR r.visibility = 'public') AND i.kind = 'pull' AND i.state = 'open' AND p.merged_at IS NULL) AS open,
      
        junipercrew
        12d ago
        
      
      Query semantics change (kind = 'pull') with no test (item 3).
    
         (SELECT COUNT(*) FROM pull p JOIN issue i ON i.id = p.issue_id JOIN repo r ON r.id = i.repo_id
           WHERE (?4 = 0 OR r.visibility = 'public') AND i.created_at >= ?1 AND i.created_at <= ?3) AS opened1h,
         (SELECT COUNT(*) FROM pull p JOIN issue i ON i.id = p.issue_id JOIN repo r ON r.id = i.repo_id
@@ -13,6 +13,7 @@
 */
import type { Database } from "bun:sqlite";
import { quietly } from "../core/write_clock.ts";
import { sha256 } from "../kernel/hash.ts";
/** A report is a few dozen bytes; this is already generous. */
@@ -99,9 +100,11 @@
export function saltFor(db: Database, at: number): string {
  const salt = new Bun.CryptoHasher("sha256")
    .update(crypto.getRandomValues(new Uint8Array(32)))
    .digest("hex");
  db.run("DELETE FROM vital_salt WHERE day <> ?", [day]);
  db.run("INSERT OR IGNORE INTO vital_salt (day, salt) VALUES (?, ?)", [day, salt]);
  db.run("DELETE FROM page_vital WHERE at < ?", [at - KEEP_MS]);
  quietly(db, () => {
    db.run("DELETE FROM vital_salt WHERE day <> ?", [day]);
    db.run("INSERT OR IGNORE INTO vital_salt (day, salt) VALUES (?, ?)", [day, salt]);
    db.run("DELETE FROM page_vital WHERE at < ?", [at - KEEP_MS]);
  });
  return (
    db
      .query<{ salt: string }, [string]>("SELECT salt FROM vital_salt WHERE day = ?")
@@ -127,9 +130,11 @@
export function recordVital(
    .get(dayOf(at));
  if ((held?.n ?? 0) >= dayMax) return false;
  const visitor = sha256(`${saltFor(db, at)}\0${client}\0${agent}`).slice(0, 32);
  db.run(
    "INSERT INTO page_vital (day, at, route, visitor, ttfb, load, lcp, inp, cls) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
    [dayOf(at), at, route, visitor, report.ttfb, report.load, report.lcp, report.inp, report.cls],
  quietly(db, () =>
    db.run(
      "INSERT INTO page_vital (day, at, route, visitor, ttfb, load, lcp, inp, cls) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
      [dayOf(at), at, route, visitor, report.ttfb, report.load, report.lcp, report.inp, report.cls],
    ),
  );
  return true;
}
@@ -0,0 +1,97 @@
/**
 * The three queries #7896 rewrote for the indexes answer what the ones they
 * replaced did, on rows built to tell them apart: a note that parks an issue,
 * one that is not the newest, an open issue that is not a pull.
 */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { breakerParked, WAITING_NOTES } from "../src/crew/breaker.ts";
import { readPipeline } from "../src/flow/pipeline.ts";
import { readVitals } from "../src/flow/vitals.ts";
import { id } from "../src/kernel/id.ts";
import { snappyFixture, type SnappyFixture } from "../bench/snappy.ts";
let f: SnappyFixture;
let repoId: string;
beforeAll(async () => {
  f = await snappyFixture({ repos: 2, issuesPerRepo: 3 });
  repoId = f.app.db.query<{ id: string }, []>("SELECT id FROM repo LIMIT 1").get()!.id;
}, 60_000);
afterAll(async () => {
  await f.close();
});
const issue = (kind: string, state: string, n: number): string => {
  const i = id();
  f.app.db
    .query("INSERT INTO issue (id, repo_id, number, kind, title, body, author_id, state, created_at) VALUES (?1, ?2, ?3, ?4, 't', '', ?5, ?6, ?7)")
    .run(i, repoId, n, kind, f.owner.id, state, new Date().toISOString());
  return i;
};
const note = (issueId: string, body: string, at: string) =>
  f.app.db
    .query("INSERT INTO comment (id, issue_id, author_id, body, created_at) VALUES (?1, ?2, ?3, ?4, ?5)")
    .run(id(), issueId, f.owner.id, body, at);
test("breakerParked: parked by its newest note only, open only", () => {
  const parked = issue("issue", "open", 9001);
  note(parked, "hello", "2026-01-01T00:00:00.000Z");
  note(parked, WAITING_NOTES[0], "2026-01-02T00:00:00.000Z");
  const spoken = issue("issue", "open", 9002);
  note(spoken, WAITING_NOTES[0], "2026-01-01T00:00:00.000Z");
  note(spoken, "a person spoke", "2026-01-02T00:00:00.000Z");
  const closed = issue("issue", "closed", 9003);
  note(closed, WAITING_NOTES[1], "2026-01-01T00:00:00.000Z");
  const old = f.app.db
    .query<{ issueId: string; repoId: string; at: string }, string[]>(
      `SELECT issueId, repoId, at FROM (
         SELECT i.id AS issueId, i.repo_id AS repoId, c.body AS body, c.created_at AS at,
                ROW_NUMBER() OVER (PARTITION BY i.id ORDER BY c.created_at DESC, c.id DESC) AS rn
         FROM issue i JOIN comment c ON c.issue_id = i.id
         WHERE i.state = 'open' AND i.repo_id IN (?1)
       ) WHERE rn = 1 AND body IN (?2, ?3)`,
    )
    .all(repoId, ...WAITING_NOTES);
  const now = breakerParked(f.app.db, [repoId]);
  expect(now).toEqual(old);
  expect(now.map((r) => r.issueId)).toEqual([parked]);
});
test("open pulls: an open issue that is not a pull is not counted, as before", () => {
  const db = f.app.db;
  const count = () => readVitals(db).open;
  const before = count();
  issue("issue", "open", 9101);
  expect(count()).toBe(before);
  const pull = issue("pull", "open", 9102);
  db.query("INSERT INTO pull (issue_id, base_branch, head_branch, base_oid, head_oid, head_repo_id) VALUES (?1, 'main', 'b', '', '', ?2)").run(pull, repoId);
  expect(count()).toBe(before + 1);
  const old = db
    .query<{ n: number }, []>(
      `SELECT COUNT(*) AS n FROM pull p JOIN issue i ON i.id = p.issue_id JOIN repo r ON r.id = i.repo_id
        WHERE i.state = 'open' AND p.merged_at IS NULL`,
    )
    .get()!.n;
  expect(count()).toBe(old);
});
test("ready asks: the tally is the old join's, counted by hand", () => {
  const db = f.app.db;
  db.query("UPDATE repo SET autonomy = 'on'").run();
  const ready = () => readPipeline(db).find((s) => s.key === "ready")!.waiting;
  const old = db
    .query<{ n: number }, []>(
      `SELECT COUNT(*) AS n FROM issue i JOIN repo r ON r.id = i.repo_id
        WHERE i.kind = 'issue' AND i.state = 'open' AND r.autonomy != 'off'
          AND (r.direction_issue_id IS NULL OR r.direction_issue_id != i.id)
          AND NOT EXISTS (SELECT 1 FROM issue_dependency d JOIN issue b ON b.id = d.blocked_by_id
                           WHERE d.issue_id = i.id AND b.state = 'open')
          AND NOT EXISTS (SELECT 1 FROM run x WHERE x.issue_id = i.id AND x.kind = 'agent'
                           AND x.state IN ('queued','running'))`,
    )
    .get()!.n;
  expect(old).toBeGreaterThan(0);
  expect(ready()).toBe(old);
  db.query("UPDATE repo SET autonomy = 'off'").run();
  expect(ready()).toBe(0);
});
@@ -0,0 +1,135 @@
/**
 * Telemetry does not keep the caches cold (#7896): the rows a route timing,
 * a usage count, a flag read, a session's last-seen time, a home visit or a
 * page vital writes are left out of the write clock, while any other write
 * still moves it. And so a home read after a second of traffic is a hit.
 */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { Database } from "bun:sqlite";
import { createUsageCounter } from "../src/core/usage_count.ts";
import { makeFlags } from "../src/core/flags.ts";
import { sessionOf, createSession } from "../src/core/sessions.ts";
import { recordMemory } from "../src/boards/memory.ts";
import { record as recordRing } from "../src/boards/ring.ts";
import { createRouteTiming } from "../src/core/route_timing.ts";
import { noteVisit } from "../src/core/home_visit.ts";
import { quietly, writeStamp } from "../src/core/write_clock.ts";
import { recordVital } from "../src/web/measure.ts";
import { kpiCache } from "../src/web/studio/home_cache.ts";
import { snappyFixture, type SnappyFixture } from "../bench/snappy.ts";
test("a quiet write leaves the stamp; a loud one moves it", () => {
  const db = new Database(":memory:");
  db.run("CREATE TABLE t (n INTEGER)");
  const before = writeStamp(db);
  quietly(db, () => db.run("INSERT INTO t VALUES (1)"));
  expect(writeStamp(db)).toBe(before);
  db.run("INSERT INTO t VALUES (2)");
  expect(writeStamp(db)).not.toBe(before);
});
test("a quiet write that rolls back is still left out", () => {
  const db = new Database(":memory:");
  db.run("CREATE TABLE t (n INTEGER)");
  const before = writeStamp(db);
  expect(() =>
    db.transaction(() => {
      quietly(db, () => db.run("INSERT INTO t VALUES (1)"));
      throw new Error("no");
    })(),
  ).toThrow();
  expect(writeStamp(db)).toBe(before);
});
let f: SnappyFixture;
beforeAll(async () => {
  f = await snappyFixture({ repos: 2, issuesPerRepo: 2 });
}, 60_000);
afterAll(async () => {
  await f.close();
});
/** Every row of every table, so a writer's footprint can be named. */
function dump(db: Database): Map<string, string> {
  const out = new Map<string, string>();
  const names = db
    .query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
    .all();
  for (const { name } of names) out.set(name, JSON.stringify(db.query(`SELECT * FROM "${name}"`).all()));
  return out;
}
/** The tables no cached page is built from: the only ones a quiet writer may touch. */
const TELEMETRY = new Set([
      
        junipercrew
        12d ago
        outdated
      
      Sleeping 1.3 s makes the test slow and timing-dependent; flush the timings directly instead (item 4).
    
  "route_timing", "usage_count", "flag_use", "session", "home_visit",
  "page_vital", "vital_salt", "memory_hour", "machine_sample",
]);
const flags = makeFlags({ probe: { why: "test", default: false, issue: 7896 } });
const writers: Record<string, () => void> = {
  "route timing": () => {
    const t = createRouteTiming(f.app.db);
    t.record("GET /probe", 3);
    t.flush();
    t.stop();
  },
  "usage count": () => {
    const c = createUsageCounter(f.app.db);
    c.count({ pattern: "GET /probe", method: "GET", status: 200, role: "anon", surface: "web" });
    c.flush();
    c.stop();
  },
  "flag read": () => {
    flags.flag("probe");
    flags.flush(f.app.db);
  },
  "session last-seen": () => {
    const { token } = createSession(f.app.db, f.owner.id);
    f.app.db.query("UPDATE session SET last_seen_at = NULL").run();
    stampBase = writeStamp(f.app.db);
    expect(sessionOf(f.app.db, token).ok).toBe(true);
  },
  "home visit": () => void noteVisit(f.app.db, f.owner.id, Date.now() + 3_600_000),
  "page vital": () => void recordVital(f.app.db, { path: "/", ttfb: 1, load: 2, lcp: 3, inp: 4, cls: 0 }, "/", "client", "agent"),
  "memory sample": () => recordMemory(f.app.db, 1e8, 5e7, Date.now()),
  "machine sample": () =>
    recordRing(f.app.db, [{ at: Date.now(), target: "forge", cpuCores: 1, memoryBytes: 1e8, load: 0.5 }], Date.now()),
};
let stampBase: string | undefined;
for (const [name, write] of Object.entries(writers))
  test(`the ${name} write leaves the clock, and touches only telemetry tables`, () => {
    const db = f.app.db;
    stampBase = writeStamp(db);
    const before = dump(db);
    write();
    const after = dump(db);
    const touched = [...after].filter(([t, rows]) => before.get(t) !== rows).map(([t]) => t);
    expect(touched.length).toBeGreaterThan(0);
    for (const t of touched) expect(TELEMETRY.has(t)).toBe(true);
    expect(writeStamp(db)).toBe(stampBase);
  });
test("a loud write still moves the clock", () => {
  const db = f.app.db;
  const before = writeStamp(db);
  db.query("INSERT INTO forge_setting (key, value, updated_by, updated_at) VALUES ('probe', '1', ?1, 'x')").run(f.owner.id);
  expect(writeStamp(db)).not.toBe(before);
});
test("a home read after telemetry flushed is a cache hit", async () => {
  await fetch(`${f.base}/`, { headers: { cookie: f.ownerCookie } }).then((r) => r.text());
  const kpi = kpiCache(f.app.db);
  const misses = kpi.misses;
  writers["route timing"]!();
  writers["page vital"]!();
  await fetch(`${f.base}/`, { headers: { cookie: f.ownerCookie } }).then((r) => r.text());
  expect(kpi.misses).toBe(misses);
});
test("the home's since-your-last-visit is read outside every cache", async () => {
  const src = await Bun.file(new URL("../src/web/studio/home_cache.ts", import.meta.url)).text();
  expect(src).not.toContain("home_visit");
  expect(src).not.toContain("lastVisit");
});
		@@ -291,6 +291,17 @@ fixture; all three caches hit):
291	291	The anonymous door (1.5 ms, 10 statements), the app shelf, and the
292	292	"On you" card. Each costs less than its cache's key would.
293	293
	294	## Telemetry does not invalidate (#7896)
	295
	296	The write clock counts every row the connection changes, and a signed-in
	297	visit itself writes: route timings a second after the request, usage
	298	counts, flag reads, the session's last-seen time, the home visit, page
	299	vitals, machine and memory samples. Counted, they kept every cache cold
	300	for the next visitor. These writers run inside `quietly` (`core/write_clock.ts`),
	301	which leaves their rows out of the stamp. Wrap only a write to a table no
	302	cached page is built from; a page that shows telemetry is bounded by the
	303	30 seconds a cache entry lives. `test/write-clock-quiet.test.ts` proves it.
	304
294	305	## The writes that invalidate
295	306
296	307	Each row is an action (or, for a push, the post-receive hook, the one
		@@ -8,6 +8,7 @@
8	8	import type { Database } from "bun:sqlite";
9	9	import { heapStats } from "bun:jsc";
10	10	import type { App } from "../app.ts";
	11	import { quietly } from "../core/write_clock.ts";
11	12
12	13	export const MEMORY_EVERY_MS = 60_000;
13	14	export const HOUR_MS = 3_600_000;
		@@ -29,7 +30,7 @@ const valid = (n: number) => Number.isFinite(n) && n >= 0;
29	30	export function recordMemory(db: Database, rss: number, heap: number, now: number): void {
30	31	if (!valid(rss) \|\| !valid(heap) \|\| !valid(now)) return;
31	32	const hour = Math.floor(now / HOUR_MS) * HOUR_MS;
32		db.transaction(() => {
	33	db.transaction(() => quietly(db, () => {
33	34	db.run(
34	35	`INSERT INTO memory_hour (hour, samples, rss_sum, rss_max, heap_sum, heap_max) VALUES (?, 1, ?, ?, ?, ?)
35	36	ON CONFLICT(hour) DO UPDATE SET samples = samples + 1, rss_sum = rss_sum + excluded.rss_sum,
		@@ -38,7 +39,7 @@ export function recordMemory(db: Database, rss: number, heap: number, now: numbe
38	39	[hour, rss, rss, heap, heap],
39	40	);
40	41	db.run("DELETE FROM memory_hour WHERE hour < ?", [hour - KEEP_MS]);
41		})();
	42	}))();
42	43	}
43	44
44	45	/** The hours in the `hours` before `now` (the current one included), oldest first. */
		@@ -7,6 +7,7 @@
7	7	*/
8	8	import type { Database } from "bun:sqlite";
9	9	import { withoutWaiting } from "../kernel/db.ts";
	10	import { quietly } from "../core/write_clock.ts";
10	11
11	12	export const FINE_MS = 15_000;
12	13	export const COARSE_MS = 300_000;
		@@ -104,7 +105,7 @@ export function record(db: Database, points: readonly Point[], now: number): voi
104	105	lag_ms, lag_ms_max, checks, agents)
105	106	VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
106	107	);
107		withoutWaiting(db, db.transaction(() => {
	108	withoutWaiting(db, db.transaction(() => quietly(db, () => {
108	109	for (const p of points) {
109	110	const c = p.celsius ?? null;
110	111	const lag = p.lagMs ?? null;
		@@ -137,5 +138,5 @@ export function record(db: Database, points: readonly Point[], now: number): voi
137	138	}
138	139	db.query("DELETE FROM machine_sample WHERE step = 15 AND at < ?").run(iso(now - FINE_KEEP_MS));
139	140	db.query("DELETE FROM machine_sample WHERE step = 300 AND at < ?").run(iso(now - COARSE_KEEP_MS));
140		}));
	141	})));
141	142	}
		@@ -17,6 +17,7 @@
17	17	*/
18	18
19	19	import type { Database } from "bun:sqlite";
	20	import { quietly } from "./write_clock.ts";
20	21
21	22	export type FlagDecl = {
22	23	/** One line: what the flag switches and why it exists. */
		@@ -274,12 +275,12 @@ export function makeFlags<const D extends Record<string, FlagDecl>>(decls: D) {
274	275	`INSERT INTO flag_use (day, flag, variant, n) VALUES (?1, ?2, ?3, ?4)
275	276	ON CONFLICT (day, flag, variant) DO UPDATE SET n = n + excluded.n`,
276	277	);
277		db.transaction(() => {
	278	db.transaction(() => quietly(db, () => {
278	279	for (const [key, n] of taken) {
279	280	const [day, flag, variant] = key.split("\t");
280	281	up.run(day!, flag!, Number(variant), n);
281	282	}
282		})();
	283	}))();
283	284	} catch {
284	285	for (const [key, n] of taken) pending.set(key, (pending.get(key) ?? 0) + n);
285	286	}
		@@ -5,6 +5,7 @@
5	5	*/
6	6
7	7	import type { Database } from "bun:sqlite";
	8	import { quietly } from "./write_clock.ts";
8	9
9	10	export const VISIT_WRITE_GAP_MS = 60 * 1000;
10	11
		@@ -16,9 +17,11 @@ export function lastVisit(db: Database, userId: string): number \| undefined {
16	17	export function noteVisit(db: Database, userId: string, now: number): number \| undefined {
17	18	const before = lastVisit(db, userId);
18	19	if (before === undefined \|\| now - before >= VISIT_WRITE_GAP_MS)
19		db.query(
20		"INSERT INTO home_visit (user_id, at) VALUES (?1, ?2) ON CONFLICT(user_id) DO UPDATE SET at = excluded.at",
21		).run(userId, now);
	20	quietly(db, () =>
	21	db
	22	.query("INSERT INTO home_visit (user_id, at) VALUES (?1, ?2) ON CONFLICT(user_id) DO UPDATE SET at = excluded.at")
	23	.run(userId, now),
	24	);
22	25	return before;
23	26	}
24	27
		@@ -0,0 +1,1 @@
	1	6f100057a211ae106d96d29d3e46bdd6afe425297b44c6206bf4135bdf42a434
		@@ -0,0 +1,12 @@
	1	// The home and a repository page read the whole issue table cold (#7896):
	2	// the open counts of every repository, the open pulls, the newest comment of
	3	// every open issue. Each now walks an index and not the table: the counts
	4	// are answered by `issue_counts` alone, open pulls by a partial index of
	5	// just them, a time window of pulls by `issue_created`, and an issue's
	6	// newest comment by its place in `comment_issue_at`. Additive.
	7	export default `
	8	CREATE INDEX issue_counts ON issue(repo_id, state, sealed, kind);
	9	CREATE INDEX issue_open_pull ON issue(repo_id) WHERE state = 'open' AND kind = 'pull';
	10	CREATE INDEX issue_created ON issue(created_at);
	11	CREATE INDEX comment_issue_at ON comment(issue_id, created_at, id);
	12	`;
		@@ -20,6 +20,7 @@
20	20
21	21	import type { Database } from "bun:sqlite";
22	22	import { withoutWaiting } from "../kernel/db.ts";
	23	import { quietly } from "./write_clock.ts";
23	24
24	25	/** Upper edges in ms; bucket `i` holds durations `<= EDGES_MS[i]`, the last is everything slower. */
25	26	export const EDGES_MS = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500] as const;
		@@ -129,7 +130,7 @@ export function createRouteTiming(
129	130	);
130	131	const hourNo = Math.floor(now() / HOUR_MS);
131	132	// Behind another process's lock this throws at once and the records go back (#6957).
132		withoutWaiting(db, db.transaction(() => {
	133	withoutWaiting(db, db.transaction(() => quietly(db, () => {
133	134	for (const [key, v] of batch) {
134	135	const [h, pattern, b] = key.split(SEP) as [string, string, string];
135	136	upsert.run(hourText(Number(h)), pattern, Number(b), v.n, v.us);
		@@ -140,7 +141,7 @@ export function createRouteTiming(
140	141	);
141	142	prunedHour = hourNo;
142	143	}
143		}));
	144	})));
144	145	} catch (err) {
145	146	prunedHour = -1;
146	147	for (const [key, v] of batch) {
		@@ -8,6 +8,7 @@ import { sha256 } from "../kernel/hash.ts";
8	8	import { id as newId, secret } from "../kernel/id.ts";
9	9	import { err, ok, type Result } from "../kernel/result.ts";
10	10	import { getUserById, isActive, type User } from "./users.ts";
	11	import { quietly } from "./write_clock.ts";
11	12
12	13	const SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
13	14	/** How stale a session's last-seen time may get before a request moves it. */
		@@ -70,9 +71,11 @@ export function sessionOf(
70	71	// At most one write a minute per browser, however busy it is.
71	72	const stale = new Date(now.getTime() - SEEN_EVERY_MS).toISOString();
72	73	if (row.last_seen_at === null \|\| row.last_seen_at < stale)
73		db.query("UPDATE session SET last_seen_at = ?1 WHERE token_hash = ?2").run(
74		now.toISOString(),
75		hash,
	74	quietly(db, () =>
	75	db.query("UPDATE session SET last_seen_at = ?1 WHERE token_hash = ?2").run(
	76	now.toISOString(),
	77	hash,
	78	),
76	79	);
77	80	return ok({ user, id: row.id });
78	81	}
		@@ -15,6 +15,7 @@
15	15
16	16	import type { Database } from "bun:sqlite";
17	17	import { withoutWaiting } from "../kernel/db.ts";
	18	import { quietly } from "./write_clock.ts";
18	19
19	20	export const ROLES = ["anon", "user", "admin", "agent"] as const;
20	21	export const SURFACES = ["api", "mcp", "web"] as const;
		@@ -125,14 +126,14 @@ export function createUsageCounter(
125	126	DO UPDATE SET n = n + excluded.n`,
126	127	);
127	128	// Behind another process's lock this throws at once and the counts go back (#6957).
128		withoutWaiting(db, db.transaction(() => {
	129	withoutWaiting(db, db.transaction(() => quietly(db, () => {
129	130	for (const [key, n] of batch) {
130	131	const [hour, pattern, method, status, role, surface] = key.split(
131	132	SEP,
132	133	) as [string, string, string, string, string, string];
133	134	upsert.run(hour, pattern, method, status, role, surface, n);
134	135	}
135		}));
	136	})));
136	137	} catch (err) {
137	138	// Put the counts back so a failed write loses nothing.
138	139	for (const [key, n] of batch)