Дополнить доказательства трека 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, бюджет серии, оговорки о валидности данных,
точные команды воспроизведения, «почему» закрыто измерением).
This commit is contained in:
2026-10-16 03:01:14 +03:00
parent e38795d0a3
commit b7cf7b2d3f
181 changed files with 12378 additions and 3388 deletions
+407 -37
View File
@@ -602,6 +602,12 @@ class Sampler:
'ereq': _int(row.get('ereq')),
'dresp': _int(row.get('dresp')),
'wretr': _int(row.get('wretr')),
'hrsp_1xx': _int(row.get('hrsp_1xx')),
'hrsp_2xx': _int(row.get('hrsp_2xx')),
'hrsp_3xx': _int(row.get('hrsp_3xx')),
'hrsp_4xx': _int(row.get('hrsp_4xx')),
'hrsp_5xx': _int(row.get('hrsp_5xx')),
'hrsp_other': _int(row.get('hrsp_other')),
}
)
@@ -661,10 +667,12 @@ class Sampler:
fields = output.split('|')
if len(fields) != 10:
return
waits = self._wait_events()
self._record(
{
't': now_iso(),
'source': 'postgres',
'waits': waits,
**{
key: int(value)
for key, value in zip(
@@ -686,12 +694,27 @@ class Sampler:
}
)
def _wait_events(self) -> dict:
"""Сколько сессий ждут на каждом типе события: Lock/tuple/transactionid и т.д."""
output = psql(
"SELECT coalesce(wait_event_type, 'CPU/Idle') || ':' || coalesce(wait_event, '-'), count(*)"
" FROM pg_stat_activity WHERE datname = current_database() AND pid <> pg_backend_pid()"
" GROUP BY 1 ORDER BY 2 DESC LIMIT 12"
)
waits = {}
for line in output.splitlines():
parts = line.split('|')
if len(parts) == 2 and parts[1].isdigit():
waits[parts[0]] = int(parts[1])
return waits
def _pg_statements(self) -> None:
output = psql(
"SELECT calls, round(total_exec_time::numeric, 1), round(mean_exec_time::numeric, 3),"
" left(regexp_replace(query, '\\s+', ' ', 'g'), 90)"
" FROM pg_stat_statements WHERE query ILIKE '%messages%' OR query ILIKE '%chats%'"
" ORDER BY total_exec_time DESC LIMIT 5"
" left(regexp_replace(query, '\\s+', ' ', 'g'), 110)"
" FROM pg_stat_statements"
" WHERE query ILIKE '%messages%' OR query ILIKE '%chats%' OR query ILIKE '%idempotency_keys%'"
" ORDER BY total_exec_time DESC LIMIT 10"
)
if not output:
return
@@ -768,7 +791,7 @@ def k6_run(script: str, label: str, env: dict[str, str], timeout: float) -> dict
return summary
def load_env(profile: str, mode: str, spread: str, label: str) -> dict[str, str]:
def load_env(profile: str, mode: str, spread: str, label: str, vus: dict | None = None) -> dict[str, str]:
env = {
'BASE_URL': 'http://haproxy:8080',
'PROFILE': spread,
@@ -776,13 +799,21 @@ def load_env(profile: str, mode: str, spread: str, label: str) -> dict[str, str]
'CHATS': str(CHATS),
'LABEL': label,
}
if os.environ.get('LAB3_MAX_VUS'):
env['MAX_VUS'] = os.environ['LAB3_MAX_VUS']
if os.environ.get('LAB3_PRE_VUS'):
env['PRE_VUS'] = os.environ['LAB3_PRE_VUS']
max_vus = (vus or {}).get('max') or os.environ.get('LAB3_MAX_VUS')
pre_vus = (vus or {}).get('pre') or os.environ.get('LAB3_PRE_VUS')
if max_vus:
env['MAX_VUS'] = str(max_vus)
MANIFEST_VUS['max'] = str(max_vus)
if pre_vus:
env['PRE_VUS'] = str(pre_vus)
MANIFEST_VUS['pre'] = str(pre_vus)
return env
# Бюджет VU действующего прогона: попадает в манифест и в сводку k6.
MANIFEST_VUS: dict[str, str] = {}
def run_measured(
label: str,
profile: str,
@@ -796,6 +827,7 @@ def run_measured(
warmup: bool = True,
extra: dict | None = None,
phases: dict | None = None,
vus: dict | None = None,
) -> dict:
"""Один прогон: (необязательный прогрев) + измерение + сэмплер + манифест."""
profile_config = PROFILES[profile]
@@ -809,6 +841,7 @@ def run_measured(
RAW_DIR.mkdir(parents=True, exist_ok=True)
stand = load_stand_config()
MANIFEST_VUS.clear()
if warmup:
log(f'прогрев {label}: {WARMUP_SECONDS}s на {ladder[0]} req/s')
@@ -816,7 +849,7 @@ def run_measured(
script,
f'warmup-{label}',
{
**load_env(profile, mode, spread, f'warmup-{label}'),
**load_env(profile, mode, spread, f'warmup-{label}', vus),
**({'RATE': str(ladder[0]), 'DURATION': str(WARMUP_SECONDS)} if steady else {'LADDER': str(ladder[0]), 'STEP_SECONDS': str(WARMUP_SECONDS)}),
},
timeout=WARMUP_SECONDS + 120,
@@ -825,7 +858,7 @@ def run_measured(
sampler = Sampler().start()
started = now_iso()
env = {
**load_env(profile, mode, spread, label),
**load_env(profile, mode, spread, label, vus),
**({'RATE': str(ladder[0]), 'DURATION': str(duration)} if steady else {'LADDER': ','.join(str(r) for r in ladder), 'STEP_SECONDS': str(step_seconds)}),
}
log(f'нагрузка {label}: {"steady " + str(ladder[0]) + " req/s" if steady else "ladder " + str(ladder)}')
@@ -871,8 +904,8 @@ def write_raw(
'generator': {
'cpus': stand.get('LOADGEN_CPUS'),
'memory': stand.get('LOADGEN_MEMORY'),
'max_vus': os.environ.get('LAB3_MAX_VUS', '200'),
'pre_vus': os.environ.get('LAB3_PRE_VUS', '60'),
'max_vus': MANIFEST_VUS.get('max') or os.environ.get('LAB3_MAX_VUS', '200'),
'pre_vus': MANIFEST_VUS.get('pre') or os.environ.get('LAB3_PRE_VUS', '60'),
},
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
'quiesce': read_json(QUIESCE_STATE, None),
@@ -953,12 +986,17 @@ def summarise_series(labels: list[str]) -> dict:
summary = read_json(RAW_DIR / f'{label}.k6.json', {})
for step in summary.get('steps', []):
rate = int(step['rate'])
entry = steps.setdefault(rate, {'rate': rate, 'achieved': [], 'p95': [], 'failed': [], 'vus': [], 'offered': []})
entry = steps.setdefault(
rate,
{'rate': rate, 'achieved': [], 'p95': [], 'failed': [], 'vus': [], 'offered': [], 'status_5xx': [], 'status_4xx': []},
)
entry['achieved'].append(float(step['achieved_rps']))
entry['p95'].append(float(step['p95']))
entry['failed'].append(float(step['failed']))
entry['vus'].append(float(step.get('vus_active') or 0))
entry['offered'].append(float(step['rate']))
entry['status_5xx'].append(float((step.get('status') or {}).get('server_5xx') or 0))
entry['status_4xx'].append(float((step.get('status') or {}).get('client_4xx') or 0))
rows = []
for rate in sorted(steps):
entry = steps[rate]
@@ -972,6 +1010,8 @@ def summarise_series(labels: list[str]) -> dict:
'p95_max': spread(entry['p95'])[1],
'failed': sum(entry['failed']),
'vus_active': max(entry['vus']) if entry['vus'] else 0,
'status_5xx': int(max(entry['status_5xx'])) if entry['status_5xx'] else 0,
'status_4xx': int(max(entry['status_4xx'])) if entry['status_4xx'] else 0,
'reps': len(entry['achieved']),
}
)
@@ -1031,12 +1071,25 @@ def haproxy_stats(samples: list[dict]) -> dict:
continue
entry = servers.setdefault(
record['server'],
{'requests': [], 'errors': [], 'qcur': [], 'scur': [], 'statuses': set(), 'addr': set(), 'events': []},
{
'requests': [],
'errors': [],
'dresp': [],
'qcur': [],
'scur': [],
'codes': {},
'statuses': set(),
'addr': set(),
'events': [],
},
)
entry['requests'].append((record['t'], record['stot']))
entry['errors'].append(record['ereq'])
entry['dresp'].append(record.get('dresp') or 0)
entry['qcur'].append(record['qcur'])
entry['scur'].append(record['scur'])
for code in ('hrsp_1xx', 'hrsp_2xx', 'hrsp_3xx', 'hrsp_4xx', 'hrsp_5xx', 'hrsp_other'):
entry['codes'].setdefault(code, []).append(record.get(code) or 0)
entry['statuses'].add(record['status'])
entry['addr'].add(record['addr'])
entry['events'].append((record['t'], record['status'], record['check']))
@@ -1055,7 +1108,12 @@ def haproxy_stats(samples: list[dict]) -> dict:
result[name] = {
'requests': last[1] - first[1],
'rps': round((last[1] - first[1]) / seconds, 2),
'errors': entry['errors'][-1],
'errors': entry['errors'][-1] - entry['errors'][0] if entry['errors'] else 0,
'dresp': entry['dresp'][-1] - entry['dresp'][0] if entry['dresp'] else 0,
'response_codes': {
code: (values[-1] - values[0]) if values else 0
for code, values in entry['codes'].items()
},
'qcur_peak': max(entry['qcur']),
'scur_peak': max(entry['scur']),
'statuses': sorted(entry['statuses']),
@@ -1093,6 +1151,123 @@ def _timestamp(value: str) -> float:
return datetime.strptime(value, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=timezone.utc).timestamp()
def mechanism_stats(samples: list[dict]) -> dict:
"""Где теряется время: ожидания сессий, дельты pg_stat_statements, блокировки.
Даёт не «упираемся в ресурс», а разрез по причинам: сколько сессий стоит в
Lock, какие операторы съели время за прогон, сколько запросов прошло и как
распределились ответы LB.
"""
waits: dict[str, int] = {}
lock_peak = 0
active_peak = 0
for record in samples:
if record.get('source') != 'postgres':
continue
for key, value in (record.get('waits') or {}).items():
waits[key] = max(waits.get(key, 0), value)
lock_peak = max(lock_peak, record.get('lock_waiters') or 0)
active_peak = max(active_peak, record.get('active') or 0)
statements: list[dict] = []
ticks = [record for record in samples if record.get('source') == 'pg_stat_statements' and record.get('top')]
if len(ticks) >= 2:
first, last = ticks[0]['top'], ticks[-1]['top']
before = {row['query'][:60]: row for row in first}
for row in last:
previous = before.get(row['query'][:60])
calls = row['calls'] - (previous['calls'] if previous else 0)
total_ms = row['total_ms'] - (previous['total_ms'] if previous else 0)
if calls > 0:
statements.append(
{
'query': row['query'][:60],
'calls': calls,
'total_ms': round(total_ms, 1),
'mean_ms': round(total_ms / calls, 3),
}
)
statements.sort(key=lambda row: -row['total_ms'])
return {
'waits_peak': dict(sorted(waits.items(), key=lambda item: -item[1])[:6]),
'lock_waiters_peak': lock_peak,
'active_peak': active_peak,
'statements': statements[:6],
}
def analyse_mechanism(groups: dict, labels: list[str]) -> None:
"""Разрез «почему»: один темп, разные конфигурации/реплики, почему растёт не всё."""
block = {
key: group for key, group in groups.items() if key.startswith(('block#', 'why#'))
}
if not block:
return
lines = [
'Конфигурации одного блока измерены на одном темпе (steady, 60 s, близкий',
'объём данных, интерливинг повторов), поэтому различия относятся к',
'распределению ресурсов, а не к разному времени суток или профилю нагрузки.',
'Блоки различаются темпом (block# — 900 req/s, why# — за коленом).',
'',
]
for key, group in sorted(block.items()):
label = representative(group)
summary = read_json(RAW_DIR / f'{label}.k6.json', {})
step = summary['steps'][0] if summary.get('steps') else {}
_, samples, manifest = load_raw(label)
stats = container_stats(samples)
mechanism = mechanism_stats(samples)
api_peak = max((value['cpu_peak'] for name, value in stats.items() if 'api' in name), default=0.0)
pg_peak = stats.get('mtusi-lab3-postgres-1', {}).get('cpu_peak', 0.0)
generator_peak = max((value['cpu_peak'] for name, value in stats.items() if 'loadgen' in name), default=0.0)
stand = manifest.get('stand', {})
lines += [f'## {key} ({len(group)} повторов)', '']
lines += table(
['достигнуто RPS', 'p95, ms', 'failed', '2xx', '4xx', '5xx', 'прочее', 'CPU API пик %', 'CPU PG пик %', 'CPU ген. пик %'],
[
[
step.get('achieved_rps'),
step.get('p95'),
step.get('failed'),
(step.get('status') or {}).get('ok'),
(step.get('status') or {}).get('client_4xx'),
(step.get('status') or {}).get('server_5xx'),
(step.get('status') or {}).get('other'),
api_peak,
pg_peak,
generator_peak,
]
],
)
lines.append(
f'Лимиты: реплик {stand.get("API_REPLICAS")} x {stand.get("API_CPUS_PER_REPLICA")} CPU '
f'({stand.get("API_MEMORY_PER_REPLICA")}), PG {stand.get("PG_CPUS")} CPU, пул {stand.get("DATABASE_POOL_MAX")}, '
f'LB {stand.get("LB_CPUS")} CPU, генератор {stand.get("LOADGEN_CPUS")} CPU.'
)
lines.append('')
lines += table(
['активных сессий пик', 'Lock-ожиданий пик', 'ожидания (тип: событие -> сессий)'],
[
[
mechanism['active_peak'],
mechanism['lock_waiters_peak'],
', '.join(f'{name}: {count}' for name, count in mechanism['waits_peak'].items()) or '—',
]
],
)
lines += table(
['SQL (начало) по убыванию времени', 'вызовов за прогон', 'всего, ms', 'среднее, ms'],
[[row['query'], row['calls'], row['total_ms'], row['mean_ms']] for row in mechanism['statements']],
)
app = app_metrics_delta(samples)
for container, delta in sorted(app.items()):
lines.append(
f'- реплика {delta["instance_id"]}: latency p95 {delta["latency_ms"].get("p95")} ms, '
f'счётчики {json.dumps({name: value for name, value in delta["counters"].items() if name.startswith(("messages", "idempotency", "request_count"))}, ensure_ascii=False)}'
)
lines.append('')
write_markdown(TRACK1_DIR / 'summary-mechanism.md', 'Разрез «почему»: где теряется время на одном темпе', lines)
def write_markdown(path: Path, title: str, lines: list[str]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(f'# {title}\n\n' + '\n'.join(lines) + '\n', encoding='utf-8')
@@ -1157,6 +1332,7 @@ def cmd_check(args) -> None:
'instances': counts,
'replicas': {name: info for name, info in replica_map().items()},
'captured_at': now_iso(),
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
}
print(json.dumps(payload, ensure_ascii=False, indent=1))
write_json(LEVEL4_DIR / 'spread.json', payload)
@@ -1173,7 +1349,12 @@ def cmd_check(args) -> None:
env={**os.environ, 'API_BASE_URL': BASE_URL},
)
output = result.stdout + result.stderr
(LEVEL4_DIR / 'idempotency-concurrency.txt').write_text(output, encoding='utf-8')
stamp = (
f'=== e2e-фильтр идемпотентности (конкурентный повтор через LB)\n'
f'captured_at {now_iso()}\n'
f'commit {run_command(["git", "rev-parse", "HEAD"], check=False).stdout.strip()}\n\n'
)
(LEVEL4_DIR / 'idempotency-concurrency.txt').write_text(stamp + output, encoding='utf-8')
print(output[-1500:])
if result.returncode != 0:
raise SystemExit('idempotency concurrency suite failed')
@@ -1195,6 +1376,7 @@ def cmd_run(args) -> None:
overrides['API_TOTAL_CPUS'] = str(args.api_total_cpus)
if args.pg_cpus:
overrides['PG_CPUS'] = str(args.pg_cpus)
overrides['LOADGEN_MEMORY'] = args.loadgen_memory
ensure_stand(overrides)
profile = args.profile
ladder = [int(value) for value in args.ladder.split(',')] if args.ladder else None
@@ -1208,6 +1390,7 @@ def cmd_run(args) -> None:
mode='read' if args.mode == 'read' else None,
spread=args.spread,
warmup=not args.no_warmup,
vus={'max': args.max_vus, 'pre': args.pre_vus},
)
print(json.dumps(summary, ensure_ascii=False, indent=1))
@@ -1482,8 +1665,20 @@ def failover_once(target: str, args, config: dict) -> dict:
command_offset = probe_offset(probe, command_moment)
exit_offset = probe_offset(probe, exit_moment)
outage_start = first_success_after_exit if first_success_after_exit is None else exit_offset
# Окно отсутствия реплики: от выхода контейнера до первого успешного ответа
# после него. Если успех не наступил (проба не восстановилась), окно тянется
# до конца наблюдения — иначе метрика «во время отказа» выродилась бы в точку.
outage_start = (
first_success_after_exit if first_success_after_exit is not None else last_offset_before_stop(probe, exit_offset)
)
last_offset = probe.samples[-1]['t'] if probe.samples else exit_offset
# Два окна, чтобы метрика не вырождалась:
# - «остановка и дрейн»: от команды docker stop до первого успеха после выхода контейнера;
# - «реплики нет»: от выхода контейнера до первого успеха после него
# (при корректном дреине это доли секунды — так и должно быть).
stop_window_end = (
first_success_after_exit if first_success_after_exit is not None else last_offset
)
phases = {
'stop_command_at': stop_at,
'stop_exit_code': stop.returncode,
@@ -1494,6 +1689,8 @@ def failover_once(target: str, args, config: dict) -> dict:
'restore_at': restore_at,
'replica_rejoined_s': recovered,
'lb_down_at': lb_down_time(samples, address),
'stop_window_seconds': round(stop_window_end - command_offset, 2),
'absent_window_seconds': round(outage_start - exit_offset, 2),
'probe_offsets': {
'stop_command': round(command_offset, 2),
'container_exit': round(exit_offset, 2),
@@ -1516,8 +1713,12 @@ def failover_once(target: str, args, config: dict) -> dict:
'failures': len(failures),
'confirmed': len(probe.confirmed),
'rps_before': phase_rps(probe.samples, 0.0, command_offset),
'rps_stop_window': phase_rps(probe.samples, command_offset, stop_window_end),
'rps_while_stopped': phase_rps(probe.samples, exit_offset, outage_start),
'rps_after': phase_rps(probe.samples, outage_start, last_offset),
'errors_stop_window': sum(
1 for sample in failures if command_offset <= sample['t'] <= stop_window_end
),
'errors_while_stopped': sum(
1 for sample in failures if exit_offset <= sample['t'] <= outage_start
),
@@ -1547,6 +1748,11 @@ def probe_offset(probe: MessageProbe, moment: float) -> float:
return probe.samples[0]['t'] + (moment - probe.started_monotonic)
def last_offset_before_stop(probe: MessageProbe, exit_offset: float) -> float:
"""Конец наблюдения, если после выхода контейнера успехов не было."""
return probe.samples[-1]['t'] if probe.samples else exit_offset
def lb_down_time(samples: list[dict], address: str) -> str | None:
for record in samples:
if record.get('source') != 'haproxy' or record.get('server') in ('FRONTEND', 'BACKEND'):
@@ -1562,7 +1768,14 @@ def phase_rps(samples: list[dict], start: float, end: float) -> float:
def write_failover_evidence(results: list[dict]) -> None:
write_json(LEVEL4_DIR / 'failover-sweep.json', results)
write_json(
LEVEL4_DIR / 'failover-sweep.json',
{
'captured_at': now_iso(),
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
'results': results,
},
)
lines = table(
[
'реплика',
@@ -1575,7 +1788,9 @@ def write_failover_evidence(results: list[dict]) -> None:
'реплика вернулась, s',
'LB DOWN',
'RPS до',
'RPS в отказе',
'RPS в окне остановки',
'ошибок в окне',
'RPS без реплики',
'RPS после',
'k6 RPS',
'k6 ошибок',
@@ -1594,6 +1809,8 @@ def write_failover_evidence(results: list[dict]) -> None:
result['phases']['replica_rejoined_s'],
(result['phases']['lb_down_at'] or '-')[11:19],
result['probe']['rps_before'],
result['probe']['rps_stop_window'],
result['probe']['errors_stop_window'],
result['probe']['rps_while_stopped'],
result['probe']['rps_after'],
result['k6']['achieved_rps'],
@@ -1607,10 +1824,11 @@ def write_failover_evidence(results: list[dict]) -> None:
lines += [
'',
'Проба: последовательные POST с интервалом 0.2 s, при неопределённом результате '
'повтор с тем же Idempotency-Key (как у реального клиента). Окно отсутствия реплики '
'считается от выхода контейнера до первого успешного ответа после него; дрейн перед '
'остановкой специально переживает обнаружение отказа LB, поэтому клиент не обязан '
'видеть ошибки. Потери и дубли проверяются по истории чата.',
'повтор с тем же Idempotency-Key (как у реального клиента). «Окно остановки» — от '
'команды docker stop до первого успеха после выхода контейнера (сюда попадает дрейн); '
'«RPS без реплики» — от выхода контейнера до первого успеха после него, при корректном '
'дреине это доли секунды. Ошибок не должно быть ни в одном из окон, потери и дубли '
'проверяются по истории чата.',
]
write_markdown(LEVEL4_DIR / 'failover-sweep.md', 'Отказ каждой реплики под нагрузкой', lines)
@@ -1648,6 +1866,7 @@ def cmd_rolling(args) -> None:
started = now_iso()
steps = []
for step in range(replicas):
step_started = time.monotonic()
current = replica_map()
known = set(current)
# Меняем самую «старую» реплику: только что созданная видна как самая молодая.
@@ -1662,6 +1881,7 @@ def cmd_rolling(args) -> None:
steps.append(
{
'step': step + 1,
'replacement_seconds': round(time.monotonic() - step_started, 2),
'old_instance': target,
'old_container': container[:12],
'old_build_id': old_build,
@@ -1702,6 +1922,9 @@ def cmd_rolling(args) -> None:
finished = now_iso()
payload = {
'build_id': build_id,
'captured_at': now_iso(),
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
'replacement_seconds': [step['replacement_seconds'] for step in steps],
'image_id': image_id,
'image': config['API_IMAGE'],
'replicas': replicas,
@@ -1716,8 +1939,18 @@ def cmd_rolling(args) -> None:
if summary:
write_raw('rolling', summary, samples, config, started, finished, {'steps': steps}, sampler.errors)
lines = table(
['шаг', 'было', 'BUILD_ID до', 'стало', 'BUILD_ID после'],
[[step['step'], step['old_instance'][:12], step['old_build_id'], step['new_instance'][:12], step['new_build_id']] for step in steps],
['шаг', 'было', 'BUILD_ID до', 'стало', 'BUILD_ID после', 'замена, s'],
[
[
step['step'],
step['old_instance'][:12],
step['old_build_id'],
step['new_instance'][:12],
step['new_build_id'],
step['replacement_seconds'],
]
for step in steps
],
)
lines += [
f'5xx от API во время rolling update: {len(server_failures)} из {len(probe.samples)} попыток',
@@ -1761,29 +1994,49 @@ def wait_for_new_replica(replicas: int, known: set[str], timeout: float = 180) -
def cmd_ab(args) -> None:
sides = {'A': args.before, 'B': args.after}
# Бюджет A/B фиксируется явно: иначе точки унаследуют конфигурацию предыдущих
# серий (именно так ранние прогоны A/B уехали на удвоенный API/PG и пул 20),
# и числа станут несравнимы с базовыми прогонами той же серии.
plan = {
'API_REPLICAS': str(args.replicas),
'API_TOTAL_CPUS': str(args.api_total_cpus),
'API_TOTAL_MEMORY_MB': str(args.api_total_memory_mb),
'PG_CPUS': str(args.pg_cpus),
'DATABASE_POOL_MAX': str(args.pool),
'LB_CPUS': str(args.lb_cpus),
'LOADGEN_CPUS': str(args.loadgen_cpus),
'LOADGEN_MEMORY': args.loadgen_memory,
}
log(f'A/B на бюджете: {plan}')
for rep in range(1, args.reps + 1):
order = ['A', 'B'] if rep % 2 else ['B', 'A']
for side in order:
ensure_stand({'API_IMAGE': sides[side], 'API_REPLICAS': str(args.replicas)})
run_measured(f'ab#{side}#rep{rep}', args.profile, warmup=not args.no_warmup)
report_ab(args)
ensure_stand({**plan, 'API_IMAGE': sides[side]})
run_measured(
f'{args.prefix}#{side}#rep{rep}',
args.profile,
warmup=not args.no_warmup,
vus={'max': args.max_vus},
)
report_ab(args, plan)
def report_ab(args=None) -> None:
labels = [label for label in raw_labels() if label.startswith('ab#')]
def report_ab(args=None, plan: dict | None = None) -> None:
prefix = getattr(args, 'prefix', 'ab') if args else 'ab'
labels = [label for label in raw_labels() if label.startswith(f'{prefix}#')]
groups = group_configurations(labels)
lines = []
verdicts = []
series_by_side = {
side: summarise_series(groups.get(f'ab#{side}', [])) for side in ('A', 'B')
side: summarise_series(groups.get(f'{prefix}#{side}', [])) for side in ('A', 'B')
}
images = {
side: (getattr(args, side.lower(), None) if args else None) for side in ('A', 'B')
}
for side in ('A', 'B'):
if not images[side] and groups.get(f'ab#{side}'):
if not images[side] and groups.get(f'{prefix}#{side}'):
manifest = read_json(
RAW_DIR / f'{groups[f"ab#{side}"][-1]}.manifest.json', {}
RAW_DIR / f'{groups[f"{prefix}#{side}"][-1]}.manifest.json', {}
)
images[side] = (manifest.get('stand') or {}).get('API_IMAGE')
for rate in sorted({row['rate'] for row in series_by_side['A']['rows']}):
@@ -1831,15 +2084,30 @@ def report_ab(args=None) -> None:
'',
'Правило подтверждения: медиана меняется ≥5 % и диапазоны min/max повторов не перекрываются.',
]
suffix = '' if prefix == 'ab' else f'-{prefix}'
write_json(
TRACK1_DIR / 'ab-verdict.json',
TRACK1_DIR / f'ab-verdict{suffix}.json',
{
'verdicts': verdicts,
'ceiling': {side: series_by_side[side]['ceiling_rps'] for side in ('A', 'B')},
'prefix': prefix,
'images': images,
'budget': plan
or (
read_json(RAW_DIR / f'{groups[f"{prefix}#A"][-1]}.manifest.json', {}).get('stand')
if groups.get(f'{prefix}#A')
else None
),
'rule': 'медиана меняется ≥5 % и диапазоны min/max повторов не пересекаются',
'captured_at': now_iso(),
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
},
)
write_markdown(TRACK1_DIR / 'summary-ab.md', 'A/B: подтверждённое улучшение', lines)
write_markdown(
TRACK1_DIR / f'summary-ab{suffix}.md',
f'A/B: подтверждённое улучшение ({prefix})',
lines,
)
# ---------------------------------------------------------------- анализ и графики
@@ -1877,6 +2145,7 @@ def cmd_analyze(args) -> None:
analyse_series_a(groups, labels)
analyse_diagnostics(groups, labels)
analyse_growth(groups, labels)
analyse_mechanism(groups, labels)
if groups.get('ab#A') or groups.get('ab#B'):
report_ab()
make_graphs(groups, labels)
@@ -1895,9 +2164,10 @@ def analyse_runs(groups: dict) -> None:
series = summarise_series(group)
label = representative(group)
_, samples, manifest = load_raw(label)
lines += [f'## {key} ({len(group)} прогонов, {series_kind(group)})', '']
reps_note = 'одиночный прогон' if len(group) == 1 else f'{len(group)} прогонов'
lines += [f'## {key} ({reps_note}, {series_kind(group)})', '']
lines += table(
['темп, req/s', 'достигнуто RPS', 'min..max', 'p95, ms', 'ошибок', 'VU', 'dropped'],
['темп, req/s', 'достигнуто RPS', 'min..max', 'p95, ms', 'ошибок', 'VU', 'dropped', '5xx', '4xx'],
[
[
row['rate'],
@@ -1907,6 +2177,8 @@ def analyse_runs(groups: dict) -> None:
row['failed'],
row['vus_active'],
read_json(RAW_DIR / f'{label}.k6.json', {}).get('dropped_iterations', 0),
row.get('status_5xx', 0),
row.get('status_4xx', 0),
]
for row in series['rows']
],
@@ -2397,6 +2669,77 @@ def cmd_track1(args) -> None:
cmd_quiesce(argparse.Namespace(action='down'))
def cmd_track1_extras(args) -> None:
"""Догоняющие серии трека 1: VU-своп, блоки «почему» и контрольный A/B.
Отдельные команды, потому что они отвечают на уточняющие вопросы (потолок
сервера или генератора, где теряется время, сравнение на бюджете по умолчанию),
а не строят базовую картину серии A.
"""
base = {
'API_TOTAL_MEMORY_MB': str(DEFAULT_STAND['API_TOTAL_MEMORY_MB']),
'LB_CPUS': str(DEFAULT_STAND['LB_CPUS']),
'LOADGEN_CPUS': str(args.loadgen_cpus),
'LOADGEN_MEMORY': args.loadgen_memory,
}
if args.part in ('all', 'vuswap'):
log('=== VU-своп: та же конфигурация, меняется только MAX_VUS')
for replicas in ('1', '4'):
for max_vus in (200, 900, 2000):
ensure_stand({**base, 'API_REPLICAS': replicas, 'API_TOTAL_CPUS': str(DEFAULT_STAND['API_TOTAL_CPUS']), 'PG_CPUS': str(DEFAULT_STAND['PG_CPUS']), 'DATABASE_POOL_MAX': str(DEFAULT_STAND['DATABASE_POOL_MAX'])})
run_measured(
f'vuswap#n{replicas}-vu{max_vus}',
'p-a',
ladder=[700, 900, 1100],
step_seconds=15,
warmup=False,
vus={'max': max_vus},
)
if args.part in ('all', 'why'):
log(f'=== блок «почему»: один темп {args.rate} req/s, {args.reps} повтора, интерливинг')
block = [
('n1', {'API_REPLICAS': '1', 'API_TOTAL_CPUS': '3.0', 'PG_CPUS': '1.5', 'DATABASE_POOL_MAX': '10'}),
('n4', {'API_REPLICAS': '4', 'API_TOTAL_CPUS': '3.0', 'PG_CPUS': '1.5', 'DATABASE_POOL_MAX': '10'}),
('n4-pg3', {'API_REPLICAS': '4', 'API_TOTAL_CPUS': '3.0', 'PG_CPUS': '3.0', 'DATABASE_POOL_MAX': '10'}),
('n4-api6', {'API_REPLICAS': '4', 'API_TOTAL_CPUS': '6.0', 'PG_CPUS': '1.5', 'DATABASE_POOL_MAX': '10'}),
('n4-pool20', {'API_REPLICAS': '4', 'API_TOTAL_CPUS': '3.0', 'PG_CPUS': '1.5', 'DATABASE_POOL_MAX': '20'}),
]
for rep in range(1, args.reps + 1):
order = block if rep % 2 else list(reversed(block))
for name, overrides in order:
ensure_stand({**base, **overrides})
run_measured(
f'{args.prefix}#{name}#rep{rep}',
'p-a',
rate=args.rate,
duration=args.duration,
warmup=False,
vus={'max': args.max_vus},
)
if args.part in ('all', 'abdiag'):
log('=== контрольный A/B на бюджете по умолчанию')
cmd_ab(
argparse.Namespace(
before=args.before,
after=args.after,
profile='p-b',
replicas=4,
reps=args.ab_reps,
no_warmup=False,
prefix='abdiag',
max_vus=900,
api_total_cpus=DEFAULT_STAND['API_TOTAL_CPUS'],
api_total_memory_mb=DEFAULT_STAND['API_TOTAL_MEMORY_MB'],
pg_cpus=DEFAULT_STAND['PG_CPUS'],
pool=DEFAULT_STAND['DATABASE_POOL_MAX'],
lb_cpus=DEFAULT_STAND['LB_CPUS'],
loadgen_cpus=args.loadgen_cpus,
loadgen_memory=args.loadgen_memory,
)
)
cmd_analyze(argparse.Namespace())
# ---------------------------------------------------------------- CLI
@@ -2427,6 +2770,9 @@ def build_parser() -> argparse.ArgumentParser:
run.add_argument('--lb-cpus', type=float, help='лимит CPU HAProxy')
run.add_argument('--api-total-cpus', type=float, help='суммарный бюджет CPU API (делится на реплики)')
run.add_argument('--pg-cpus', type=float, help='лимит CPU PostgreSQL')
run.add_argument('--loadgen-memory', default='256m', help='лимит памяти генератора (k6 OOM на медленной стороне)')
run.add_argument('--max-vus', type=int, help='MAX_VUS генератора (по умолчанию 200)')
run.add_argument('--pre-vus', type=int, help='PRE_VUS генератора (по умолчанию 60)')
run.add_argument('--mode', choices=['write', 'read'])
run.add_argument('--spread', choices=['spread', 'hot'])
run.add_argument('--no-warmup', action='store_true')
@@ -2474,6 +2820,15 @@ def build_parser() -> argparse.ArgumentParser:
ab.add_argument('--replicas', type=int, default=4)
ab.add_argument('--reps', type=int, default=3)
ab.add_argument('--no-warmup', action='store_true')
ab.add_argument('--api-total-cpus', type=float, default=DEFAULT_STAND['API_TOTAL_CPUS'])
ab.add_argument('--api-total-memory-mb', type=int, default=DEFAULT_STAND['API_TOTAL_MEMORY_MB'])
ab.add_argument('--pg-cpus', type=float, default=DEFAULT_STAND['PG_CPUS'])
ab.add_argument('--pool', type=int, default=DEFAULT_STAND['DATABASE_POOL_MAX'])
ab.add_argument('--lb-cpus', type=float, default=DEFAULT_STAND['LB_CPUS'])
ab.add_argument('--loadgen-cpus', type=float, default=DEFAULT_STAND['LOADGEN_CPUS'])
ab.add_argument('--loadgen-memory', default=DEFAULT_STAND['LOADGEN_MEMORY'])
ab.add_argument('--max-vus', type=int, default=1200)
ab.add_argument('--prefix', default='ab', help='префикс меток (различает серии A/B)')
ab.set_defaults(func=cmd_ab)
analyze = sub.add_parser('analyze', help='агрегаты и графики из raw')
@@ -2488,6 +2843,21 @@ def build_parser() -> argparse.ArgumentParser:
quiesce.add_argument('action', choices=['up', 'down', 'status'])
quiesce.set_defaults(func=cmd_quiesce)
extras = sub.add_parser('track1-extras', help='догоняющие серии трека 1 (VU-своп, блоки «почему», A/B на бюджете по умолчанию)')
extras.add_argument('--part', choices=['all', 'vuswap', 'why', 'abdiag'], default='all')
extras.add_argument('--rate', type=int, default=1500, help='темп блока «почему»')
extras.add_argument('--duration', type=int, default=60)
extras.add_argument('--reps', type=int, default=2)
extras.add_argument('--max-vus', type=int, default=900)
extras.add_argument('--prefix', default='why')
extras.add_argument('--ab-reps', type=int, default=3)
extras.add_argument('--before', default='mtusi-messenger:lab3-before')
extras.add_argument('--after', default='mtusi-messenger:lab3-after')
extras.add_argument('--loadgen-cpus', type=float, default=DEFAULT_STAND['LOADGEN_CPUS'])
extras.add_argument('--loadgen-memory', default=DEFAULT_STAND['LOADGEN_MEMORY'],
help='память генератора: при 900 VU и секундных задержках 256 MiB мало (k6 убивается OOM)')
extras.set_defaults(func=cmd_track1_extras)
track1 = sub.add_parser('track1', help='полная серия трека 1')
track1.add_argument('--reps', type=int, default=2)
track1.add_argument('--ab-before', default='mtusi-messenger:lab3-before')
+29 -8
View File
@@ -45,6 +45,12 @@ export function stepMetrics(rates, keyBuilder) {
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`),
};
@@ -164,6 +170,21 @@ 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);
@@ -180,10 +201,7 @@ export function writeIteration(data, metrics) {
tags: { rate: String(step.rate) },
},
);
step.requests.add(1);
step.duration.add(response.timings.duration);
if (response.status !== 201) step.failed.add(1);
step.vus.add(exec.instance.vusActive);
recordResponse(step, response, 201);
}
export function readIteration(data, metrics) {
@@ -196,10 +214,7 @@ export function readIteration(data, metrics) {
tags: { rate: String(step.rate) },
},
);
step.requests.add(1);
step.duration.add(response.timings.duration);
if (response.status !== 200) step.failed.add(1);
step.vus.add(exec.instance.vusActive);
recordResponse(step, response, 200);
}
function round(value, digits) {
@@ -218,6 +233,12 @@ export function summaryJson(data, metrics, rates, kind, 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),