Files
mtusi2026lab3/scripts/load/common.js
T
ilya.tyunin b7cf7b2d3f Дополнить доказательства трека 1 по замечаниям ревью
Измерения (raw-файлы, сводки, отчёт):
- контрольный A/B на бюджете по умолчанию (`abdiag`, 3+3 повтора): A упирается в
  250 req/s и отдаёт 503 `unavailable` (4/894/2813 на 300/350/400), B держит
  398.7 req/s без единого 5xx;
- блок «почему» на одном темпе (900 и 1500 req/s, 2 повтора x 5 конфигураций):
  перераспределение того же бюджета не меняет потолок (820–854 req/s), разделение
  бюджета между репликами поднимает время горячего оператора с 1.56 до 17.3–17.9 ms,
  ожидания `LWLock:WALWrite`/`Lock:transactionid` общие для всех реплик;
- колено текущей сборки (900–2200 req/s, N=1 и N=4): ≈1200 req/s против ≈700 у
  серии A, за коленом одна реплика с полным бюджетом не хуже четырёх;
- пара прогонов HAProxy 0.25 против 1.0 CPU на 1500 req/s: результат одинаков,
  при квоте 1.0 балансировщик использует те же 25 % ядра.

Харнесс `scripts/lab3/lab3.py`:
- `--loadgen-memory` для подкоманды `run` (прогон колена падал на разборе аргументов);
- суффикс вывода A/B для контрольной серии (`summary-ab-abdiag.md`, `ab-verdict-abdiag.json`);
- исправлено затенение `header()` локальной переменной в `cmd_check`, из-за которого
  падала проверка `check spread`;
- сэмплер: классы ответов LB (`hrsp_*`), ожидания сессий PostgreSQL (`wait_event`),
  операторы `idempotency_keys` в дельтах `pg_stat_statements`.

Доказательства и документы: пересняты `evidence/level3/{smoke,persistence}` и
`evidence/level4/{dependency-faults,spread,idempotency-concurrency}`, обновлены
сводки и графики `evidence/track1/*`, `evidence/README.md` (метки и состав сводок),
`REPORT.md` (разбор отказов стороны A, бюджет серии, оговорки о валидности данных,
точные команды воспроизведения, «почему» закрыто измерением).
2026-10-16 03:01:14 +03:00

270 lines
9.1 KiB
JavaScript

