database-load.js

database-load.jstests/performance/database-load.jsraw ← performance11,435 B← Back to the app
1/**
2 * AI Software Factory — database load suite (TASK-0135).
3 *
4 * Targets the seeded 100k-record database (`seed-100k.mjs`, marker `databaseId`).
5 * Four scenarios (the spec's k6 matrix):
6 *
7 *   - table-first    50 VUs, 2 min — POST /databases/:id/query first page
8 *                   (pageSize 50, no cursor) — the "fresh cache" table load.
9 *   - table-scroll   100 VUs, 2 min — POST /databases/:id/query pages 2..50
10 *                   (each carries the cursor from the prior page — a real
11 *                   scroll). The cursor chain is precomputed in setup so a
12 *                   scroll request is a single round-trip.
13 *   - record-open    50 VUs, 1 min — GET /records/:id (record → its pageId)
14 *                   then GET /pages/:pageId/blocks (the record-open path the
15 *                   acceptance criteria bound to ≤ 4 queries).
16 *   - record-create  100 rps, 2 min — POST /databases/:id/records, sustained.
17 *
18 * Thresholds (staging-hard):
19 *   table (first+scroll) p95 < 500 ms; record-open p95 < 500 ms;
20 *   creates p95 < 500 ms AND ≥ 100 rps sustained with no > 5 s stall
21 *   (a create slower than 5 s is counted as a stall); error rate < 0.1%.
22 *   p99 is reported (not blocking — this k6 build rejects the `warn:` soft-
23 *   threshold prefix; p99 is surfaced via the summary trend stats).
24 *
25 * Report-only vs hard: K6_STRICT=1 (default, staging) → hard (k6 exit 99 on
26 * breach); K6_STRICT=0 (local + dev/PR) → trivially-true thresholds (the run
27 * still prints real p95/p99/error for the PR artifact).
28 *
29 * Endpoints verified live:
30 *   - table view reads through POST /databases/:id/query ({pageSize,cursor})
31 *     → {data:{records,totalCount,nextCursor}} (the web's real path, TASK-0124).
32 *   - record-open: GET /records/:id → {…pageId, properties} then
33 *     GET /pages/:pageId/blocks.
34 *
35 * Env:
36 *   K6_API_URL        API base (default http://localhost:4000)
37 *   K6_EMAIL / K6_PASSWORD  perf user (demo@factory.local / Factory!2345)
38 *   K6_WORKSPACE_ID   seeded workspace (for resolve fallback)
39 *   K6_DB_ID          seeded 100k database id (required — marker databaseId)
40 *   K6_STRICT         "1" hard (default) / "0" report-only
41 *
42 * Run (full):  pnpm --dir tests/performance database-load
43 * Run (smoke): K6_PROFILE=smoke pnpm --dir tests/performance database-load
44 */
45import http from "k6/http";
46import { check } from "k6";
47import { Trend, Rate } from "k6/metrics";
48 
49const tableFirstMs = new Trend("table_first_ms", true);
50const tableScrollMs = new Trend("table_scroll_ms", true);
51const recordOpenMs = new Trend("record_open_ms", true);
52const recordCreateMs = new Trend("record_create_ms", true);
53const createStall = new Rate("create_stall_rate"); // a create slower than 5 s
54 
55const API = __ENV.K6_API_URL || "http://localhost:4000";
56const EMAIL = __ENV.K6_EMAIL || "demo@factory.local";
57const PASSWORD = __ENV.K6_PASSWORD || "Factory!2345";
58const STRICT = (__ENV.K6_STRICT || "1") !== "0";
59const SMOKE = __ENV.K6_PROFILE === "smoke";
60const DB_ID = __ENV.K6_DB_ID || "";
61 
62// Durations (seconds). Full: table 2m, create 2m, record-open 1m.
63// Smoke: 30 s — long enough for a full iteration to land on a slow dev API
64// (dev requests can take seconds; a 6 s window interrupted every iteration
65// before the Trend.add() call, leaving the summary with no samples).
66const TABLE_SECS = SMOKE ? 60 : 120;
67const CREATE_SECS = SMOKE ? 60 : 120;
68const OPEN_SECS = SMOKE ? 60 : 60;
69// Smoke: minimal concurrency (1 VU / 1 rps) — on a loaded shared dev machine
70// requests queue and balloon (15 s+ under contention), which drops iterations;
71// a smoke's job is to prove the execs + endpoints work, not to load. The real
72// load only makes sense on a dedicated staging instance (full profile).
73const CREATE_RPS = SMOKE ? 1 : 100;
74const TABLE_FIRST_VUS = SMOKE ? 1 : 50;
75const TABLE_SCROLL_VUS = SMOKE ? 1 : 100;
76const OPEN_VUS = SMOKE ? 1 : 50;
77 
78const PAGE_SIZE = 50;
79// The table-scroll chain (pages 2..N). Full: 50 (the spec's pages 2..50).
80// Smoke: 2 pages (1 scroll cursor) — a long setup chain alone can eat the
81// scenario window on a loaded dev machine (each query can take several
82// seconds under contention). The full profile builds all 50.
83const CHAIN_PAGES = SMOKE ? 2 : 50;
84 
85// ---- per-VU auth + cursor-chain/record pool --------------------------------
86// k6's `setup()` return (`__DATA`) is only reachable from `default()` /
87// `teardown()`, NOT from scenario execs — so each VU resolves its own token +
88// precomputed cursor chain + record pool on first use and caches it in a
89// top-level `let` (k6 scopes top-level state per VU). The chain-building
90// queries are NOT added to any Trend, so they do not pollute the measured
91// table-scroll / record-open latencies. `setup()` still does a one-time
92// host-side validation (fail-fast) — its return is not consumed by the execs.
93let _DATA = null;
94function data() {
95  if (!_DATA) _DATA = resolveData();
96  return _DATA;
97}
98function resolveData() {
99  let res = http.post(`${API}/api/v1/auth/login`, JSON.stringify({ email: EMAIL, password: PASSWORD }), {
100    headers: { "Content-Type": "application/json" },
101  });
102  if (res.status !== 200) {
103    res = http.post(`${API}/api/v1/auth/register`, JSON.stringify({ email: EMAIL, password: PASSWORD, name: "Perf DbLoad" }), {
104      headers: { "Content-Type": "application/json" },
105    });
106    res = http.post(`${API}/api/v1/auth/login`, JSON.stringify({ email: EMAIL, password: PASSWORD }), {
107      headers: { "Content-Type": "application/json" },
108    });
109  }
110  if (res.status !== 200) throw new Error(`auth failed: ${res.status} ${res.body.slice(0, 200)}`);
111  const body = res.json();
112  const token = body.accessToken || body.access_token || body.token;
113  if (!token) throw new Error(`no token in auth response`);
114  if (!DB_ID) throw new Error("K6_DB_ID is empty — run seed-100k.mjs and export its databaseId.");
115 
116  const H = { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
117 
118  // Precompute the cursor chain for pages 1..CHAIN_PAGES (table-scroll) +
119  // collect a pool of record ids (record-open). One cursor hop per page.
120  const cursorChain = []; // index 0 = page 1 (null cursor), i = page i+1
121  const recordIds = [];
122  let cursor = null;
123  for (let page = 1; page <= CHAIN_PAGES; page++) {
124    const q = { pageSize: PAGE_SIZE };
125    if (cursor !== null) q.cursor = cursor;
126    const r = http.post(`${API}/api/v1/databases/${DB_ID}/query`, JSON.stringify(q), { headers: H });
127    if (r.status !== 200) throw new Error(`query setup page ${page} failed: ${r.status}`);
128    const data = r.json().data || {};
129    const records = data.records || [];
130    if (records.length === 0) break;
131    cursorChain.push(cursor);
132    for (const rec of records) if (rec.id) recordIds.push(rec.id);
133    cursor = data.nextCursor ?? null;
134    if (cursor === null) break;
135  }
136  if (recordIds.length === 0) throw new Error("no records found in the seeded DB — is K6_DB_ID correct?");
137  return { token, cursorChain, recordIds };
138}
139export function setup() {
140  // One-time host-side validation (fail-fast): login works, K6_DB_ID is set,
141  // and the DB has records. Its return is not used by the execs (see the
142  // per-VU data() note above) — it only surfaces a misconfiguration early.
143  resolveData();
144  return { ok: true };
145}
146 
147function H(token) {
148  return { "Content-Type": "application/json", Authorization: `Bearer ${token}` };
149}
150 
151export function tableFirst() {
152  const res = http.post(`${API}/api/v1/databases/${DB_ID}/query`, JSON.stringify({ pageSize: PAGE_SIZE }), {
153    headers: H(data().token),
154  });
155  tableFirstMs.add(res.timings.duration);
156  check(res, {
157    "[db] table-first 2xx": (r) => r.status >= 200 && r.status < 300,
158    "[db] table-first has records": (r) => (r.json().data?.records || []).length > 0,
159  });
160}
161 
162export function tableScroll() {
163  const d = data();
164  // Pick a page 2..CHAIN_PAGES (the chain stores the cursor that FETCHES page i+1).
165  const idx = 1 + Math.floor(Math.random() * Math.max(1, d.cursorChain.length - 1));
166  const cursor = d.cursorChain[Math.min(idx, d.cursorChain.length - 1)];
167  const q = { pageSize: PAGE_SIZE };
168  if (cursor !== null && cursor !== undefined) q.cursor = cursor;
169  const res = http.post(`${API}/api/v1/databases/${DB_ID}/query`, JSON.stringify(q), {
170    headers: H(d.token),
171  });
172  tableScrollMs.add(res.timings.duration);
173  check(res, {
174    "[db] table-scroll 2xx": (r) => r.status >= 200 && r.status < 300,
175    "[db] table-scroll has records": (r) => (r.json().data?.records || []).length > 0,
176  });
177}
178 
179export function recordOpen() {
180  const t0 = Date.now();
181  const d = data();
182  const rid = d.recordIds[Math.floor(Math.random() * d.recordIds.length)];
183  const rec = http.get(`${API}/api/v1/records/${rid}`, { headers: H(d.token) });
184  if (rec.status >= 200 && rec.status < 300) {
185    const pageId = rec.json().pageId;
186    if (pageId) {
187      const blocks = http.get(`${API}/api/v1/pages/${pageId}/blocks`, { headers: H(d.token) });
188      check(blocks, { "[db] record-open blocks 2xx": (r) => r.status >= 200 && r.status < 300 });
189    }
190  }
191  recordOpenMs.add(Date.now() - t0);
192  check(rec, { "[db] record-open 2xx": (r) => r.status >= 200 && r.status < 300 });
193}
194 
195export function recordCreate() {
196  const res = http.post(
197    `${API}/api/v1/databases/${DB_ID}/records`,
198    JSON.stringify({ title: `Perf DbLoad ${__VU}-${__ITER}` }),
199    { headers: H(data().token) }
200  );
201  recordCreateMs.add(res.timings.duration);
202  if (res.timings.duration > 5000) createStall.add(true);
203  else createStall.add(false);
204  check(res, { "[db] record-create 2xx": (r) => r.status >= 200 && r.status < 300 });
205}
206 
207const HARD_THRESHOLDS = {
208  table_first_ms: ["p(95)<500"],
209  table_scroll_ms: ["p(95)<500"],
210  record_open_ms: ["p(95)<500"],
211  record_create_ms: ["p(95)<500"],
212  // A create slower than 5 s = a stall; allow ~0 (≤ 0.1% of creates).
213  create_stall_rate: ["rate<0.001"],
214  http_req_failed: ["rate<0.001"],
215};
216const SOFT_THRESHOLDS = {
217  table_first_ms: ["avg<1e15"],
218  table_scroll_ms: ["avg<1e15"],
219  record_open_ms: ["avg<1e15"],
220  record_create_ms: ["avg<1e15"],
221  // `rate<=1` (not `<1`): k6 Rate thresholds are a FRACTION, so a true 100%
222  // rate (e.g. every create stalls on a dead DB) is exactly 1.0 and would
223  // red the report-only tier under `rate<1`. `<=` keeps it green.
224  create_stall_rate: ["rate<=1"],
225  http_req_failed: ["rate<=1"],
226};
227 
228export const options = {
229  scenarios: {
230    "table-first": {
231      executor: "constant-vus",
232      startTime: "0s",
233      duration: `${TABLE_SECS}s`,
234      vus: TABLE_FIRST_VUS,
235      exec: "tableFirst",
236    },
237    "table-scroll": {
238      executor: "constant-vus",
239      startTime: "0s",
240      duration: `${TABLE_SECS}s`,
241      vus: TABLE_SCROLL_VUS,
242      exec: "tableScroll",
243    },
244    "record-open": {
245      executor: "constant-vus",
246      startTime: "0s",
247      duration: `${OPEN_SECS}s`,
248      vus: OPEN_VUS,
249      exec: "recordOpen",
250    },
251    // Sustained 100 rps of creates (the spec's create-rate floor).
252    "record-create": {
253      executor: "constant-arrival-rate",
254      startTime: "0s",
255      duration: `${CREATE_SECS}s`,
256      preAllocatedVUs: SMOKE ? 5 : 50,
257      maxVUs: SMOKE ? 20 : 200,
258      rate: CREATE_RPS,
259      exec: "recordCreate",
260    },
261  },
262  thresholds: STRICT ? HARD_THRESHOLDS : SOFT_THRESHOLDS,
263  summaryTrendStats: ["avg", "min", "med", "p(90)", "p(95)", "p(99)", "max"],
264};
265