Files
mytodos/load-tests/app.js
T

528 lines
16 KiB
JavaScript
Raw Normal View History

2026-10-15 20:59:32 -07:00
/**
* Throughput and concurrency load tests for mytodos.
*
* The application is entirely Blade + Livewire with no API surface, so the
* dominant real-world cost is the POST to Livewire's update endpoint rather
* than the page GET that precedes it. Any test that only loads pages
* understates load by roughly an order of magnitude, because a single page view
* is normally followed by a burst of update round-trips: search is bound to a
* 300ms debounce, folders render on expand, and toggles each commit.
*
* Snapshots are captured from real pages and replayed. They cannot be
* synthesised, because Livewire signs every snapshot with
* hash_hmac('sha256', json_encode($snapshot), APP_KEY). A generator that
* invents snapshots is also self-defeating: the checksum guard locks out an IP
* after ten bad payloads in ten minutes, which would invalidate the whole run.
*
* Run one scenario at a time so the numbers stay attributable:
*
* SCENARIOS=page_load VUS=25 DURATION=2m k6 run load-tests/app.js
*
* Then step VUS upward until the p95 breaches the SLO. The driver script
* load-tests/ramp.sh does that sweep and collects the results.
*/
import http from 'k6/http';
import exec from 'k6/execution';
import { check } from 'k6';
import { Counter, Rate, Trend } from 'k6/metrics';
const BASE_URL = (__ENV.BASE_URL || 'http://mytodos.test').replace(/\/$/, '');
const VUS = parseInt(__ENV.VUS || '25', 10);
const DURATION = __ENV.DURATION || '2m';
const LABEL = __ENV.LABEL || `vus-${VUS}`;
const ALL_SCENARIOS = [
'anon',
'page_load',
'livewire_read',
'livewire_write',
'folders_read',
'folders_write',
'admin',
];
const ENABLED = (__ENV.SCENARIOS || ALL_SCENARIOS.join(','))
.split(',')
.map((name) => name.trim())
.filter((name) => ALL_SCENARIOS.indexOf(name) !== -1);
if (ENABLED.length === 0) {
throw new Error(`SCENARIOS must name at least one of: ${ALL_SCENARIOS.join(', ')}`);
}
/**
* Read the session manifest written by `php artisan app:seed-load-test`.
*
* Each entry already carries the encrypted session cookie, because
* EncryptCookies wraps cookie values in an HMAC prefix and then encrypts them.
* A bare session id is rejected by the framework.
*/
const sessions = JSON.parse(open('./sessions.json'));
const userSessions = sessions.filter((s) => !s.isAdmin);
const adminSessions = sessions.filter((s) => s.isAdmin);
/**
* Pair a latency trend with a request counter.
*
* A Trend's summary values carry percentiles but no sample count, and the count
* is what throughput is derived from, so each scenario needs both.
*/
function scenarioMetrics(name) {
return {
trend: new Trend(`${name}_latency`, true),
counter: new Counter(`${name}_requests`),
};
}
const METRICS = {
anon: scenarioMetrics('anon'),
page_load: scenarioMetrics('page_load'),
livewire_read: scenarioMetrics('livewire_read'),
livewire_write: scenarioMetrics('livewire_write'),
folders_read: scenarioMetrics('folders_read'),
folders_write: scenarioMetrics('folders_write'),
admin: scenarioMetrics('admin'),
};
const failures = new Rate('functional_failures');
const serverErrors = new Counter('server_errors');
const checksumRejects = new Counter('checksum_rejects');
/**
* Record one successful request against a scenario's metrics.
*/
function record(name, durationMs) {
METRICS[name].trend.add(durationMs);
METRICS[name].counter.add(1);
failures.add(false);
}
// Service level objectives the ramp is looking for a breach of.
const SLO_P95_MS = parseInt(__ENV.SLO_P95_MS || '1000', 10);
const SLO_ERROR_RATE = parseFloat(__ENV.SLO_ERROR_RATE || '0.01');
export const options = {
discardResponseBodies: false,
// p99 is not in k6's default summary set, and it is the number that exposes
// a tail growing long before the mean moves.
summaryTrendStats: ['avg', 'min', 'med', 'max', 'p(50)', 'p(90)', 'p(95)', 'p(99)'],
scenarios: ENABLED.reduce((acc, name) => {
acc[name] = {
executor: 'constant-vus',
vus: VUS,
duration: DURATION,
exec: name,
tags: { scenario: name },
};
return acc;
}, {}),
thresholds: {
functional_failures: [`rate<${SLO_ERROR_RATE}`],
},
};
/**
* Choose the session a VU always authenticates as.
*
* Pinning each VU to one account keeps a single session cookie hot for the
* whole run and spreads load across accounts, which is closer to real use than
* re-authenticating on every iteration.
*/
function sessionFor(pool, vuId) {
if (pool.length === 0) {
throw new Error('The session manifest has no usable sessions. Run php artisan app:seed-load-test first.');
}
return pool[(vuId - 1) % pool.length];
}
function authHeaders(session) {
return {
Cookie: `${session.cookieName}=${session.cookie}`,
Accept: 'text/html,application/xhtml+xml',
};
}
function livewireHeaders(session, page) {
return {
Cookie: `${session.cookieName}=${session.cookie}`,
'Content-Type': 'application/json',
'X-Livewire': '1',
'X-CSRF-TOKEN': page.csrf,
Accept: 'application/json',
};
}
/**
* Pull the three values a Livewire round-trip needs out of a rendered page:
* the signed snapshot, the CSRF token and the update endpoint URL.
*/
function parsePage(body) {
const snapshot = /wire:snapshot="([^"]*)"/.exec(body);
const csrf = /data-csrf="([^"]*)"/.exec(body);
const uri = /data-update-uri="([^"]*)"/.exec(body);
if (!snapshot || !csrf || !uri) {
throw new Error('Could not find the Livewire snapshot, CSRF token or update URI in the response.');
}
return {
snapshot: htmlDecode(snapshot[1]),
csrf: csrf[1],
uri: uri[1],
};
}
/**
* Blade escapes attribute values, so the snapshot arrives HTML-escaped inside
* the wire:snapshot attribute.
*/
function htmlDecode(value) {
return value
.replace(/&quot;/g, '"')
.replace(/&#039;/g, "'")
.replace(/&lt;/g, '<')
.replace(/&gt;/g, '>')
.replace(/&amp;/g, '&');
}
/**
* Load a page and remember the session context for later update calls.
*
* Cached per VU because the update scenarios chain snapshots: each response
* carries the next valid snapshot, so refetching every iteration would measure
* page loads rather than the update path.
*/
function loadPage(pool, path) {
const session = sessionFor(pool, exec.vu.idInTest);
const response = http.get(BASE_URL + path, {
headers: authHeaders(session),
tags: { name: path, step: 'page' },
});
const ok = check(response, {
'page returned 200': (r) => r.status === 200,
'page is not the paywall redirect': (r) => r.status !== 302,
});
if (!ok) {
failures.add(true);
serverErrors.add(1);
throw new Error(`${path} returned ${response.status}`);
}
const page = parsePage(response.body);
page.timing = response.timings.duration;
return { session, path, ...page };
}
/**
* Post one Livewire update, chaining the returned snapshot for the next call.
*/
function sendUpdate(page, scenario, updates, calls) {
const payload = JSON.stringify({
components: [
{
snapshot: page.snapshot,
updates: updates || {},
// Livewire 4 validates that every call carries a method string and a
// params array, and rejects the whole payload with a 500 otherwise.
calls: (calls || []).map((call) => ({
path: '',
method: call.method,
params: call.params || [],
})),
},
],
});
const response = http.post(page.uri, payload, {
headers: livewireHeaders(page.session, page),
tags: { name: page.path, step: 'update' },
});
if (response.status !== 200) {
failures.add(true);
serverErrors.add(1);
if (response.status === 429) {
checksumRejects.add(1);
}
throw new Error(`Livewire update to ${page.path} returned ${response.status}`);
}
let body;
try {
body = JSON.parse(response.body);
} catch (e) {
failures.add(true);
throw new Error(`Livewire update to ${page.path} did not return JSON`);
}
const component = body.components && body.components[0];
if (!component || !component.snapshot) {
failures.add(true);
throw new Error(`Livewire update to ${page.path} returned no snapshot`);
}
// The response snapshot is the only one valid for the next request.
page.snapshot = component.snapshot;
record(scenario, response.timings.duration);
return response;
}
export function anon() {
for (const path of ['/', '/pricing']) {
const response = http.get(BASE_URL + path, { tags: { name: path } });
const ok = check(response, { 'anonymous page returned 200': (r) => r.status === 200 });
if (!ok) {
failures.add(true);
serverErrors.add(1);
} else {
record('anon', response.timings.duration);
}
}
}
export function page_load() {
// Rotate through the three authenticated pages a user actually navigates
// between, so the reported number is not the mean of one page's cost.
const page = loadPage(userSessions, PAGE_LOAD_PATHS[exec.scenario.iterationInTest % PAGE_LOAD_PATHS.length]);
record('page_load', page.timing);
}
export function livewire_read() {
const page = getTodosContext();
const step = exec.scenario.iterationInTest % 4;
if (step === 0) {
// The search box is bound to a 300ms debounce, so every few keystrokes of
// a real search session produce one of these. It is also the only query in
// the app whose predicate cannot use an index.
const term = SEARCH_TERMS[exec.scenario.iterationInTest % SEARCH_TERMS.length];
sendUpdate(page, 'livewire_read', { search: term }, []);
} else if (step === 1) {
sendUpdate(page, 'livewire_read', {}, [{ method: 'resetFilters' }]);
} else if (step === 2) {
const status = STATUS_FILTERS[exec.scenario.iterationInTest % STATUS_FILTERS.length];
sendUpdate(page, 'livewire_read', { status }, []);
} else {
// Paginates one more page, which re-runs the filtered COUNT(*).
sendUpdate(page, 'livewire_read', {}, [{ method: 'loadMore' }]);
}
}
export function livewire_write() {
const page = getTodosContext();
const session = page.session;
const todoId = session.todoIds[exec.scenario.iterationInTest % session.todoIds.length];
sendUpdate(page, 'livewire_write', {}, [{ method: 'toggleComplete', params: [todoId] }]);
}
export function folders_read() {
const page = getFoldersContext();
const folderIds = page.session.folderIds;
// A fresh id every time means the component always expands rather than
// toggling shut, so every iteration pays the per-folder todo query.
const folderId = folderIds[exec.scenario.iterationInTest % folderIds.length];
sendUpdate(page, 'folders_read', {}, [{ method: 'toggleExpandFolder', params: [folderId] }]);
}
export function folders_write() {
const page = getFoldersContext();
const session = page.session;
const todoId = session.todoIds[exec.scenario.iterationInTest % session.todoIds.length];
const folderId = session.folderIds[exec.scenario.iterationInTest % session.folderIds.length];
sendUpdate(page, 'folders_write', {}, [
{ method: 'moveTodoToFolder', params: [todoId, folderId] },
]);
}
export function admin() {
const pool = adminSessions.length > 0 ? adminSessions : userSessions;
const response = http.get(BASE_URL + '/admin/notes-limits', {
headers: authHeaders(sessionFor(pool, exec.vu.idInTest)),
tags: { name: '/admin/notes-limits' },
});
const ok = check(response, { 'admin page returned 200': (r) => r.status === 200 });
if (!ok) {
failures.add(true);
serverErrors.add(1);
} else {
record('admin', response.timings.duration);
}
}
/**
* Search terms, including one that matches nothing, so the LIKE predicate is
* exercised against both a matching and a full-scan outcome.
*/
const SEARCH_TERMS = ['invoice', 'review', 'the', 'a', 'zzznomatch', 'team', 'update', ''];
const STATUS_FILTERS = ['open', 'completed', 'overdue', 'all'];
const PAGE_LOAD_PATHS = ['/dashboard', '/todos', '/folders'];
/**
* Per-VU snapshot chains. Each VU gets its own module instance, so these are
* private to that VU and survive across its iterations.
*/
let todosContext = null;
let foldersContext = null;
function getTodosContext() {
if (todosContext === null) {
todosContext = loadPage(userSessions, '/todos');
}
return todosContext;
}
function getFoldersContext() {
if (foldersContext === null) {
foldersContext = loadPage(userSessions, '/folders');
}
return foldersContext;
}
/**
* Turn the run into the number the question actually asks for: how many
* concurrent users this workload supports.
*
* Little's Law gives that directly. With a stable arrival rate, the mean number
* of requests resident in the system equals the arrival rate times the mean
* time each spends there, so:
*
* concurrent users = throughput (req/s) x mean response time (s)
*
* Note this is a floor derived from the offered load. Once the server is
* saturated, response time grows in step with offered concurrency, so the
* product stops growing too. That is why the SLO breach, not the product, is
* the signal to stop ramping.
*/
function capacityFor(metrics, scenario, durationSeconds) {
const trend = metrics[METRICS[scenario].trend.name];
const counter = metrics[METRICS[scenario].counter.name];
if (!trend || !counter || !durationSeconds) {
return null;
}
const count = counter.values.count;
const values = trend.values;
if (!count) {
return null;
}
const rps = count / durationSeconds;
const meanSeconds = values.avg / 1000;
return {
requests: count,
rps: round(rps, 2),
meanMs: round(values.avg, 1),
p50Ms: round(values.med, 1),
p95Ms: round(values['p(95)'], 1),
p99Ms: round(values['p(99)'], 1),
maxMs: round(values.max, 1),
concurrentUsers: round(rps * meanSeconds, 1),
breachesP95: values['p(95)'] > SLO_P95_MS,
};
}
function round(value, places) {
const factor = Math.pow(10, places);
return Math.round(value * factor) / factor;
}
export function handleSummary(data) {
const durationSeconds = (data.state.testRunDurationMs || 0) / 1000;
const rows = [];
for (const name of ENABLED) {
rows.push({ scenario: name, ...(capacityFor(data.metrics, name, durationSeconds) || { error: 'no samples' }) });
}
const errorRate = data.metrics.functional_failures
? data.metrics.functional_failures.values.rate
: 0;
const missing = rows.filter((row) => row.error);
const breached = rows.filter((row) => row.breachesP95);
const saturated = errorRate >= SLO_ERROR_RATE;
const lines = [];
lines.push('');
lines.push(`label ${LABEL}`);
lines.push(`base url ${BASE_URL}`);
lines.push(`vus/scenario ${VUS}`);
lines.push(`duration ${DURATION} (measured ${round(durationSeconds, 1)}s)`);
lines.push(`error rate ${round(errorRate * 100, 2)}% (SLO < ${SLO_ERROR_RATE * 100}%)`);
lines.push('');
lines.push('scenario rps mean p50 p95 p99 max users p95-ok');
lines.push('----------------- ------ ------ ----- ----- ----- ----- ------ ------');
for (const row of rows) {
if (row.error) {
lines.push(`${row.scenario.padEnd(17)} ${row.error}`);
continue;
}
lines.push(
[
row.scenario.padEnd(17),
String(row.rps).padStart(6),
String(row.meanMs).padStart(6),
String(row.p50Ms).padStart(5),
String(row.p95Ms).padStart(5),
String(row.p99Ms).padStart(5),
String(row.maxMs).padStart(5),
String(row.concurrentUsers).padStart(6),
(row.breachesP95 ? 'NO' : 'yes').padStart(6),
].join(' '),
);
}
lines.push('');
lines.push(`p95 SLO: ${SLO_P95_MS}ms`);
if (missing.length > 0) {
lines.push(`VERDICT: ${missing.map((r) => r.scenario).join(', ')} produced no samples. Fix the scenario before reading any capacity number from this run.`);
} else if (saturated) {
lines.push(`VERDICT: saturated at ${VUS} VU(s). Throughput is capped by the server, not by the workload.`);
} else if (breached.length > 0) {
lines.push(`VERDICT: ${breached.map((r) => r.scenario).join(', ')} breached the p95 SLO at ${VUS} VU(s). This is the knee.`);
} else {
lines.push(`VERDICT: still within SLO at ${VUS} VU(s). Raise VUS and measure again.`);
}
const summary = {
label: LABEL,
baseUrl: BASE_URL,
vus: VUS,
durationSeconds: round(durationSeconds, 2),
errorRate: errorRate,
sloP95Ms: SLO_P95_MS,
rows,
};
const output = { stdout: lines.join('\n') + '\n' };
if (__ENV.RESULTS) {
output[__ENV.RESULTS] = JSON.stringify(summary, null, 2);
}
return output;
}