// Общие части профилей нагрузки: подготовка синтетических данных, разбор
// лестницы темпов, пошаговые метрики и сводка в stdout.
//
// Темп задаётся исполнителем constant-arrival-rate: k6 не интерполирует темп
// внутри сценария, поэтому каждый шаг лестницы — отдельный сценарий со своим
// временем старта и плоской полкой. Метрики каждого шага собираются отдельными
// объектами (k6 не создаёт подметрики для произвольных тегов), а сводка
// печатается JSON в stdout: файлов из контейнера генератор не создаёт.
import encoding from 'k6/encoding';
import exec from 'k6/execution';
import http from 'k6/http';
import { Counter, Gauge, Trend } from 'k6/metrics';
export const BASE_URL = (__ENV.BASE_URL || 'http://haproxy:8080').replace(
/\/+$/u,
'',
);
const CHAT_COUNT = Number(__ENV.CHATS || 24);
const LOAD_USERS = 3;
// Бюджет VU: на 1100 req/s при p95 около 25 ms достаточно около 30 активных VU;
// 60 предвыделенных и 200 максимальных оставляют запас, чтобы узкое место
// оказалось на сервере, а не в генераторе.
// Бюджет VU: на 1100 req/s при p95 около 25 ms достаточно около 30 активных VU.
// Значения переопределяются извне (PRE_VUS/MAX_VUS): на пути чтения генератор
// упирался в 200 VU раньше, чем в CPU, и потолок измерялся бы как потолок k6.
export const VUS = {
preAllocated: Number(__ENV.PRE_VUS || 60),
max: Number(__ENV.MAX_VUS || 200),
};
export function ratesFromEnv(fallback) {
const raw = __ENV.LADDER;
if (!raw) return fallback;
const parsed = raw
.split(',')
.map((value) => Number(value.trim()))
.filter((value) => Number.isFinite(value) && value > 0);
return parsed.length > 0 ? parsed : fallback;
}
export function stepMetrics(rates, keyBuilder) {
const metrics = {};
for (const rate of rates) {
metrics[keyBuilder(rate)] = {
rate,
requests: new Counter(`step_${rate}_requests`),
failed: new Counter(`step_${rate}_failed`),
// Классы ответов: k6 пишет только «не 201», для разбора отказов
// (например, стороны A в A/B) нужны сами коды.
status2xx: new Counter(`step_${rate}_status_2xx`),
status4xx: new Counter(`step_${rate}_status_4xx`),
status5xx: new Counter(`step_${rate}_status_5xx`),
statusOther: new Counter(`step_${rate}_status_other`),
duration: new Trend(`step_${rate}_duration`, true),
vus: new Gauge(`step_${rate}_vus`),
};
}
return metrics;
}
export function ladderScenarios(rates, stepSeconds) {
const scenarios = {};
rates.forEach((rate, index) => {
scenarios[`step_${rate}`] = {
executor: 'constant-arrival-rate',
exec: 'run',
rate,
timeUnit: '1s',
duration: `${stepSeconds}s`,
startTime: `${index * stepSeconds}s`,
preAllocatedVUs: VUS.preAllocated,
maxVUs: VUS.max,
tags: { rate: String(rate) },
};
});
return scenarios;
}
export function steadyScenarios(rate, seconds) {
return {
steady: {
executor: 'constant-arrival-rate',
exec: 'run',
rate,
timeUnit: '1s',
duration: `${seconds}s`,
preAllocatedVUs: VUS.preAllocated,
maxVUs: VUS.max,
tags: { rate: String(rate) },
},
};
}
// Идентификаторы не обязаны быть криптостойкими: нужна уникальность ключа
// идемпотентности на итерацию и уникальность синтетических пользователей.
function token(size) {
return Math.random().toString(36).slice(2, 2 + size);
}
export function setup() {
const runId = token(8);
const users = [];
for (let index = 0; index < LOAD_USERS; index += 1) {
const username = `k6_${runId}_${index}`;
const password = `k6-pass-${runId}-${index}`;
const registered = http.post(
`${BASE_URL}/api/v1/users`,
JSON.stringify({
username,
display_name: `k6 ${index}`,
password,
}),
{ headers: { 'content-type': 'application/json' } },
);
if (registered.status !== 201)
throw new Error(
`cannot register ${username}: ${registered.status} ${registered.body}`,
);
const user = JSON.parse(registered.body);
const session = http.post(
`${BASE_URL}/api/v1/auth/sessions`,
null,
{
headers: {
authorization: `Basic ${encoding.b64encode(`${username}:${password}`)}`,
},
},
);
if (session.status !== 201)
throw new Error(
`cannot create session for ${username}: ${session.status} ${session.body}`,
);
users.push({
id: user.id,
token: JSON.parse(session.body).token,
username,
});
}
const chats = [];
for (let index = 0; index < CHAT_COUNT; index += 1) {
const created = http.post(
`${BASE_URL}/api/v1/chats`,
JSON.stringify({
title: `k6 ${runId} chat ${index}`,
member_ids: users.map((user) => user.id),
}),
{
headers: {
'content-type': 'application/json',
authorization: `Bearer ${users[0].token}`,
},
},
);
if (created.status !== 201)
throw new Error(
`cannot create chat ${index}: ${created.status} ${created.body}`,
);
chats.push(JSON.parse(created.body).id);
}
return { runId, users, chats, profile: __ENV.PROFILE || 'spread' };
}
function chatFor(data) {
if (data.profile === 'hot') return data.chats[0];
return data.chats[(exec.vu.idInTest * 7 + exec.vu.iterationInInstance) % data.chats.length];
}
function actorFor(data) {
return data.users[exec.vu.idInTest % data.users.length];
}
function recordResponse(step, response, expected) {
step.requests.add(1);
step.duration.add(response.timings.duration);
if (response.status === expected) {
step.status2xx.add(1);
return;
}
step.failed.add(1);
if (response.status >= 200 && response.status < 300) step.status2xx.add(1);
else if (response.status >= 400 && response.status < 500) step.status4xx.add(1);
else if (response.status >= 500 && response.status < 600) step.status5xx.add(1);
else step.statusOther.add(1);
step.vus.add(exec.instance.vusActive);
}
export function writeIteration(data, metrics) {
const step = metrics[exec.scenario.name];
const actor = actorFor(data);
const key = `k6-${Date.now().toString(36)}-${token(12)}-${exec.vu.idInTest}`;
const response = http.post(
`${BASE_URL}/api/v1/chats/${chatFor(data)}/messages`,
JSON.stringify({ text: `k6 ${data.runId} ${key}` }),
{
headers: {
'content-type': 'application/json',
authorization: `Bearer ${actor.token}`,
'idempotency-key': key,
},
tags: { rate: String(step.rate) },
},
);
recordResponse(step, response, 201);
}
export function readIteration(data, metrics) {
const step = metrics[exec.scenario.name];
const actor = actorFor(data);
const response = http.get(
`${BASE_URL}/api/v1/chats/${chatFor(data)}/messages?limit=50`,
{
headers: { authorization: `Bearer ${actor.token}` },
tags: { rate: String(step.rate) },
},
);
recordResponse(step, response, 200);
}
function round(value, digits) {
const factor = 10 ** digits;
return Math.round(value * factor) / factor;
}
export function summaryJson(data, metrics, rates, kind, stepSeconds) {
const steps = rates.map((rate) => {
const name = `step_${rate}`;
const values = data.metrics[`${name}_duration`]?.values ?? {};
const requests = data.metrics[`${name}_requests`]?.values?.count ?? 0;
return {
rate,
duration_s: stepSeconds,
requests,
achieved_rps: round(requests / stepSeconds, 2),
failed: data.metrics[`${name}_failed`]?.values?.count ?? 0,
status: {
ok: data.metrics[`${name}_status_2xx`]?.values?.count ?? 0,
client_4xx: data.metrics[`${name}_status_4xx`]?.values?.count ?? 0,
server_5xx: data.metrics[`${name}_status_5xx`]?.values?.count ?? 0,
other: data.metrics[`${name}_status_other`]?.values?.count ?? 0,
},
p50: round(values['p(50)'] ?? 0, 2),
p95: round(values['p(95)'] ?? 0, 2),
p99: round(values['p(99)'] ?? 0, 2),
avg: round(values.avg ?? 0, 2),
max: round(values.max ?? 0, 2),
vus_active: data.metrics[`${name}_vus`]?.values?.value ?? 0,
};
});
const global = data.metrics.http_req_duration?.values ?? {};
return {
label: __ENV.LABEL || 'unlabelled',
profile: __ENV.PROFILE || 'spread',
mode: __ENV.MODE || 'write',
kind,
base_url: BASE_URL,
steps,
http_reqs: data.metrics.http_reqs?.values?.count ?? 0,
iterations: data.metrics.iterations?.values?.count ?? 0,
dropped_iterations: data.metrics.dropped_iterations?.values?.count ?? 0,
vus_max: data.metrics.vus_max?.values?.value ?? 0,
vus_configured: VUS,
http_req_duration_p95: round(global['p(95)'] ?? 0, 2),
checks: {
passes: data.metrics.checks?.values?.passes ?? 0,
fails: data.metrics.checks?.values?.fails ?? 0,
},
};
}