forked from mtusi2026/mtusi2026lab3
Дополнить доказательства трека 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:
+407
-37
@@ -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
@@ -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),
|
||||
|
||||
Reference in New Issue
Block a user