forked from mtusi2026/mtusi2026lab3
Compare API and PostgreSQL CPU budgets and connection pool limits. Collect repeatable measurements and generate report aggregates and graphs.
167 lines
8.7 KiB
JavaScript
167 lines
8.7 KiB
JavaScript
import http from 'k6/http';
|
|
import encoding from 'k6/encoding';
|
|
import execution from 'k6/execution';
|
|
import { check, fail, sleep } from 'k6';
|
|
import { Counter, Trend } from 'k6/metrics';
|
|
|
|
const base = __ENV.BASE_URL || 'http://nginx';
|
|
const rate = Number(__ENV.RATE || 100);
|
|
const seconds = Number(__ENV.SECONDS || 30);
|
|
const warmup = Number(__ENV.WARMUP || 10);
|
|
const expected = Number(__ENV.EXPECTED || 1);
|
|
const calibration = __ENV.CALIBRATION === '1';
|
|
const attempts = new Counter('bench_attempts');
|
|
const successes = new Counter('bench_successes');
|
|
const failures = new Counter('bench_failures');
|
|
const latency = new Trend('bench_latency', true);
|
|
const successLatency = new Trend('bench_success_latency', true);
|
|
const epoch = new Trend('bench_start_epoch');
|
|
const operations = Object.fromEntries(['read', 'write'].map((op) => [op, {
|
|
attempts: new Counter(`bench_${op}_attempts`),
|
|
successes: new Counter(`bench_${op}_successes`),
|
|
failures: new Counter(`bench_${op}_failures`),
|
|
latency: new Trend(`bench_${op}_latency`, true),
|
|
}]));
|
|
const statuses = Object.fromEntries(['200', '201', 'other', 'network'].map((key) => [key, new Counter(`bench_status_${key}`)]));
|
|
|
|
const arrival = { executor: 'constant-arrival-rate', rate, timeUnit: '1s',
|
|
preAllocatedVUs: 128, maxVUs: 128 };
|
|
export const options = {
|
|
scenarios: {
|
|
warmup: { ...arrival, exec: 'warmupLoad', duration: `${warmup}s`, gracefulStop: '5s' },
|
|
measurement: { ...arrival, exec: 'default', startTime: `${warmup}s`,
|
|
duration: `${seconds}s`, gracefulStop: '10s' },
|
|
},
|
|
summaryTrendStats: ['min', 'med', 'avg', 'max', 'p(95)', 'p(99)'],
|
|
setupTimeout: '120s',
|
|
};
|
|
|
|
function request(method, path, token, body, key) {
|
|
const headers = { Accept: 'application/json' };
|
|
if (token) headers.Authorization = token;
|
|
if (key) headers['Idempotency-Key'] = key;
|
|
if (body !== undefined) headers['Content-Type'] = 'application/json';
|
|
return http.request(method, base + path, body === undefined ? null : JSON.stringify(body), {
|
|
headers, timeout: '5s', tags: { name: path.includes('/messages') ? 'messages' : 'setup' },
|
|
});
|
|
}
|
|
|
|
function required(response, status, field) {
|
|
let data;
|
|
try { data = response.json(); } catch { fail(`setup: invalid JSON, status ${response.status}`); }
|
|
if (response.status !== status || !data?.[field]) fail(`setup: expected ${status}/${field}, got ${response.status}`);
|
|
return data;
|
|
}
|
|
|
|
export function setup() {
|
|
const salt = `${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9)}`;
|
|
let token = 'Bearer calibration';
|
|
let path = '/messages';
|
|
if (!calibration) {
|
|
const users = ['alice', 'bob'].map((label) => {
|
|
const username = `bench_${label}_${salt.replaceAll('-', '')}`;
|
|
const password = `T3st-${salt}-Aa1!`;
|
|
const user = required(request('POST', '/api/v1/users', null,
|
|
{ username, display_name: `Benchmark ${label}`, password }), 201, 'id');
|
|
const auth = `Basic ${encoding.b64encode(`${username}:${password}`)}`;
|
|
const session = required(request('POST', '/api/v1/auth/sessions', auth), 201, 'token');
|
|
return { id: user.id, token: session.token };
|
|
});
|
|
token = `Bearer ${users[0].token}`;
|
|
const chat = required(request('POST', '/api/v1/chats', token,
|
|
{ title: 'Saturation benchmark', member_ids: users.map((u) => u.id) }), 201, 'id');
|
|
path = `/api/v1/chats/${chat.id}/messages`;
|
|
for (let i = 0; i < 30; i++) required(request('POST', path, token,
|
|
{ text: `seed-${salt}-${i}` }, `seed-${salt}-${i}`), 201, 'id');
|
|
}
|
|
const seen = new Set();
|
|
const until = Date.now() + 20000;
|
|
do {
|
|
const response = request('GET', `${path}?limit=50`, token);
|
|
if (response.status !== 200) fail(`warmup status ${response.status}`);
|
|
const id = response.headers['X-Instance-Id'];
|
|
if (id) seen.add(id);
|
|
if (seen.size === expected) break;
|
|
sleep(0.02);
|
|
} while (Date.now() < until);
|
|
if (seen.size !== expected) fail(`warmup observed ${seen.size} instances, expected ${expected}`);
|
|
return { token, path, salt };
|
|
}
|
|
|
|
export function warmupLoad(data) { iteration(data, false); }
|
|
export default function (data) { iteration(data, true); }
|
|
|
|
function iteration(data, measuring) {
|
|
if (measuring && execution.scenario.iterationInTest === 0) epoch.add(Date.now());
|
|
const sequence = execution.scenario.iterationInTest;
|
|
const identity = `${execution.scenario.name}-${sequence}`;
|
|
const op = ((sequence * 37 + 17) % 100) < 80 ? 'read' : 'write';
|
|
if (measuring) { attempts.add(1); operations[op].attempts.add(1); }
|
|
const response = op === 'read'
|
|
? request('GET', `${data.path}?limit=50`, data.token)
|
|
: request('POST', data.path, data.token, { text: `bench-${identity}-${data.salt}` }, `${data.salt}-${identity}`);
|
|
if (!measuring) return;
|
|
let payload;
|
|
try { payload = response.json(); } catch { payload = null; }
|
|
const instance = response.headers['X-Instance-Id'];
|
|
const ok = response.status === (op === 'read' ? 200 : 201) && Boolean(instance)
|
|
&& (op === 'read' ? Array.isArray(payload?.items) : Boolean(payload?.id));
|
|
const elapsed = response.timings.duration + response.timings.blocked;
|
|
latency.add(elapsed);
|
|
successes.add(ok ? 1 : 0);
|
|
failures.add(ok ? 0 : 1);
|
|
operations[op].successes.add(ok ? 1 : 0);
|
|
operations[op].failures.add(ok ? 0 : 1);
|
|
if (ok) { successLatency.add(elapsed); operations[op].latency.add(elapsed); }
|
|
statuses[String(response.status)]?.add(1);
|
|
if (![200, 201].includes(response.status)) statuses[response.status === 0 ? 'network' : 'other'].add(1);
|
|
if (instance) check(response, { [`instance:${instance}`]: () => true });
|
|
}
|
|
|
|
export function handleSummary(data) {
|
|
const count = (name) => data.metrics[name]?.values.count || 0;
|
|
const times = (name) => ({ p50: data.metrics[name]?.values.med ?? null,
|
|
p95: data.metrics[name]?.values['p(95)'] ?? null,
|
|
p99: data.metrics[name]?.values['p(99)'] ?? null });
|
|
const start = data.metrics.bench_start_epoch?.values.min;
|
|
const totalDropped = count('dropped_iterations');
|
|
const dropped = Math.max(0, rate * seconds - count('bench_attempts'));
|
|
const instances = Object.fromEntries((data.root_group.checks || []).filter((c) => c.name.startsWith('instance:'))
|
|
.map((c) => [c.name.slice(9), c.passes]));
|
|
const group = (op) => {
|
|
const prefix = op === 'all' ? 'bench' : `bench_${op}`;
|
|
return { attempted: count(`${prefix}_attempts`), successful: count(`${prefix}_successes`),
|
|
errors: count(`${prefix}_failures`), successful_rps: count(`${prefix}_successes`) / seconds,
|
|
successful_latency_ms: times(op === 'all' ? 'bench_success_latency' : `${prefix}_latency`),
|
|
status_counts: {}, error_counts: {}, instance_counts: op === 'all' ? instances : {} };
|
|
};
|
|
const result = {
|
|
label: __ENV.LABEL, profile: { arrival_model: 'k6 constant-arrival-rate; one HTTP request per iteration',
|
|
offered_rps: rate, duration_seconds: seconds, warmup_seconds: warmup, warmup_profile: 'same 80/20 workload at target rate',
|
|
read_percent: 80, write_percent: 20, initial_messages: calibration ? 0 : 30, history_limit: 50,
|
|
max_in_flight: 128, timeout_ms: 5000, automatic_retries: false, expected_instances: expected,
|
|
phase: __ENV.PHASE || 'probe' },
|
|
measurement: { scheduled_slots: rate * seconds, client_dropped_slots: dropped,
|
|
scheduler_late_slots: 0, read: group('read'), write: group('write'), all: group('all') },
|
|
timing: { measurement_started_epoch_ms: start,
|
|
measurement_scheduled_end_epoch_ms: start + seconds * 1000,
|
|
measurement_completed_epoch_ms: Date.now() },
|
|
client: { engine: 'k6', scheduler_lateness_measured: false,
|
|
raw_dropped_iterations_including_warmup: totalDropped,
|
|
peak_vus: data.metrics.vus?.values.max, max_vus: 128 },
|
|
all_latency_ms: times('bench_latency'), raw_metrics: data.metrics,
|
|
notes: ['Setup and in-scenario mixed warmup excluded from custom bench metrics.',
|
|
'Native warmup and measurement scenarios; no Date.now gating of measured requests.',
|
|
'Latency uses native HTTP duration plus blocked time, not subtraction of wall-clock timestamps.',
|
|
'Measurement missing slots are planned minus actual starts; raw k6 dropped iterations also include warmup.',
|
|
'scheduler_late_slots is a compatibility placeholder, not a k6 measurement.',
|
|
'Dropped iterations and actual delivered fraction must be checked.',
|
|
'No credentials or message bodies are exported.'],
|
|
};
|
|
result.measurement.all.status_counts = Object.fromEntries(['200', '201', 'other', 'network']
|
|
.map((status) => [status, count(`bench_status_${status}`)]));
|
|
return { [__ENV.OUTPUT]: JSON.stringify(result, null, 2),
|
|
stdout: JSON.stringify({ label: result.label, attempted: result.measurement.all.attempted,
|
|
errors: result.measurement.all.errors, p95: result.all_latency_ms.p95, dropped }) + '\n' };
|
|
}
|