diff --git a/.claude/rules/balancer.md b/.claude/rules/balancer.md index 257d229c..fa918c8c 100644 --- a/.claude/rules/balancer.md +++ b/.claude/rules/balancer.md @@ -157,7 +157,8 @@ paths: METH_POST { path_reg ^/api/v1/chats/[^/]+/attachments$ }` в `backend api`. Больше самого долгого молчания живой загрузки: до тела `2 × request_timeout_seconds + [uploads] wait_timeout_seconds` = 17 с - (вход, членство, ожидание места), после тела — проверка (до ~4 с) + + (вход, членство, ожидание места), а с закрытием соединения на зависшем сервере + (`DB_CLOSE_TIMEOUT_SECONDS`, вне срока блока) до 2 × (6 + 2) + 5 = 21 с; после тела — проверка (до ~4 с) + tx1 6 + PUT 5 + tx2 6 = 21 с, а ветка компенсации после неудачной tx2 — ещё DELETE 5, 26 с: брокера в пути нет (change `pipeline-reliability`, решение 11). Тело ограничивают @@ -166,7 +167,7 @@ paths: зависшей реплике 30 с до 504, а замеры `failover` рассчитаны на 10. Выражение повторяет путь ручки в `src/api/routers/v1/attachment.py`: при смене префикса API менять вместе. Наибольшая длительность загрузки - U = 17 + 30 + 26 ≈ 73 с < `ROLLOUT_DRAIN_TIMEOUT` 90 с; + U = 21 + 30 + 26 ≈ 77 с < `ROLLOUT_DRAIN_TIMEOUT` 90 с; `graceful_shutdown_seconds` прежний (8 с): `stop-one.sh` и `docker stop` — отказ, загрузка дольше 8 с обрывается, строку `pending` убирает уборщик. Проверка поведения — `driver.py lb-upload-timeouts`: diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index b23bc7a8..2430f9a5 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -548,14 +548,28 @@ design change `track2-reconcile-cost`, решения 1–3, 7–13. Метод `anon`, `oom_kill`), `mq` (метрики брокера, `missing`), `jobs.log` — `psql \watch`. `rabbitmqctl` стоит 0,5 с CPU брокера на вызов: им не опрашивать. Перезапуск сбрасывает cgroup того же контейнера: `overload.split_lives` — наибольшее и сумма по жизням. -- **Пометки:** `oom`, `worker_restart`, `failed` — результат настройки; `lost`, `stuck`, - `duplicate`, `sha_mismatch` — ненулевой код команды в конце метки, ячейки сняты; +- **Причины завершения** (verify S5): поток `Stand.death_events` (`docker events`: `oom`, + `kill`, `die` с кодом выхода), разбор — `overload.die_causes`. Проба Docker 29.9: ядро — + `oom` и `die` 137 в десятки мс; `docker kill` — `kill` с сигналом и `die`; процесс + обработки — `oom` без `die`. Столбцы `worker_die_oom`, `worker_die_command`, + `worker_die_other`, `worker_exit_codes`, `worker_oom_events`, `relay_restarts`, `relay_die`. + `oom_kill` — счётчик cgroup плюс подтверждённые завершения процесса 1, а не каждый + перезапуск. Перезапусков больше, чем `die` в потоке, — отказ: поток потерян. +- **Реплики в LB** считает `overload.lb_up_count`: только слоты-серверы, не `BACKEND`, `UP + 1/2` — ещё в балансировке; наименьшее — столбец `lb_up_min`. В метке `baseline` `lb_down` + не срабатывал: считал `BACKEND` третьей репликой. +- **Сверка принятых — в обе стороны** (verify S4): вложение стенда не из 202 и не из разогрева + — `unexpected_rows`; больше, чем 5xx и обрывов, — пометка `unexpected`. +- **Пометки:** `oom`, `worker_restart`, `worker_crash`, `failed` — результат настройки; `lost`, `stuck`, + `duplicate`, `sha_mismatch`, `unexpected` — ненулевой код команды в конце метки, ячейки сняты; `not_recovered`, `dropped`, `lb_down`, `host_swap`, `storage_down`. Запись «Started worker» не совпала с ячейкой — отказ. Тиков сэмплера нет 3 с в нагрузке — отказ. - **`RESUME=1`** — как у серий: тот же commit, готовая строка `cells.csv` — признак ячейки. - **Результаты:** `evidence/queue/<метка>/` — `meta.json`, `cells.csv` (новые столбцы — только в конец), `timeline.csv`, `summary.md`, четыре SVG, `raw/` — только итоги k6; - журналы не копируются, `.work/` удаляется. `quick-queue-*` — в `.gitignore`. + журналы не копируются, `.work/` удаляется. `quick-queue-*` — в `.gitignore`. Метка + `baseline` (`7999002`) снята раньше правок verify и не перезаписывается; для отчёта — + `baseline2`, столбцы правок есть только у неё. - **Время:** полный профиль — 57 ячеек, ~2 ч 10 мин; `queue_quick` — `s` (2, 2), `lp` (4, 4), предел 40 и без него, `kill-worker`, `w2-p256`, ~11 мин. Рабочий стенд — `make stop`. diff --git a/.claude/rules/service-layer.md b/.claude/rules/service-layer.md index 63e7e687..2582e096 100644 --- a/.claude/rules/service-layer.md +++ b/.claude/rules/service-layer.md @@ -131,8 +131,9 @@ paths: одного (проба: 2,3 тела против 1,19). `bytes` в `put` не передавать: botocore оборачивает его в `BytesIO` с общим буфером, и копия та же; - ожидание места, тело и проверка — до `created_at` строки `pending`: - граница живой загрузки уборщика (B = 17 с) от очереди и медленного - клиента не растёт (`settings.md`, «Уборщик»); + граница живой загрузки уборщика (B = 17 с по формуле кода, с закрытием соединения + до 21 с: `KNOWN_ISSUES.md`) от очереди и медленного клиента не растёт + (`settings.md`, «Уборщик»); - компенсация (design change `upload-consistency`, решение 1) — только удаление объекта staging и только при известном исходе, в `_mark_queued`: флаг «COMMIT отправлен» ставится прямо перед `commit()` и только при diff --git a/.claude/rules/settings.md b/.claude/rules/settings.md index 182445a0..a7c66d8d 100644 --- a/.claude/rules/settings.md +++ b/.claude/rules/settings.md @@ -189,8 +189,10 @@ API» называет все пять (с `max_unfinished_jobs`). - `max_unfinished_jobs` (int, `ge=0`, 250; 0 — без предела; design change `track1-queue-overload`, решения 1–2): при каком числе незавершённых заданий стенда (`queued` и `processing`) загрузка получает 429 `Retry-After: 5`. Выбран по худшему - классу: предел / потолок worker — срок ожидания, он меньше `[relay] - republish_after_seconds`; при другом числе worker предел другой. Разовая подмена — + измеренному классу: предел / потолок worker — срок ожидания, ~270 с. Файл на лимите + CPU процесса (15 с, scan bomb в пределах контракта) этим не покрыт и не мерился: + расчёт 250 × 15 с ≈ 1 ч разбора, при таком ожидании relay шлёт копии. При другом + числе worker предел другой. Разовая подмена — `UPLOADS__MAX_UNFINISHED_JOBS` (стенд отказов и профиль `uploads` — 0, пятый API стенда отказов — 3). `Retry-After` — константа `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS`; @@ -198,23 +200,25 @@ API» называет все пять (с `max_unfinished_jobs`). паролей 4 × 64 MiB + места до ~90 MiB при 40 клиентах ≈ 450 MiB; при 8 местах — ~530 MiB; - `wait_timeout_seconds` 5 — молчание реплики до тела `2 × [database] - request_timeout_seconds + wait_timeout_seconds` = 17 с меньше `timeout - server` LB пути загрузки (30 с, `balancer.md`); при смене любого из - них пересчитать цепочку. **Проверки соотношения при старте нет** (в + request_timeout_seconds + wait_timeout_seconds` = 17 с, а с закрытием соединения + на зависшем сервере (`DB_CLOSE_TIMEOUT_SECONDS`, вне срока блока) до 2 × (6 + 2) + + 5 = 21 с меньше `timeout server` LB пути загрузки (30 с, `balancer.md`); при смене + любого из них пересчитать цепочку. **Проверки соотношения при старте нет** (в отличие от grace уборщика): `timeout server` живёт в `haproxy.cfg`, и процесс API его не знает. Поэтому `wait_timeout_seconds` больше `30 − - 2 × request_timeout_seconds` = 18 с сервис примет молча, а ожидающая - загрузка получит 504 от LB вместо 429 реплики (design change + 2 × (request_timeout_seconds + закрытие)` = 14 с сервис примет молча, а ожидающая + загрузка может получить 504 от LB вместо 429 реплики (design change `upload-memory`, «Уточнения apply», п. 14). То же для молчания после тела (≈ 26 с): бо́льшие `request_timeout_seconds` и `[s3] timeout_seconds` выводят его за 30 с так же молча; - `body_timeout_seconds` 30 — один срок на всё тело с момента, как загрузка заняла место (не срок простоя: клиент по байту раз в 29 с - держал бы место вечно). Наибольшая длительность загрузки 17 + 30 + 26 - ≈ 73 с < `ROLLOUT_DRAIN_TIMEOUT` (90 с); -- **граница B уборщика прежняя** (17 с): ожидание места, тело и - проверка идут до `created_at` строки `pending`, а сроки tx1, PUT и tx2 - не менялись. Поэтому `[uploads]` в проверку grace уборщика не входит. + держал бы место вечно). Наибольшая длительность загрузки 21 + 30 + 26 + ≈ 77 с < `ROLLOUT_DRAIN_TIMEOUT` (90 с); +- **граница B уборщика прежняя** (17 с по формуле кода, с закрытием соединения до 21 + с): ожидание места, тело и проверка идут до `created_at` строки `pending`, а сроки + tx1, PUT и tx2 не менялись. Поэтому `[uploads]` в проверку grace уборщика не входит. + Закрытия формула не учитывает: при grace 900 с это неважно, `KNOWN_ISSUES.md`. ### Брокер и worker (с лабы 5) diff --git a/.claude/rules/student-tests.md b/.claude/rules/student-tests.md index 4b64084f..8da2c7ab 100644 --- a/.claude/rules/student-tests.md +++ b/.claude/rules/student-tests.md @@ -431,7 +431,7 @@ paths: клиентов за барьером, принято от K до K + 20), `test_backlog_off` (обычный API без предела); - девять сценариев `queue-overload` с открытой нагрузкой и счётчиками — исключения сверки: - `make bench_queue` → `evidence/queue/baseline/summary.md`. + `make bench_queue QUEUE_LABEL=baseline2` → `evidence/queue/baseline2/summary.md`. Проверки отказов реплик (остановка, kill, зависание, rolling update) — не pytest, а `make test-failover`, профиль `failover` стенда `bench/` diff --git a/.claude/rules/worker.md b/.claude/rules/worker.md index 1d88b523..9fa8aa51 100644 --- a/.claude/rules/worker.md +++ b/.claude/rules/worker.md @@ -86,7 +86,7 @@ change `async-attachments` (2, 6–8) и `pipeline-reliability` (1–9, 19). З копии потерянных). Конкуренция, которая не помещается в лимит памяти контейнера, — не только повторы `render_killed`: ядро может завершить и процесс 1, контейнер перезапускается, задания возвращаются по аренде (до 70 с). Защита — конкуренция, а - не `oom_score_adj`. Числа и проверка правила — метка `evidence/queue/baseline/`. + не `oom_score_adj`. Числа и проверка правила — метка `evidence/queue/baseline2/`. - **Варианты:** одно декодирование, `fit_size` (округление вниз, не `Image.thumbnail`). `draft` у JPEG — под самый большой нужный размер. Основа 1280 — для optimized и thumbnail; crop — из основы, если её короткая сторона ≥ 256, иначе diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index bbff7a83..f45d9496 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -208,7 +208,7 @@ python3 $D --port 8080 s3-idle # клиент S3 после ска python3 $D lb-upload-timeouts # сроки LB пути загрузки на заглушке: 202 после 12 с молчания, 504 через 10/30 с, 400 в формате контракта; ~35 с python3 $D --port 8080 defense-scenario # защита лабы 5: worker стоит, 202, 201, 409, 201, сообщение в очереди, рестарт, worker, ready, оригинал и три варианта; ~1,5 мин python3 $D --port 8080 defense-faults # шаг 4 защиты: crash до фиксации и до ack, relay убит до публикации и до отметки, replay; ~4 мин -make bench_queue_quick # шаг защиты «для 5 — выбранный эксперимент»: очередь под перегрузкой, ~11 мин (рабочий стенд — make stop); разбор — evidence/queue/baseline/summary.md +make bench_queue_quick # шаг защиты «для 5 — выбранный эксперимент»: очередь под перегрузкой, ~11 мин (рабочий стенд — make stop); разбор — evidence/queue/baseline2/summary.md python3 $D broker-check # брокер: образ, volume, порт, предел памяти, очередь, пароль только у rabbitmq, relay, worker, остановка с кодом 0; ~30 с python3 $D --port 8080 worker-process # процесс worker: PID 1, лимиты, Pillow, журнал, неверные настройки, остановка, рестарт хранилищ, остановка под нагрузкой; ~5 мин python3 $D --port 8080 relay-process # процесс relay: то же, окружение без S3 и Valkey; ~2 мин diff --git a/AGENTS.md b/AGENTS.md index 2fe9dd4f..996ed09c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -92,10 +92,10 @@ max_objects_per_second` (2000 объектов S3/с), отказ по пред `upload-consistency` — `storage-consistency`, с `async-attachments` — `attachment-processing`, `message-broker`, с `pipeline-reliability` — `job-outbox`, с `unit-of-work` — `unit-of-work`, с `track1-queue-overload` — `queue-overload`); -в `KNOWN_ISSUES.md` девять открытых записей (смесь версий при замене реплик на первый +в `KNOWN_ISSUES.md` десять открытых записей (смесь версий при замене реплик на первый релиз с обработкой; bootstrap после удаления bucket; уборщик -удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`; 504 LB на метаданных и скачивании вложения при зависшем PostgreSQL; ложный FAIL `driver.py reconcile-cycle` на наполненном стенде; память S3 на долго живущем стенде; остановка API при замороженном PostgreSQL дольше срока контейнера). Отчёт, evidence и рабочий план лабы 3 остались в её +удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`; 504 LB на метаданных и скачивании вложения при зависшем PostgreSQL; ложный FAIL `driver.py reconcile-cycle` на наполненном стенде; память S3 на долго живущем стенде; граница живой загрузки уборщика без закрытия соединения; остановка API при замороженном PostgreSQL дольше срока контейнера). Отчёт, evidence и рабочий план лабы 3 остались в её репозитории (`REPORT.md`, `evidence/`, `git show 063eedb:PLAN.md`). Стек: Python 3.12, uv, FastAPI, pydantic v2, pydantic-settings, structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore @@ -203,8 +203,8 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore неизвестен — объект не трогается (`service-layer.md`). Незавершённые загрузки убирает только уборщик — отдельный сервис `cleaner` на образе API, а не реплики: строки `pending` старше `[cleaner] - pending_grace_seconds` (900 с; больше границы живой загрузки 17 с, - иначе уборщик не стартует) под `FOR UPDATE SKIP LOCKED`, в два шага: + pending_grace_seconds` (900 с; больше границы живой загрузки 17 с по + формуле, с закрытием соединения до 21 с, иначе уборщик не стартует) под `FOR UPDATE SKIP LOCKED`, в два шага: пометка строки (`updated_at`) отдельной транзакцией, затем объект и строка одной транзакцией под блокировкой (объект раньше строки); помеченную строку `mark_queued` в `queued` не переводит, @@ -249,7 +249,8 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore с `Retry-After` без строки и объекта. Тело — не дольше `body_timeout_seconds` с момента места (иначе 400), в PUT уходит тот же `BytesIO` без второй копии (`service-layer.md`). Ожидание, тело и - проверка — до строки `pending`: граница B уборщика прежняя (17 с). + проверка — до строки `pending`: граница B уборщика прежняя (17 с по + формуле, с закрытием соединения до 21 с: `KNOWN_ISSUES.md`). Буфер приёма сокетов `api` — 512 KiB (`sysctls`), буфер отправки LB к реплике — 256 KiB, буфер приёма LB от клиента — 128 KiB; `timeout server` пути загрузки 30 с, остальных — 10 с; `ROLLOUT_DRAIN_TIMEOUT` 90 с (`balancer.md`, `docker.md`). @@ -512,7 +513,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `make bench_scaling_quick` | самопроверка серий: 1 × 1 и 2 × 1 при `max_connections` 50, короткие окна (~4 мин), метка `quick-scaling-<время>`, в git не идёт | | `make bench_uploads [UPLOADS_LABEL=...]` | уровень 4, память при одновременных загрузках (~50 мин, метка `baseline` по умолчанию; change `upload-memory`): стенд `mtusi-bench` с LB, одной репликой 1 CPU / 512 МБ без swap, PostgreSQL, Valkey и S3 рабочего стенда; варианты «до» (`Profile.uploads_before` — `04f8592`, commit переноса лабы 4: места загрузки уже есть, `bench.md`; `git archive`; commit вне истории — код 2), «без лимита» (1000 мест, без очереди) и «с лимитом» (по умолчанию) × тела PNG ~1 и ~10 MiB × 1 / 10 / 20 / 40 клиентов × 3 повтора, на прогон — новые реплика и volume S3; пик `memory.peak` окна со сбросом (сэмплер `peak`), `anon`, `sock`, OOM, ответы по кодам, загрузок/с, p50/p95/p99, пики S3 и LB, H1–H4 в сводке — `evidence/uploads/<метка>/`. Перед запуском — проверка хоста (`bench.md`), рабочий стенд — `make stop`, гипотезы закоммичены раньше | | `make bench_uploads_quick` | то же короче (~4,5 мин): «без лимита» и «с лимитом», 10 MiB, 1 / 10 / 40 клиентов, один повтор, метка `quick-uploads-<время>`, в git не идёт | -| `make bench_queue [QUEUE_LABEL=...] [RESUME=1]` | уровень 5, трек 1, очередь под перегрузкой (~2 ч 10 мин, метка `baseline`; change `track1-queue-overload`): стенд `mtusi-bench` с S3, брокером, relay, worker и уборщиком, настройки (1, 1), (2, 2), (4, 4), (2, 256) × классы `s`, `m`, `lj`, `lp` × 3 повтора и блоки предела, приёма, второго worker, KILL worker, рестарта брокера; на ячейку — свежий стенд, открытая модель, контрольный поток, разбор очереди, обход метаданных; `evidence/queue/<метка>/` (`meta.json`, `cells.csv`, `timeline.csv`, `summary.md` с H1–H9 и рекомендацией, SVG). Рабочий стенд — `make stop`, гипотезы закоммичены раньше метки | +| `make bench_queue [QUEUE_LABEL=...] [RESUME=1]` | уровень 5, трек 1, очередь под перегрузкой (~2 ч 10 мин, метка `baseline` по умолчанию, она занята: для отчёта — `QUEUE_LABEL=baseline2`; change `track1-queue-overload`): стенд `mtusi-bench` с S3, брокером, relay, worker и уборщиком, настройки (1, 1), (2, 2), (4, 4), (2, 256) × классы `s`, `m`, `lj`, `lp` × 3 повтора и блоки предела, приёма, второго worker, KILL worker, рестарта брокера; на ячейку — свежий стенд, открытая модель, контрольный поток, разбор очереди, обход метаданных; `evidence/queue/<метка>/` (`meta.json`, `cells.csv`, `timeline.csv`, `summary.md` с H1–H9 и рекомендацией, SVG). Рабочий стенд — `make stop`, гипотезы закоммичены раньше метки | | `make bench_queue_quick` | то же короче (~11 мин): `s` (2, 2), `lp` (4, 4), предел 40 и без него, `kill-worker`, `w2-p256`, один повтор, метка `quick-queue-<время>`, в git не идёт; шаг защиты «для 5» | | `make bench_plots LABELS="..." [PLOTS=scaling]` | графики SVG и сводка серий трека 1 из меток: R* от числа реплик, p95 от интенсивности, CPU по компонентам, эффективность и точка насыщения — `evidence/plots//` | | `make bench_ab BEFORE=... AFTER=... REAPPLY= [SERIES=...]` | «до» и «после» одного изменения подряд (два прогона `bench`): `bench` для `BEFORE`, commit доказательств, `git revert` commit отката `REAPPLY`, `bench` для `AFTER`; с `SERIES` — серия трека 1 вместо матрицы (`make bench_scaling`). Нужно чистое рабочее дерево; сама делает два коммита | diff --git a/KNOWN_ISSUES.md b/KNOWN_ISSUES.md index 7690c195..631a577c 100644 --- a/KNOWN_ISSUES.md +++ b/KNOWN_ISSUES.md @@ -165,6 +165,23 @@ пересоздания volume); при подтверждении — лимит 768 МБ или меньше `GOMEMLIMIT`. Метка `make bench_queue` этого не покажет: её ячейки идут на свежих volume. +## Граница живой загрузки уборщика не учитывает закрытие соединения + +- **Где:** `src/cleaner/main.py`, `live_upload_bound_seconds`; `openspec/specs/load-balancing/spec.md` + и `openspec/specs/service-configuration/spec.md` («17 с»). Найдено verify change + `track1-queue-overload` (S9). +- **Что:** формула `2 × request_timeout_seconds + [s3] timeout_seconds` = 17 с не считает закрытие + соединения на зависшем сервере (`DB_CLOSE_TIMEOUT_SECONDS`, 2 с: возврат соединения идёт вне срока + блока). Оценка сверху — 2 × (6 + 2) + 5 = 21 с. То же у молчания реплики до тела: 21 с вместо 17, но + оба меньше `timeout server` 30 с, поэтому цепочка LB верна. +- **Чем грозит:** проверка старта пропускает grace от 18 до 21 с. При 900 с по умолчанию разницы нет, + запас огромный. На стенде отказов grace 20 с: при зависшем PostgreSQL уборщик может взять строку ещё + живой загрузки, но данные не страдают: `mark_queued` помеченную строку не переводит, клиент получает + 503, объект удаляется. +- **Предложение:** прибавить `2 × DB_CLOSE_TIMEOUT_SECONDS` в формулу и поднять grace стенда отказов до + 22 с и больше, отдельным change; там же поправить «17 с» в спеках. Правка меняет код уборщика и стенд + отказов, в `track1-queue-overload` не входит. + ## Остановка API при замороженном PostgreSQL дольше срока контейнера - **Где:** `src/main.py`, `await engine.dispose()` в lifespan без общего срока. Найдено diff --git a/QUESTIONS.md b/QUESTIONS.md index 2d3a4031..c9245d4a 100644 --- a/QUESTIONS.md +++ b/QUESTIONS.md @@ -43,7 +43,7 @@ Прогон их не удалял. Перед удалением убедиться, что контейнеров на них нет (`docker ps -a --filter volume=<имя>`), затем `docker volume rm <имя>`. - `make student_test` красный по `test_exclusion_evidence_exists` не только из-за - `evidence/queue/baseline/summary.md`: в репозитории нет и `evidence/auth/passwords-and-tokens.md`, + `evidence/queue/baseline2/summary.md`: в репозитории нет и `evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md` (их нет и на `5b5f59a`; снимаются по AGENTS.md, «Переход в следующую лабу»). Стадия apply в `evidence/` не пишет: снять перед отчётом. @@ -229,7 +229,7 @@ ## track1-queue-overload -Подробности и отвергнутые варианты — `openspec/changes/track1-queue-overload/design.md`; пробы — его раздел «Пробы» (проект compose `q1probe`, образ `git archive 5a97416`, файлы в scratchpad). Это пробы, а не результат: результат даст метка `evidence/queue/baseline/`. +Подробности и отвергнутые варианты — `openspec/changes/track1-queue-overload/design.md`; пробы — его раздел «Пробы» (проект compose `q1probe`, образ `git archive 5a97416`, файлы в scratchpad). Это пробы, а не результат: результат даст метка `evidence/queue/baseline2/` (`evidence/queue/baseline/` снята раньше правок verify). ### Решения @@ -249,6 +249,10 @@ - **Apply: доля второго worker считается только по разбору накопленного,** без окна `after`: иначе H3 ложно не подтверждалась бы. Порог не менялся (там же, п. 2). - **Apply: CPU окна — с интерполяцией на краях;** разность только по внутренним отсчётам занижала его на ~10 % (там же, п. 3). - **Apply: блоки, которых нет в быстром профиле, проверены разово** скриптом в scratchpad поверх `run.main` (там же, п. 4). +- **Правки verify: `oom` — только подтверждённое завершение ядром.** Причина — события Docker (`oom`, `kill`, `die` с кодом), столбцы `worker_die_*`; `oom_kill` больше не прибавляет каждый перезапуск. На этом считаются H2 и правило рекомендации; условия гипотез не менялись, а смысл стал тем, что в них написано (design, «Уточнения apply», п. 8). Осталось открытым: перезапуск не от ядра условия правила не нарушает, только пометка `worker_crash` (вопрос 3). +- **Правки verify: настройка, снятая не на всех классах, не кандидат в рекомендацию.** Порог 90 % не менялся. По плану это (1, 1) и (2, 256): «наименьшая конкуренция» теперь выбирается только между (2, 2) и (4, 4), а (1, 1) может быть только названа. Метка `baseline` даёт тот же итог (2, 2) (там же, п. 9). +- **Правки verify: лишняя строка в базе — отказ метки, как `lost`, но условие H6 не расширено:** пометка `unexpected` вне записанного до метки списка H6; строка, которую объясняет 5xx или обрыв, пометку не даёт (там же, п. 10). +- **Правки verify: `UP 1/2` — реплика ещё в балансировке:** она получает запросы, `lb_down` на неё не срабатывает. Опора — сценарий «реплики MUST NOT выводиться из балансировщика» (там же, п. 11). ### Вопросы @@ -256,3 +260,7 @@ 1. Предел незавершённых заданий: 429 или 503? Контракт называет 429 «ограничением частоты запросов», а здесь ограничено количество принятой работы; 503 в нём — «зависимость недоступна». Сделано: 429 `rate_limited` с `Retry-After` — как у занятых мест загрузки (вопрос 1 в отчёте), зависимости живы, и реплика остаётся готовой. Другой ответ меняет строку `DOMAIN_ERRORS` и сценарии. 2. Рубрика уровня 3 показывает «worker остановлен → upload 202», а трек 1 требует ограничить принятую работу. Как долго загрузка обязана отвечать 202 при остановленном worker? Сделано: пока незавершённых меньше предела (250); дальше 429, а текст, история, метаданные, готовые байты и `/health/ready` работают. Сценарий защиты грузит единицы файлов. Другой ответ — значение настройки. + +Вопрос пользователю (основной сессии), прогон не останавливает: + +3. Правило рекомендации требует «без `oom` и `failed`». После правки S5 аварийный перезапуск worker не от ядра (`worker_crash`) это условие не нарушает: раньше такой перезапуск считался `oom` косвенно. Условие не менялось, потому что записано до метки. В метке таких случаев не ждём (пробы: только ядро). Появится — считать настройку некандидатом? Сейчас: пометка в сводке, решение — в отчёте. diff --git a/REPORT.md b/REPORT.md index 4ce5e9d8..9cfda28c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -495,6 +495,16 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку Трек 1 уровня 5, change `track1-queue-overload`. **Код метки — commit `d667fa3`, сама метка `baseline` — commit `7999002`** (`dirty` false, 57 ячеек из 57, 2 ч 05 мин, `swapouts_delta` 0, сна нет, питание от сети, предупреждений о хосте нет, посторонние контейнеры `domains-*` названы в паспорте). Гипотезы и правило записаны и закоммичены раньше метки. Числа порогов — из проб стадии propose (design, раздел «Пробы»); числа результатов ниже — из `evidence/queue/baseline/summary.md` и `evidence/queue/baseline/cells.csv`. +**Метка переснимается как `baseline2`.** Проверка нашла ошибки инструмента, которые нельзя поправить задним числом, поэтому метка снимается целиком заново на коммите с правками. Каталог `baseline` остаётся в репозитории как снятый раньше, с кодом и порогами в прежнем виде: числа ниже — пока его. Что неверно в `baseline`: + +- `lb_down` считал строку `BACKEND` репликой, и выход одной реплики не срабатывал: условие H7 «`lb_down` нет» метка не проверяла; +- `cpu_worker_per_job_s` занижен на ~8–12 %: CPU до конца восстановления делился на все `ready`, включая окно `after`; +- каждый перезапуск worker считался завершением ядром: причина в метке не проверялась; +- queue lag есть только на ячейку, а не по окнам, в сводке его нет; CPU и троттлинг — не по всем окнам и ролям; +- нет счётчика перезапусков relay, лишние строки в базе не искались. + +Пороги H1–H9 и порог правила рекомендации не менялись. + **Главное.** Подтверждены H1, H2, H3, H5, H6, H7, H8, H9, **H4 не подтверждена** (2 ячейки из 33 ниже порога, причина — разбор ниже). Рекомендация правила — (2, 2), значения по умолчанию оставлены. Конкуренция сверх двух при 1 CPU не ускоряет, а на `lp` (4, 4) ломает обработку: 16 перезапусков worker за три ячейки и 2 принятых задания в `failed`. Настоящее ускорение даёт второй worker. **Команда:** `make bench_queue` (метка `baseline`, ~2 ч 10 мин, `RESUME=1`), самопроверка — `make bench_queue_quick` (~11 мин, метка в git не идёт). @@ -524,8 +534,10 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку | `oldest_s` | возраст старейшего незавершённого | PostgreSQL | | Throughput | вложений с `updated_at` статуса `ready` в окне `over` и в окне `recovery`, делённые на длину окна | `GET /attachments/{id}` | | Время до `ready` | `updated_at` у `ready` минус момент ответа 202; p50, p95, p99 по окну прихода; `before` и `after` — повторы сводятся вместе | `GET /attachments/{id}`, k6 | +| Queue lag | возраст старейшего незавершённого, пик по окну тика (`peak_oldest_<окно>_s`), и время задания от подтверждения брокером до взятия, p50 и p95 по окну прихода (`queue_wait_<окно>_*_ms`) | PostgreSQL, журнал worker | | Восстановление | от последней загрузки окна `over` до нуля незавершённых | k6, PostgreSQL | | RSS | `VmHWM` процесса 1 worker, `render_peak_kib` процесса обработки (p50, наибольший), `memory.peak`, наибольшая `anon`, `oom_kill`; у перезапущенного контейнера — наибольшее и сумма по жизням | `/proc`, журнал, cgroup | +| Причина завершения worker | `worker_die_oom` (`oom` и код 137), `worker_die_command` (`kill`), `worker_die_other` (остальное, `worker_exit_codes`) | `docker events` | **Гипотезы.** @@ -543,7 +555,12 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку Вердикт считает `bench/overload.py` в сводке метки: «подтверждено», «нет», «нет данных». -**Правило рекомендации.** Кандидат — настройка без `oom` и `failed` ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а `prefetch` равен конкуренции. Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором `make bench_queue_quick`. Компромисс latency и ресурсов — вывод из таблиц метки; проверяемая формула: `concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса)`. +**Уточнения условий (пороги те же).** + +- **H3, доля второго worker.** Порог говорит «среди заданий, завершённых после его запуска», а код считает только до нуля незавершённых. Окно `after` к опыту не относится: оно приходит после разбора бэклога, большого prefetch уже нечем держать, и новые задания брокер делит поровну при любом `prefetch`. По оценке проверки буквальная доля при prefetch 256 была бы ~6,4–6,8 %, то есть при буквальном прочтении H3 — «нет». Порог не менялся; чтобы это было числом, а не оценкой, в `cells.csv` есть `second_share_all` (все завершённые после запуска) и `second_share_after` (доля в окне `after`); вердикт считает прежний `second_share`. +- **H2 и правило рекомендации — по подтверждённому `oom`.** В `baseline` любой перезапуск считался `oom`; в `baseline2` это только завершение, подтверждённое событиями Docker, или счётчик cgroup. Условия не менялись, смысл стал тем, что в них написано; аварийный перезапуск не от ядра — пометка `worker_crash`, условие правила он не нарушает (`QUESTIONS.md`, вопрос 3). + +**Правило рекомендации.** Кандидат — настройка без `oom` и `failed` ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а `prefetch` равен конкуренции. Настройка, снятая не на всех классах, не кандидат: по плану это (1, 1) и (2, 256), сводка их называет, порог 90 % прежний. Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором `make bench_queue_quick`. Компромисс latency и ресурсов — вывод из таблиц метки; проверяемая формула: `concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса)`. **Вердикты** (`evidence/queue/baseline/summary.md`, раздел «Гипотезы»). @@ -559,6 +576,8 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку | H8 | подтверждено | `kill-worker`: заданий с повтором 2 во всех повторах, восстановление 58,5 с; `restart-broker`: повторов 0, 5xx нет, восстановление 44,6 с | | H9 | подтверждено | первый `busy` на 3,1–3,3 с, первый `backlog` на 34,0–36,3 с; CPU S3 в первые 30 с 1,00; принято 306–309 за 45 с; пик 282–285; готовых/с 0,80–0,93 в окне и 2,87–2,97 после | +**Оговорка к H6: `lp` (4, 4).** Условие «p95 `after` ≤ 1,5 × p95 `before`» здесь проходит без смысловой нагрузки: p95 `before` по повторам — 83 с (`lp-c4p4-r3`: 83,27 с; r1 и r2 — 3,59 и 3,87 с), потому что окно `before` этого повтора задето OOM. Сравнивать тут не с чем: порог не меняется, но о возврате задержки на этой конфигурации условие ничего не доказывает. Что p95 `after` сам вернулся к 1,31–1,36 с, видно напрямую. + **Настройки и классы** (`evidence/queue/baseline/summary.md`, «Ячейки по конфигурациям»; медиана и min–max трёх повторов). «Процесс» — пик процесса обработки по его отчёту: p50 / наибольший. | Класс | (c, p) | Готовых/с: окно | восстановление | Пик незаверш. | Пик брокера | До `ready` over p50 / p95 / p99, с | Восст., с | `memory.peak`, МиБ | VmHWM, МиБ | Процесс, МиБ | CPU worker, S3 | Троттлинг worker | OOM | Перезапуски | @@ -661,7 +680,7 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку **Рекомендация и значения по умолчанию** (`evidence/queue/baseline/summary.md`, «Рекомендация»). Правило решения 12 даёт конкуренцию 2, prefetch 2. (1, 1) не кандидат: на `m` throughput ниже 90 % лучшей. (4, 4) не кандидат: на `lp` есть `oom` и `failed`. (2, 256) по правилу сводится к (2, 2): `prefetch` равен конкуренции. **Значения оставлены:** рекомендация совпала с (2, 2), поэтому условие смены не наступило и отдельного commit нет. Условия рекомендации: 1 CPU и 1 ГБ на worker. При другом лимите пересчитать по формуле выше; для потока только больших PNG (1, 1) экономит память без потери скорости, но это другая установка, а не значение по умолчанию. -**Предел 250 по измеренному потолку.** Обоснование решения 2 опиралось на пробу: потолок `lp` 0,92/с и ожидание ~270 с при границе 300 с (`[relay] republish_after_seconds`). Метка: потолок `lp` при (2, 2) — 0,96/с (`recovery`), 250 / 0,96 ≈ 260 с. **Совпало:** ожидание меньше 300 с, предел менять незачем. Запас меньше, чем кажется: с окном приёма (0,85/с) ~294 с, с превышением (пик до 290) ~302 с, то есть на самой границе. Выход за границу на (2, 2) не должен вредить: по правилу relay копии появляются, только если в очереди ноль готовых, а дубль — без эффекта. В метке копий 0, но `lp` у предела не снимался. +**Предел 250 по измеренному потолку.** Обоснование решения 2 опиралось на пробу: потолок `lp` 0,92/с и ожидание ~270 с при границе 300 с (`[relay] republish_after_seconds`). Метка: потолок `lp` при (2, 2) — 0,96/с (`recovery`), 250 / 0,96 ≈ 260 с. **Совпало только для измеренных классов:** ожидание меньше 300 с, предел менять незачем. Запас меньше, чем кажется: с окном приёма (0,85/с) ~294 с, с превышением (пик до 290) ~302 с при потолке `recovery` и ~341 с при потолке окна, то есть за границей. Выход за границу на (2, 2) копий не даёт: выданное сразу взято, а пока в брокере есть готовые, relay не публикует заново. При (2, 256) задания старше порога получат копию, эффект нулевой по пробе (188 копий на 150 заданий, лишнего эффекта 0). В метке копий 0, но `lp` у предела не снимался. | Класс | Потолок (2, 2), готовых/с | Ожидание у предела 250, с | Как получено | |---|---|---|---| @@ -718,7 +737,7 @@ Staging при заполненном пределе: 250 × 10 458 117 байт - **Лимит памяти на macOS.** `setrlimit(RLIMIT_AS)` на хосте macOS отказывает, консольный worker это пишет в журнал (`render_memory_limit_applied`); на стенде Linux лимит действует. - **Цена процесса на задание.** Метка `baseline`: CPU worker на задание при (2, 2) — 0,30 с на `s` и `m`, 0,39 на `lj`, 0,94 на `lp` (`evidence/queue/baseline/cells.csv`). Долю запуска процесса метка не выделяет, проба — ~100 мс на маленьком файле. Forkserver (9 мс) отвергнут сейчас: секреты родителя в окружении и свой жизненный цикл. Граница — один модуль. - **Изоляция секретов процесса обработки неполная.** В его окружении секретов нет, но он идёт под тем же UID, что процесс 1 worker, и может прочитать `/proc/1/environ` с ключами S3 и паролями PostgreSQL и брокера. От случайной утечки это защищает, после эксплойта декодера — нет. Предложение — `PR_SET_DUMPABLE=0` в процессе worker, вопрос преподавателю (`QUESTIONS.md`, `## pipeline-reliability`). -- **Дорогие файлы занимают worker.** Предел считает задания, а не байты и CPU: файл на границе контракта стоит ~1 с CPU, и поток таких файлов при 250 незавершённых ждёт ~260 с. Лимит на файл прежний — 15 с CPU. +- **Дорогие файлы занимают worker.** Предел считает задания, а не байты и CPU. Измерен файл на границе байтов и пикселей: ~1 с CPU, поток таких файлов при 250 незавершённых ждёт ~260 с. **Худший случай не измерен:** scan bomb в пределах контракта стоит лимит процесса, 15 с CPU, расчётом 250 × 15 с ≈ 1 час разбора и копии от relay при таком ожидании. Обоснование предела «ожидание меньше 300 с» верно только для измеренных классов, для этого файла — нет. Защиты, кроме лимита на файл, нет. - **Завершение процесса 1 worker ядром.** Конкуренция, которая не помещается в лимит памяти, стоит не только повторов: `lp` (4, 4) — 16 перезапусков за три прогона, задания ждут аренду 70 с, 2 из 188 ушли в `failed` `retry_exhausted`. Значение по умолчанию на всех классах помещается; правило подбора — раздел «Очередь под перегрузкой». - **Приём у границы байтов отнимает S3 у worker.** Готовых/с 0,80–0,93 вместо 2,87–2,97, пока S3 занят приёмом. Приоритета обработки нет, предел останавливает это на ~35-й секунде такой нагрузки. - **Предел мягкий и один на стенд.** Превышение — загрузки в полёте (измерено до 285 при пределе 250), справедливости между пользователями и чатами нет. diff --git a/bench/overload.py b/bench/overload.py index a62827f9..604195c7 100644 --- a/bench/overload.py +++ b/bench/overload.py @@ -12,7 +12,7 @@ import json import random import sys from collections.abc import Iterable, Mapping -from dataclasses import dataclass, field +from dataclasses import dataclass, field, replace from pathlib import Path from typing import Any @@ -33,9 +33,14 @@ ROLES = ( "cleaner", "haproxy", ) -# пометки, при которых метка не зелёная: система потеряла работу (решение 11) -FATAL_FLAGS = ("lost", "stuck", "duplicate", "sha_mismatch") +# условие H6, записанное до метки: состав не меняется +H6_FLAGS = ("lost", "stuck", "duplicate", "sha_mismatch") +# пометки, при которых метка не зелёная: система потеряла работу (решение 11) или +# в базе есть вложение, на которое никто не отвечал (verify S4) +FATAL_FLAGS = (*H6_FLAGS, "unexpected") DEFAULT_SETTING = (2, 2) +# `oom` и `die` одного завершения: на пробе ~50 мс, запас на нагруженную ВМ +OOM_DIE_WINDOW_S = 2.0 MIB = 2**20 CONFIRMED = "подтверждено" REFUTED = "нет" @@ -150,6 +155,28 @@ CELL_FIELDS = [ "swapouts", "lb_down", "flags", + # новые столбцы — только в конец (verify change track1-queue-overload) + *[f"queue_wait_{w}_{q}_ms" for w in WINDOWS for q in ("p50", "p95")], + *[f"peak_oldest_{w}_s" for w in CONTROL_WINDOWS], + "second_jobs_all", + "second_share_all", + "second_share_after", + *[f"cpu_{role}_{w}" for role in ROLES for w in ("before", "after")], + *[ + f"throttle_{role}_{w}" + for role in ROLES + for w in CONTROL_WINDOWS + if not (role in ("worker", "s3") and w == "over") + ], + "relay_restarts", + "relay_die", + "unexpected_rows", + "worker_die_oom", + "worker_die_command", + "worker_die_other", + "worker_exit_codes", + "worker_oom_events", + "lb_up_min", ] TIMELINE_FIELDS = [ "cell", @@ -288,6 +315,14 @@ class Sources: lb_down: bool = False storage_down: bool = False extra: dict[str, Any] = field(default_factory=dict) + docker_events: list[DockerEvent] = field(default_factory=list) + worker_name: str = "worker" + relay_name: str = "relay" + relay_restarts: int = 0 + lb_up_min: int | None = None + # все вложения стенда и разогрев: сверка в обратную сторону (verify S4) + db_ids: set[str] | None = None + warm_ids: set[str] = field(default_factory=set) def parse_uploads(text: str) -> tuple[float | None, list[Upload]]: @@ -481,6 +516,88 @@ def memory_by_lives( ) +def lb_up_count(rows: Iterable[Mapping[str, str]]) -> int: + """Реплик в балансировке в строках статистики одного тика LB: только слоты- + серверы, `BACKEND` и `FRONTEND` — не реплики. `UP 1/2` — проверка уже не + прошла, но реплика ещё получает запросы (verify C1).""" + return sum( + 1 + for row in rows + if row.get("svname") not in ("BACKEND", "FRONTEND") + and (row.get("status") or "").split(" ")[0] == "UP" + ) + + +def lb_up_min(lb: Mapping[int, list[dict[str, str]]]) -> int | None: + """Наименьшее число реплик в балансировке за все тики; тиков нет — `None`.""" + return min((lb_up_count(rows) for rows in lb.values()), default=None) + + +def lb_down(lb: Mapping[int, list[dict[str, str]]], replicas: int) -> bool: + """Реплика выходила из балансировки хотя бы на одном тике.""" + least = lb_up_min(lb) + return least is not None and least < replicas + + +@dataclass(frozen=True) +class DockerEvent: + """Событие `docker events` контейнера (часы ВМ).""" + + t: float + action: str + name: str + exit_code: str + signal: str + + +def parse_docker_events(text: str) -> list[DockerEvent]: + """Строки `<нс>|<действие>|<имя>|<код выхода>|<сигнал>`.""" + out = [] + for line in text.splitlines(): + parts = line.strip().split("|") + if len(parts) == 5 and parts[0].isdigit(): + out.append( + DockerEvent(int(parts[0]) / 1e9, *parts[1:]), + ) + return sorted(out, key=lambda event: event.t) + + +def die_causes(events: Iterable[DockerEvent], name: str) -> dict[str, Any]: + """Причины завершений контейнера (verify S5). Проба на Docker 29.9: ядро — + `oom`, затем `die` с кодом 137 в те же десятки мс; `docker kill` — `kill` с + сигналом, затем `die`; завершение процесса обработки — `oom` без `die`. + Поэтому `command` — был `kill` с прошлого `die`, `oom` — код 137 рядом с + `oom`, `other` — всё остальное, по кодам выхода.""" + own = [event for event in events if event.name == name] + ooms = [event.t for event in own if event.action == "oom"] + causes: dict[str, Any] = { + "oom": 0, + "command": 0, + "other": 0, + "die": 0, + "codes": {}, + "oom_events": len(ooms), + } + killed = False + for event in own: + if event.action == "kill": + killed = True + elif event.action == "die": + causes["die"] += 1 + if killed: + causes["command"] += 1 + elif event.exit_code == "137" and any( + abs(event.t - moment) <= OOM_DIE_WINDOW_S for moment in ooms + ): + causes["oom"] += 1 + else: + causes["other"] += 1 + code = event.exit_code or "-" + causes["codes"][code] = causes["codes"].get(code, 0) + 1 + killed = False + return causes + + def events( records: Iterable[Mapping[str, Any]], name: str, @@ -629,16 +746,43 @@ def cell_row(cell: Mapping[str, Any], src: Sources) -> dict[str, Any]: # только основной контейнер worker: лимит памяти у второго свой peak_mem, anon_mem, kills = memory_by_lives(src.mp.get("worker", [])) # процесс 1, завершённый ядром, уносит cgroup раньше следующего тика: его - # счётчик не прочитать, а политика перезапускает только аварийный выход - kills += src.restarts + # счётчик не прочитать, поэтому — завершения, подтверждённые событиями Docker + causes = die_causes(src.docker_events, src.worker_name) + relay_causes = die_causes(src.docker_events, src.relay_name) + kills += causes["oom"] per_job = None delta = lives_delta( [life for lives in worker_lives for life in lives], src.t0, recovery_end, ) - if delta is not None and ready_at: - per_job = round(delta / 1e6 / len(ready_at), 3) + # CPU считается до конца восстановления, значит, и задания — до него: окно + # after в этот счёт не входит (verify W2) + ready_inside = sum(1 for moment in ready_at if moment <= recovery_end) + if delta is not None and ready_inside: + per_job = round(delta / 1e6 / ready_inside, 3) + + after_start = src.extra.get("after_start") + after_end = src.extra.get("after_end") + bounds = { + "before": (src.t0, over_start), + "over": (over_start, over_end), + "recovery": (over_end, recovery_end), + "after": (after_start or recovery_end, after_end or recovery_end), + } + # queue lag по окнам: ожидание задания — по окну его прихода, возраст + # старейшего — по окну тика (решение 7, verify W1) + arrival = {u.attachment_id: u.window for u in accepted} + waits_by_window: dict[str, list[float]] = {w: [] for w in WINDOWS} + for item in started_jobs: + window = arrival.get(str(item.get("attachment_id"))) + if window and item.get("queue_wait_ms") is not None: + waits_by_window[window].append(float(item["queue_wait_ms"])) + unexpected = None + if src.db_ids is not None: + unexpected = len( + src.db_ids - {u.attachment_id for u in accepted} - src.warm_ids, + ) row: dict[str, Any] = { key: cell.get(key) @@ -774,41 +918,70 @@ def cell_row(cell: Mapping[str, Any], src: Sources) -> dict[str, Any]: "second_jobs": len(second_ready) if src.second_records else None, "swapouts": src.swapouts, "lb_down": int(src.lb_down), + "relay_restarts": src.relay_restarts, + "relay_die": relay_causes["die"], + "unexpected_rows": unexpected, + "worker_die_oom": causes["oom"], + "worker_die_command": causes["command"], + "worker_die_other": causes["other"], + "worker_exit_codes": json.dumps(causes["codes"], sort_keys=True), + "worker_oom_events": causes["oom_events"], + "lb_up_min": src.lb_up_min, }, ) for window in WINDOWS: for q in (50, 95, 99): row[f"ready_{window}_p{q}_s"] = percentile(waits[window], q) + for q in (50, 95): + row[f"queue_wait_{window}_p{q}_ms"] = percentile( + waits_by_window[window], + q, + 0, + ) + for window, (w0, w1) in bounds.items(): + row[f"peak_oldest_{window}_s"] = max( + (t.oldest_s for t in src.jobs if w0 <= t.t < w1), + default=None, + ) for role in ROLES: lives = src.cg.get(role, []) + flat = [life for each in lives for life in each] row[f"cpu_{role}_over"] = role_cores(lives, over_start, over_end) row[f"cpu_{role}_recovery"] = role_cores(lives, over_end, recovery_end) - for role in ("worker", "s3"): - row[f"throttle_{role}_over"] = throttle_share( - [life for lives in src.cg.get(role, []) for life in lives], - over_start, - over_end, - ) + for window in ("before", "after"): + row[f"cpu_{role}_{window}"] = role_cores(lives, *bounds[window]) + for window, (w0, w1) in bounds.items(): + row[f"throttle_{role}_{window}"] = ( + throttle_share(flat, w0, w1) if w1 > w0 else None + ) action_at = src.extra.get("second_started_at") if action_at is not None and src.second_records: - # только разбор накопленного: окно after делится поровну при любом - # prefetch и смазывало бы опыт (design, «Уточнения apply», п. 2) - def in_backlog(item: Mapping[str, Any]) -> bool: - moment = reconcile.timestamp(item["timestamp"]) - return action_at <= moment <= recovery_end - after = sum(1 for item in both_ready if in_backlog(item)) - taken = sum(1 for item in second_ready if in_backlog(item)) - row["second_jobs"] = taken - row["second_share"] = round(taken / after, 3) if after else None - after_start = src.extra.get("after_start") - after_end = src.extra.get("after_end") - bounds = { - "before": (src.t0, over_start), - "over": (over_start, over_end), - "recovery": (over_end, recovery_end), - "after": (after_start or recovery_end, after_end or recovery_end), - } + def done_at(item: Mapping[str, Any]) -> float: + return reconcile.timestamp(item["timestamp"]) + + def share(items: list[Mapping[str, Any]], total: int) -> float | None: + return round(len(items) / total, 3) if total else None + + # столбец порога H3 — только разбор накопленного: окно after делится + # поровну при любом prefetch (design, «Уточнения apply», п. 2) + backlog_all = [ + i for i in both_ready if action_at <= done_at(i) <= recovery_end + ] + backlog_second = [ + i for i in second_ready if action_at <= done_at(i) <= recovery_end + ] + row["second_jobs"] = len(backlog_second) + row["second_share"] = share(backlog_second, len(backlog_all)) + # буквальное прочтение порога и само окно after: числами (verify W3) + since_all = [i for i in both_ready if done_at(i) >= action_at] + since_second = [i for i in second_ready if done_at(i) >= action_at] + row["second_jobs_all"] = len(since_second) + row["second_share_all"] = share(since_second, len(since_all)) + row["second_share_after"] = share( + [i for i in second_ready if done_at(i) > recovery_end], + sum(1 for i in both_ready if done_at(i) > recovery_end), + ) row.update(control_columns(src.control, bounds)) row["flags"] = " ".join( cell_flags(row, zero_at is None, src.storage_down), @@ -821,12 +994,20 @@ def cell_flags( not_recovered: bool, storage_down: bool, ) -> list[str]: - """Пометки решения 11.""" + """Пометки решения 11; `oom` — только подтверждённое завершение ядром, а любой + перезапуск — `worker_restart`, его причина — столбцы `worker_die_*`.""" flags = [] - if num(row.get("oom_kill")): + if num(row.get("oom_kill")) or num(row.get("worker_oom_events")): flags.append("oom") if num(row.get("worker_restarts")): flags.append("worker_restart") + if num(row.get("worker_die_other")): + flags.append("worker_crash") + if (num(row.get("unexpected_rows")) or 0) > ( + (num(row.get("s5xx")) or 0) + (num(row.get("s_conn")) or 0) + ): + # строка после 5xx или обрыва законна: на неё клиент не получил 202 + flags.append("unexpected") if num(row.get("lost")): flags.append("lost") if num(row.get("stuck")): @@ -1237,7 +1418,7 @@ def pooled(rows: Iterable[Mapping[str, Any]], key: str) -> list[float]: def h6(rows: list[Mapping[str, Any]]) -> Check: check = Check() for row in rows: - for flag in FATAL_FLAGS: + for flag in H6_FLAGS: check.true(f"{row['cell']}: нет {flag}", not flagged(row, flag)) if num(row.get("failed")): only_exhausted = all( @@ -1457,12 +1638,24 @@ def settings_of(rows: Iterable[Mapping[str, Any]]) -> list[tuple[int, int]]: def recommend(rows: list[Mapping[str, Any]]) -> dict[str, Any]: """Правило решения 12: кандидат — без `oom` и `failed` на всех классах, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая - конкуренция; `prefetch` равен конкуренции.""" + конкуренция; `prefetch` равен конкуренции. Настройка, не снятая на части + классов, не кандидат: условие «на всех классах» для неё не проверено, она + названа в `partial` с этими классами (verify S6). В сравнении лучшей она + участвует: её снятые числа настоящие.""" settings = settings_of(rows) candidates = [] reasons: dict[str, str] = {} + partial: dict[str, list[str]] = {} for setting in settings: problem = None + key = f"{setting[0]},{setting[1]}" + missing = [ + klass + for klass in classes_of(rows) + if not select(rows, klass=klass, setting=setting) + ] + if missing: + partial[key] = missing for klass in classes_of(rows): cells = select(rows, klass=klass, setting=setting) if not cells: @@ -1489,16 +1682,22 @@ def recommend(rows: list[Mapping[str, Any]]) -> dict[str, Any]: problem = f"{klass}: throughput ниже 90 % лучшей" break if problem: - reasons[f"{setting[0]},{setting[1]}"] = problem - else: + reasons[key] = problem + elif not missing: candidates.append(setting) if not candidates: - return {"setting": None, "candidates": [], "rejected": reasons} + return { + "setting": None, + "candidates": [], + "rejected": reasons, + "partial": partial, + } concurrency = min(setting[0] for setting in candidates) return { "setting": (concurrency, concurrency), "candidates": candidates, "rejected": reasons, + "partial": partial, } @@ -1523,9 +1722,12 @@ def config_table(rows: list[Mapping[str, Any]]) -> list[str]: "| Конфигурация | Ячеек | Принято | 429 | Готовых/с: окно | восстановление | " "Пик незаверш. | Пик брокера | До `ready` over p50 / p95 / p99, с | " "Восст., с | `memory.peak`, МиБ | VmHWM, МиБ | Процесс p50 / макс., МиБ | " - "CPU worker, S3 | Троттлинг worker | OOM | Перезапуски | Пометки |" + "CPU worker, S3 | Троттлинг worker | OOM | Перезапуски | Пометки | " + "Queue lag: возраст старейшего, пик before / over / after, с | " + "Ожидание в очереди p50 / p95, мс: before; over; after | " + "Завершения worker: ядро / команда / прочие | Реплик в LB, минимум |" ) - lines = [head, "|" + "---|" * 18] + lines = [head, "|" + "---|" * 22] by_config: dict[str, list[Mapping[str, Any]]] = {} for row in rows: by_config.setdefault(row["config"], []).append(row) @@ -1553,7 +1755,38 @@ def config_table(rows: list[Mapping[str, Any]]) -> list[str]: f"{fmt(med(items, 'throttle_worker_over'), 2)} | " f"{sum(int(num(r.get('oom_kill')) or 0) for r in items)} | " f"{sum(int(num(r.get('worker_restarts')) or 0) for r in items)} | " - f"{' '.join(flags) or '—'} |", + f"{' '.join(flags) or '—'} | " + + " / ".join( + fmt(med(items, f"peak_oldest_{w}_s")) for w in WINDOWS + ) + + " | " + + "; ".join( + f"{fmt(med(items, f'queue_wait_{w}_p50_ms'), 0)} / " + f"{fmt(med(items, f'queue_wait_{w}_p95_ms'), 0)}" + for w in WINDOWS + ) + + " | " + + " / ".join( + str( + sum( + int(num(r.get(f"worker_die_{k}")) or 0) for r in items + ), + ) + for k in ("oom", "command", "other") + ) + + " | " + + fmt( + min( + ( + value + for r in items + if (value := num(r.get("lb_up_min"))) is not None + ), + default=None, + ), + 0, + ) + + " |", ) return lines @@ -1593,8 +1826,9 @@ def block_table(rows: list[Mapping[str, Any]]) -> list[str]: lines = [ "| Ячейка | Принято | 429 busy / backlog | Первый busy / backlog, с | Пик | " "Готовых/с окно / восст. | Восст., с | Повторов | Второй worker: задания, доля " - "| Пометки |", - "|" + "---|" * 10, + "| Пометки | Второй: доля после запуска всего / в окне after | " + "Relay: перезапуски / завершения |", + "|" + "---|" * 12, ] for row in sorted(rows, key=lambda r: r["cell"]): if row.get("block") == "matrix": @@ -1611,7 +1845,11 @@ def block_table(rows: list[Mapping[str, Any]]) -> list[str]: f"{fmt(row.get('attempts_over_one'), 0)} | " f"{fmt(row.get('second_jobs'), 0)}, " f"{fmt(row.get('second_share'), 2)} | " - f"{row.get('flags') or '—'} |", + f"{row.get('flags') or '—'} | " + f"{fmt(row.get('second_share_all'), 3)} / " + f"{fmt(row.get('second_share_after'), 3)} | " + f"{fmt(row.get('relay_restarts'), 0)} / " + f"{fmt(row.get('relay_die'), 0)} |", ) return lines @@ -1637,7 +1875,10 @@ def render_summary( if any(flagged(row, flag) for flag in FATAL_FLAGS) ] if fatal: - lines += ["**Потеряна работа:** " + "; ".join(fatal), ""] + lines += [ + "**Потеряна работа или лишние вложения:** " + "; ".join(fatal), + "", + ] lines += ["## Гипотезы", "", "| № | Вердикт | Детали |", "|---|---|---|"] for name, (verdict, detail) in verdicts(rows, limit).items(): lines.append(f"| {name} | {verdict} | {detail} |") @@ -1657,7 +1898,12 @@ def render_summary( ), ) for key, reason in advice["rejected"].items(): - lines.append(f"- ({key}) не кандидат: {reason}") + lines.append(f"- ({key.replace(',', ', ')}) не кандидат: {reason}") + for key, missing in advice["partial"].items(): + lines.append( + f"- ({key.replace(',', ', ')}) снята не на всех классах (нет: " + f"{', '.join(missing)}): без данных не кандидат", + ) lines += [ "", "## Ячейки по конфигурациям", @@ -1983,6 +2229,48 @@ def selftest() -> None: ] assert memory_by_lives(split_lives(mp, key=1)) == (700.0, 600.0, 4) + # LB: BACKEND и FRONTEND — не реплики, UP 1/2 — ещё в балансировке + both = [ + {"svname": "api-1", "status": "UP"}, + {"svname": "api-2", "status": "UP"}, + {"svname": "api-3", "status": "MAINT"}, + {"svname": "BACKEND", "status": "UP"}, + ] + one = [ + {"svname": "api-1", "status": "UP"}, + {"svname": "api-2", "status": "DOWN"}, + {"svname": "BACKEND", "status": "UP"}, + ] + assert lb_up_count(both) == 2 + assert lb_up_count(one) == 1, "реплика вышла, BACKEND посчитан как UP" + assert lb_up_min({1: both, 2: one}) == 1 + assert lb_up_min({}) is None + assert not lb_down({1: both}, 2), "обе UP — реплика не выходила" + assert lb_down({1: both, 2: one}, 2), "одна UP и BACKEND UP — вышла" + assert not lb_down({}, 2) + assert not lb_down( + {1: [{"svname": "api-1", "status": "UP 1/2"}, *one[:1]]}, + 2, + ), "UP 1/2 — ещё в балансировке" + + # причины завершений: ядро, команда, прочее; процесс обработки — без die + happened = parse_docker_events( + "1000000000|oom|w|| \n" + "1000000000|oom|w||\n" + "9000000000|oom|w||\n" + "9050000000|die|w|137|\n" + "20000000000|kill|w||9\n" + "20050000000|die|w|137|\n" + "30000000000|die|w|3|\n" + "40000000000|die|w|137|\n" + "50000000000|die|other|137|\nбред\n", + ) + found = die_causes(happened, "w") + assert found["oom"] == 1 and found["command"] == 1, found + assert found["other"] == 2 and found["die"] == 4, found + assert found["codes"] == {"3": 1, "137": 1}, found + assert found["oom_events"] == 3, found + # ячейка на границах окон: потерянное, зависшее, OOM, перезапуск base = { "cell": "s-c2p2-r1", @@ -2037,11 +2325,138 @@ def selftest() -> None: sql={"extra_jobs": 0, "bad_variants": 0, "attempts_over_one": 1}, hwm_kib=2048, restarts=1, + docker_events=[ + DockerEvent(t + 15, "oom", "worker", "", ""), + DockerEvent(t + 15.05, "die", "worker", "137", ""), + DockerEvent(t + 16, "die", "relay", "1", ""), + ], + relay_restarts=1, + lb_up_min=2, + db_ids={"b1", "o1", "o2", "o3", "warm"}, + warm_ids={"warm"}, ) row = cell_row(base, src) assert row["lost"] == 1 and row["stuck"] == 1 + # счётчик cgroup 4 и завершение процесса 1, подтверждённое событиями assert row["ready"] == 2 and row["oom_kill"] == 5 + assert row["worker_die_oom"] == 1 and row["worker_die_other"] == 0 + assert row["relay_restarts"] == 1 and row["relay_die"] == 1 + assert row["unexpected_rows"] == 0 and "unexpected" not in row["flags"] + assert row["lb_up_min"] == 2 assert "lost" in row["flags"] and "stuck" in row["flags"] + + # перезапуск не от ядра — не oom; лишняя строка без 5xx и обрыва — пометка + plain = replace( + src, + mp={}, + docker_events=[DockerEvent(t + 15, "die", "worker", "3", "")], + db_ids={"b1", "o1", "o2", "o3", "warm", "чужое"}, + ) + crash = cell_row(base, plain) + assert crash["oom_kill"] == 0 and crash["worker_die_other"] == 1, crash + assert crash["worker_exit_codes"] == '{"3": 1}' + flags = crash["flags"].split() + assert "oom" not in flags and "worker_restart" in flags, flags + assert "worker_crash" in flags and "unexpected" in flags, flags + assert crash["unexpected_rows"] == 1 + explained = replace( + plain, + uploads=[ + *uploads_seen, + Upload("over", int((t + 14) * 1000), 10, 503, "-", "a", "-"), + ], + ) + assert "unexpected" not in cell_row(base, explained)["flags"].split() + + # CPU до конца восстановления делится на задания до него: не на окно after + zero_end = replace( + src, + metas={ + "b1": Meta(200, "ready", "-", 3, t + 1), + "o1": Meta(200, "ready", "-", 3, t + 20), + "o2": Meta(200, "ready", "-", 3, t + 30), + "o3": Meta(200, "ready", "-", 3, t + 39), + "a1": Meta(200, "ready", "-", 3, t + 45), + "a2": Meta(200, "ready", "-", 3, t + 46), + }, + ) + # от t + 0 до нуля незавершённых в t + 40: 40 с CPU по 1 ядру на 4 задания + assert cell_row(base, zero_end)["cpu_worker_per_job_s"] == 10.0 + + # queue lag по окнам: ожидание — по окну прихода, разогрева в счёте нет + laggy = replace( + src, + worker_records=[ + { + "event": "Started job attempt", + "attachment_id": ident, + "queue_wait_ms": wait, + } + for ident, wait in ( + ("b1", 100), + ("o1", 1000), + ("o2", 3000), + ("warm", 9000), + ) + ], + ) + lag = cell_row(base, laggy) + assert lag["queue_wait_before_p50_ms"] == 100 + assert lag["queue_wait_over_p50_ms"] == 1000 + assert lag["queue_wait_over_p95_ms"] == 3000 + assert lag["queue_wait_after_p50_ms"] is None + assert lag["queue_wait_p95_ms"] == 9000, "столбец на ячейку прежний" + assert lag["peak_oldest_before_s"] == 0.1 + assert lag["peak_oldest_over_s"] == 9.0 + assert set(CELL_FIELDS) >= set(lag), set(lag) - set(CELL_FIELDS) + assert len(CELL_FIELDS) == len(set(CELL_FIELDS)) + + # доля второго: порог H3 — только разбор, окно after — отдельным числом + done = [ + { + "event": "Attachment became ready", + "timestamp": stamp, + "duration_ms": 300, + } + for stamp in ( + "2026-11-01T10:00:10Z", + "2026-11-01T10:00:20Z", + "2026-11-01T10:00:50Z", + "2026-11-01T10:00:50Z", + ) + ] + other_done = done[3:] + done = done[:3] + second = reconcile.timestamp("2026-11-01T10:00:00Z") + shared = cell_row( + base, + replace( + src, + t0=second, + uploads=[ + Upload( + "over", + int((second + 25) * 1000), + 10, + 202, + "-", + "a", + "o1", + ), + ], + jobs=[ + JobTick(second + 28, 0, 0, 0, 1, 1.0, 0), + JobTick(second + 30, 0, 0, 0, 0, 0.0, 0), + ], + worker_records=done, + second_records=other_done, + extra={"second_started_at": second + 5}, + ), + ) + assert shared["second_jobs"] == 0 and shared["second_share"] == 0 + assert shared["second_jobs_all"] == 1 + assert shared["second_share_all"] == 0.25 + assert shared["second_share_after"] == 0.5 # край окна — между тиками: CPU не занижен assert row["cpu_worker_over"] == 1.0, row["cpu_worker_over"] assert "oom" in row["flags"] and "worker_restart" in row["flags"] @@ -2141,14 +2556,42 @@ def selftest() -> None: # рекомендация: (2, 2) и другая assert recommend(matrix_fixture())["setting"] == (2, 2) - other = [ + assert recommend(empty)["setting"] is None + # настройка, не снятая на части классов, не кандидат, даже если на снятых + # классах она лучшая: данных об остальных нет + partly = [ base_row(**{**r, "ready_s_recovery": "3"}) if r["concurrency"] == "1" else r for r in matrix_fixture() ] - assert recommend(other)["setting"] == (1, 1) - assert recommend(empty)["setting"] is None + advice = recommend(partly) + assert advice["setting"] == (2, 2), advice + assert advice["partial"]["1,1"] == ["lj", "s"], advice + assert (1, 1) not in advice["candidates"], advice + assert advice["partial"]["2,256"] == ["lj", "m"], advice + text = render_summary( + {"label": "x", "git": {"commit": "abc", "dirty": False}, "queue": {}}, + partly, + ) + assert "(1, 1) снята не на всех классах (нет: lj, s)" in text + # снятая на всех классах и лучшая по правилу — другая рекомендация + other = [ + *partly, + *[ + base_row( + cell=f"{klass}-c1p1-r1", + config=f"{klass}-c1p1", + concurrency="1", + prefetch="1", + **{"class": klass}, + ) + for klass in ("s", "lj") + ], + ] + advice = recommend(other) + assert advice["setting"] == (1, 1), advice + assert "1,1" not in advice["partial"], advice # сводка и графики собираются text = render_summary( diff --git a/bench/run.py b/bench/run.py index 9edf33e4..d15e2c90 100644 --- a/bench/run.py +++ b/bench/run.py @@ -1978,6 +1978,34 @@ class Stand: stderr=subprocess.DEVNULL, ) + def death_events(self, path: Path) -> subprocess.Popen[bytes]: + """Поток завершений контейнеров проекта для профиля очереди: `oom`, `kill` + и `die` с кодом выхода, формат — `overload.parse_docker_events`. Поток, как + у `project_events`; причина перезапуска есть только здесь: `.State.OOMKilled` + новый старт сбрасывает, счётчик cgroup уходит вместе с жизнью контейнера.""" + args = [ + "docker", + "events", + "--filter", + f"label=com.docker.compose.project={PROJECT}", + "--filter", + "type=container", + ] + for action in ("oom", "kill", "die"): + args += ["--filter", f"event={action}"] + args += [ + "--format", + '{{.TimeNano}}|{{.Action}}|{{index .Actor.Attributes "name"}}|' + '{{index .Actor.Attributes "exitCode"}}|' + '{{index .Actor.Attributes "signal"}}', + ] + with path.open("w") as out: + return subprocess.Popen( + args, + stdout=out, + stderr=subprocess.DEVNULL, + ) + def container_events( self, container: str, @@ -4517,6 +4545,8 @@ class Bench: self.cell_index = 0 self.attempt = 0 self.cell_seconds: list[float] = [] + # профиль очереди: поток завершений контейнеров текущей ячейки + self.queue_events: subprocess.Popen[bytes] | None = None self.cell_started = time.monotonic() self.step_no = 0 self.resume = False @@ -6664,11 +6694,11 @@ class Bench: try: row = self.queue_cell(cell, classes) finally: + self.queue_stop_events() if not self.stand.stop(): self.say(f"cleanup incomplete: {leftovers()}") if any(overload.flagged(row, f) for f in overload.FATAL_FLAGS): fatal.append(cell["cell"]) - self.runs_done += 1 self.cell_seconds.append(time.monotonic() - started) self.progress(last={"cell": cell["cell"], "flags": row["flags"]}) if fatal: @@ -6745,6 +6775,9 @@ class Bench: ) extra: dict[str, Any] = {} action_at = None + self.queue_events = stand.death_events( + stand.work_dir / f"{name}.docker-events", + ) try: time.sleep(2) load_log = f"{name}.load.k6" @@ -6897,14 +6930,19 @@ class Bench: extra, ) self.results.add_cell(row, timeline) + # готовая строка — готовая ячейка: при прерывании сразу после неё счёт тот же + self.runs_done += 1 self.say( f"{name}: accepted {row['accepted']}, 429 {row['s429']} (busy " f"{row['busy_429']}, backlog {row['backlog_429']}), peak " f"{row['peak_unfinished']}, ready/s {row['ready_s_over']} / " f"{row['ready_s_recovery']}, recovery {row['recovery_s']} s, p95 " f"{row['ready_over_p95_s']} s, memory.peak " - f"{row['memory_peak_mib']} MiB, oom {row['oom_kill']}, attempts>1 " - f"{row['attempts_over_one']}, flags [{row['flags']}]", + f"{row['memory_peak_mib']} MiB, oom {row['oom_kill']}, worker die " + f"oom/command/other {row['worker_die_oom']}/" + f"{row['worker_die_command']}/{row['worker_die_other']}, attempts>1 " + f"{row['attempts_over_one']}, lb up min {row['lb_up_min']}, flags " + f"[{row['flags']}]", ) for path in stand.work_dir.glob(f"{name}.*"): path.unlink(missing_ok=True) @@ -7046,6 +7084,17 @@ class Bench: ");\n", ), ) + # в обратную сторону: вложение в базе, на которое никто не отвечал 202 + db_ids = set( + json.loads( + stand.psql( + "SELECT coalesce(json_agg(id), '[]') FROM attachments;\n", + ), + ), + ) + warm_ids = set( + json.loads(stand.read_work("downloads.json")), + ) worker_records = reconcile.parse_records(self.queue_log(WORKER)) started = overload.events(worker_records, "Started worker") if not started: @@ -7128,18 +7177,27 @@ class Bench: "grep VmHWM /proc/1/status", check=False, ).split() - restarts = sh( - "docker", - "inspect", - "-f", - "{{.RestartCount}}", - WORKER, - check=False, + restarts, relay_restarts = ( + sh( + "docker", + "inspect", + "-f", + "{{.RestartCount}}", + container, + check=False, + ) + for container in (WORKER, RELAY) ) - lb_down = any( - sum(1 for row in rows if row.get("status") == "UP") < p.replicas - for rows in samples.lb.values() + self.queue_stop_events() + docker_events = overload.parse_docker_events( + stand.read_work(f"{name}.docker-events"), ) + died = overload.die_causes(docker_events, WORKER)["die"] + if restarts.isdigit() and int(restarts) > died: + raise BenchError( + f"{name}: worker restarted {restarts} times, docker events " + f"show {died} exits", + ) src = overload.Sources( uploads=uploads_seen, t0=t0, @@ -7161,14 +7219,35 @@ class Bench: dropped=dropped, action_at=action_at, swapouts=swapped, - lb_down=lb_down, + lb_down=overload.lb_down(samples.lb, p.replicas), storage_down=bool(stand.down_storages()) or not stand.exit_state(S3)["running"], extra=extra, + docker_events=docker_events, + worker_name=WORKER, + relay_name=RELAY, + relay_restarts=( + int(relay_restarts) if relay_restarts.isdigit() else 0 + ), + lb_up_min=overload.lb_up_min(samples.lb), + db_ids=db_ids, + warm_ids=warm_ids, ) stand.stop_sampler() return overload.cell_row(cell, src), overload.timeline_rows(cell, src) + def queue_stop_events(self) -> None: + """Поток событий ячейки: повторный вызов и уборка при отказе — без него.""" + events, self.queue_events = self.queue_events, None + if events is None: + return + events.terminate() + try: + events.wait(timeout=5) + except subprocess.TimeoutExpired: + events.kill() + events.wait() + def queue_log(self, container: str) -> str: proc = subprocess.run( ["docker", "logs", container], diff --git a/openspec/changes/track1-queue-overload/design.md b/openspec/changes/track1-queue-overload/design.md index cc10c99b..a57df395 100644 --- a/openspec/changes/track1-queue-overload/design.md +++ b/openspec/changes/track1-queue-overload/design.md @@ -200,14 +200,14 @@ CPU — снимок `docker stats`. Очередь и задержка согл ### 2. Значения: предел 250, `Retry-After` 5 -**Предел 250.** Цель — ограничить срок, а не только число: ожидание при заполненном пределе = предел / потолок. Самый дорогой законный класс — `lp`, 0,92/с: 250 — это ~270 с. Сверху его ограничивает `[relay] republish_after_seconds` (300 с): ожидание в очереди короче порога потерянного сообщения, и копий не будет и при `prefetch` больше конкуренции. На остальных классах — 85–110 с. Объём staging при заполненном пределе — не больше 250 × 10 MiB ≈ 2,4 ГиБ плюс превышение. Значение — настройка `[uploads] max_unfinished_jobs` (`ge=0`, 0 — без предела): при другом числе worker предел другой, правило пересчёта — в `REPORT.md`. Правило и порог проверяет метка: гипотезы H4 и H5. Предел меньше `max_published_backlog` (1000): при значениях по умолчанию очередь брокера вмещает весь бэклог, а `max_published_backlog` остаётся страховкой на случай большего предела; менять его поводов нет (пробы: сообщение стоит брокеру меньше килобайта). +**Предел 250.** Цель — ограничить срок, а не только число: ожидание при заполненном пределе = предел / потолок. Самый дорогой законный класс — `lp`, 0,92/с: 250 — это ~270 с. Сверху его ограничивает `[relay] republish_after_seconds` (300 с): на `lp` ожидание короче порога потерянного сообщения. Копий при `prefetch` = конкуренции нет вовсе: выданное сразу взято, а пока в брокере есть готовые, relay не публикует заново. При `prefetch` больше конкуренции и ожидании дольше порога задания получат копию: эффект нулевой (проба, дубль — no-op), а настройка и так отвергнута. На остальных измеренных классах — 85–110 с. **Худший законный файл не измерен:** scan bomb в пределах контракта стоит 15 с CPU (лимит процесса), значит, расчётом 250 × 15 с ≈ 1 час разбора и копии от relay при таком ожидании. Предел считает задания, а не CPU: это ограничение, предел по классам `s`–`lp` его не покрывает. Объём staging при заполненном пределе — не больше 250 × 10 MiB ≈ 2,4 ГиБ плюс превышение. Значение — настройка `[uploads] max_unfinished_jobs` (`ge=0`, 0 — без предела): при другом числе worker предел другой, правило пересчёта — в `REPORT.md`. Правило и порог проверяет метка: гипотезы H4 и H5. Предел меньше `max_published_backlog` (1000): при значениях по умолчанию очередь брокера вмещает весь бэклог, а `max_published_backlog` остаётся страховкой на случай большего предела; менять его поводов нет (пробы: сообщение стоит брокеру меньше килобайта). **`Retry-After` 5** — константа `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS` в `src/utils/constants.py`, рядом с `UPLOAD_RETRY_AFTER_SECONDS` (1 с): настройкой не заводится, между установками не различается. За 5 с worker завершает 4–15 заданий, повтор через секунду почти всегда получил бы тот же 429, а простоя не будет: при заполненном пределе работы на десятки секунд. Ровный повтор без случайной добавки — ограничение клиента, в ответе контракт добавки не предусматривает. ### 3. Проверка в коде - **Порт и SQL:** `AbstractAttachmentJobRepository.count_unfinished(*, limit: int) -> int`: сумма трёх подзапросов «первые `limit` строк группы» по существующим частичным индексам, состояния — `literal(..., literal_execute=True)`, как у соседних выборок, иначе общий план — Seq Scan. Докстринг порта: «сумма не меньше `limit` тогда и только тогда, когда незавершённых не меньше `limit`»: счёт на группу обрывается на пределе, и цена не растёт с превышением. Один `execute` — правило `repo-layer.md`. Фейк `service-tests/fakes/repos.py`, строка `service-tests/repo_contract.py`, строка `test_status_is_a_constant_in_statement`. Миграции и нового индекса нет. -- **Сервис:** `AttachmentService.upload` в том же первом блоке единицы работы: `require_member` → 415 → 413 → `count_unfinished`. Проверки типа и размера переезжают внутрь блока: без соединения они не берут ничего (выдача ленивая, при попадании в кэш — ноль обменов), а блок на загрузке остаётся один. Поэтому **молчание реплики до тела прежнее** (`2 × request_timeout_seconds + wait_timeout_seconds` = 17 с < `timeout server` 30 с), цепочка LB и граница B уборщика не меняются. При `max_unfinished_jobs == 0` запроса нет. +- **Сервис:** `AttachmentService.upload` в том же первом блоке единицы работы: `require_member` → 415 → 413 → `count_unfinished`. Проверки типа и размера переезжают внутрь блока: без соединения они не берут ничего (выдача ленивая, при попадании в кэш — ноль обменов), а блок на загрузке остаётся один. Поэтому **молчание реплики до тела прежнее** (`2 × request_timeout_seconds + wait_timeout_seconds` = 17 с, с закрытием соединения на зависшем сервере до 2 × (6 + 2) + 5 = 21 с < `timeout server` 30 с), цепочка LB и граница B уборщика не меняются. При `max_unfinished_jobs == 0` запроса нет. - **Исключение:** `UploadBacklogFull` (`src/core/exceptions/attachment.py`), строка в `DOMAIN_ERRORS` (429 `rate_limited`) и `RETRY_AFTER` (`errors.py`), сообщение «Too many attachments are waiting for processing, retry later». - **Журнал:** `info` «Rejected attachment» с `reason=backlog`, `unfinished`, `limit`, как у прочих отказов; «Started API» — `uploads_max_unfinished_jobs`. Метка сверяет число 429 с числом таких записей. - **Что со временем отказа:** отказ не занимает места, поэтому посторонний поток 429 не вытесняет живые загрузки, а ожидающая в очереди мест загрузка не считается заново. @@ -325,7 +325,7 @@ CPU — снимок `docker stats`. Очередь и задержка согл ### 11. Достоверность и шум -**Пометки строки** (`flags`): `oom` — `oom_kill > 0`; `worker_restart` — ядро завершило процесс 1, контейнер перезапущен; `lost` — принято, а метаданных нет; `stuck` — не `ready` и не `failed` к концу; `duplicate` — заданий на вложение больше одного или вариантов не три; `sha_mismatch`; `not_recovered` — срок окна `recovery` вышел; `failed` — есть `failed`; `dropped` — недосланные итерации; `lb_down` — реплика выходила из LB; `host_swap`; `storage_down`. `lost`, `stuck`, `duplicate`, `sha_mismatch` дают ненулевой код команды в конце метки (ячейки сняты, отказ — на всю метку): замер, где система потеряла работу, — это результат, а не сбой команды, но зелёной метка быть не должна. `oom`, `worker_restart` и `failed` — результат настройки. +**Пометки строки** (`flags`): `oom` — `oom_kill > 0` или событие Docker `oom`; `worker_restart` — контейнер перезапущен, причина — столбцы `worker_die_*`; `worker_crash` — завершение не от ядра и не по команде (там же, п. 8 «Уточнений apply»); `unexpected` — вложение стенда, на которое никто не получил 202, сверх 5xx и обрывов (п. 10); `lost` — принято, а метаданных нет; `stuck` — не `ready` и не `failed` к концу; `duplicate` — заданий на вложение больше одного или вариантов не три; `sha_mismatch`; `not_recovered` — срок окна `recovery` вышел; `failed` — есть `failed`; `dropped` — недосланные итерации; `lb_down` — реплика выходила из LB; `host_swap`; `storage_down`. `lost`, `stuck`, `duplicate`, `sha_mismatch`, `unexpected` дают ненулевой код команды в конце метки (ячейки сняты, отказ — на всю метку): замер, где система потеряла работу, — это результат, а не сбой команды, но зелёной метка быть не должна. `oom`, `worker_restart` и `failed` — результат настройки. **Шум.** Объявлено заранее: разброс — min–max трёх повторов одной конфигурации; разница двух конфигураций считается эффектом, только если их разбросы не пересекаются и разница медиан больше наибольшего разброса пары; иначе пишется «в пределах шума». На пробах разброс трёх повторов — 1–8 % по throughput и до 3 % по памяти («Шум и цена стенда»): допуски гипотез ниже шире него. Отдельной метки A/A нет: это умножило бы время, а настройка по умолчанию повторяется в каждом круге и служит опорой. @@ -347,7 +347,7 @@ CPU — снимок `docker stats`. Очередь и задержка согл | H8 | Рестарты под перегрузкой не теряют работу | `kill-worker`: всё `ready`, заданий с повторной попыткой ≤ 2, очередь разобрана не позже большего из «конец `over` + 1,3 × пик / throughput» и «KILL + аренда 70 с + 15 с»; `restart-broker`: всё `ready`, заданий с повторной попыткой нет, 5xx на загрузке нет, восстановление ≤ 1,3 × пик / throughput + 15 с | | H9 | Приём ограничен S3, местами и затем пределом, а не падением; S3 общий с worker | `accept`: первый 429 `busy` раньше первого `backlog`, оба есть, 5xx нет; CPU S3 в первые 30 с окна ≥ 0,85; принято за окно / длина окна ≥ 6/с (λ `m` в матрице); пик незавершённых ≤ 290; готовых/с в окне ≤ 1,5 при ≥ 2,4 в окне восстановления; контрольный поток: запись и чтение p95 ≤ 200 мс, скачивание ≤ 1 с, без 5xx | -**Правило рекомендации** (считается в сводке, вывод — в `REPORT.md`): кандидат — настройка без `oom` и `failed` ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а `prefetch` равен конкуренции: большему нечего добавить (H3). **Значения по умолчанию** меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором `make bench_queue_quick`, а не переснятие. По пробам ждём, что (2, 2) остаётся: (1, 1) теряет 12–15 % на `lp` и `m`, (4, 4) упирается в память. **Компромисс latency и ресурсов** — вывод из таблиц метки: что даёт память при той же скорости, что даёт CPU (второй worker), и при каких условиях поднимать конкуренцию: `concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса)`. Формула — гипотеза в отчёте, её члены — числа метки. +**Правило рекомендации** (считается в сводке, вывод — в `REPORT.md`): кандидат — настройка без `oom` и `failed` ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а `prefetch` равен конкуренции: большему нечего добавить (H3). Настройка, снятая не на всех классах, — (1, 1) и (2, 256) по плану решения 5 — не кандидат: условие «на каждом классе» для неё не проверено, сводка её называет (уточнение 9). **Значения по умолчанию** меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором `make bench_queue_quick`, а не переснятие. По пробам ждём, что (2, 2) остаётся: (1, 1) теряет 12–15 % на `lp` и `m`, (4, 4) упирается в память. **Компромисс latency и ресурсов** — вывод из таблиц метки: что даёт память при той же скорости, что даёт CPU (второй worker), и при каких условиях поднимать конкуренцию: `concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса)`. Формула — гипотеза в отчёте, её члены — числа метки. **Ограничения метода** — в отчёт дословно по метке: - один хост и ВМ Docker Desktop (arm64, 12 CPU, 7,75 ГиБ): лимит 1 CPU — квота CFS, а не отдельное ядро; генератор и посторонние контейнеры на той же ВМ, доля их CPU видна по `vm`; @@ -374,7 +374,7 @@ CPU — снимок `docker stats`. Очередь и задержка согл ### 15. Сценарий защиты и документы -**Защита:** шаг «для 5 — выбранный эксперимент» — `make bench_queue_quick` (~11 мин, заранее или на глазах) и разбор `evidence/queue/baseline/summary.md`: таблица настроек, плато предела, второй worker, рестарты. Новой команды драйвера нет: она повторяла бы профиль. +**Защита:** шаг «для 5 — выбранный эксперимент» — `make bench_queue_quick` (~11 мин, заранее или на глазах) и разбор `evidence/queue/baseline2/summary.md`: таблица настроек, плато предела, второй worker, рестарты. Новой команды драйвера нет: она повторяла бы профиль. **`REPORT.md`:** «Трек 1 уровня 5» в таблице критериев; раздел экспериментов с гипотезами (до метки), методикой, определениями, таблицами, выводами; «Сервисы и лимиты», «Открытые вопросы», «Ограничения»: снимаются записи «Дорогие файлы тратят CPU до лимита», «Отставание очистки staging», «Цена процесса на задание», «Ограничения принятой работы на входе API нет» — заменяются измеренным; новое ограничение — завершение процесса 1 worker ядром при конкуренции, которая не помещается в лимит. **Правила:** `bench.md` (раздел профиля), `worker.md`, `settings.md`, `api-contract.md`, `service-layer.md`, `repo-layer.md`, `logging.md`, `student-tests.md`; **`AGENTS.md`** — статус лабы, команды, карта кода; `config_example.toml`. `QUESTIONS.md` — раздел этого change, вопросы переносятся в `REPORT.md`. @@ -390,7 +390,7 @@ CPU — снимок `docker stats`. Очередь и задержка согл | «Предел при остановленных брокере и relay» | `test_backlog_without_broker`, fault | | «Превышение ограничено» | `test_backlog_overshoot_bounded`, fault | | «Предел выключен» | `test_backlog_off`, fault | -| «Работа копится там, где положено», «Приём упирается в места загрузки», «Сначала места, затем предел», «Контрольный поток под перегрузкой», «Бэклог уходит за измеренное время», «Никого не теряем», «Время до готовности вернулось», «Worker убит под перегрузкой», «Брокер перезапущен под перегрузкой» | исключения сверки (нужна открытая нагрузка, счётчики и рестарт контейнера): `make bench_queue` → `evidence/queue/baseline/summary.md` | +| «Работа копится там, где положено», «Приём упирается в места загрузки», «Сначала места, затем предел», «Контрольный поток под перегрузкой», «Бэклог уходит за измеренное время», «Никого не теряем», «Время до готовности вернулось», «Worker убит под перегрузкой», «Брокер перезапущен под перегрузкой» | исключения сверки (нужна открытая нагрузка, счётчики и рестарт контейнера): `make bench_queue` → `evidence/queue/baseline2/summary.md` | | `attachments` «Порядок проверок загрузки» | прежние тесты; новый шаг — `test_backlog_limit` | Вне сверки: `service-configuration` — `service-tests` (настройка), запись о старте — журнал пятого API в `test_backlog_limit`-наборе и `make run_docker`; `load-benchmark` — `make bench_queue_quick`, `make bench_uploads_quick`; `health`, `job-outbox`, `message-broker` — прежние тесты, текст уточнён. @@ -421,14 +421,23 @@ CPU — снимок `docker stats`. Очередь и задержка согл ## Уточнения apply -1. **`oom_kill` — сумма по жизням плюс перезапуски.** На `make bench_queue_quick` (`lp`, (4, 4)) контейнер перезапустился, а счётчик показал 0: ядро завершает процесс 1, cgroup уходит раньше следующего тика, и прочитать счётчик умершей жизни нельзя. Перезапуск по политике `unless-stopped` бывает только при аварийном выходе, `docker kill` блока `kill-worker` демон считает ручной остановкой, поэтому перезапуск считается завершением ядром, и ячейка получает `oom`. Причина перезапуска в метке не проверяется отдельно: `.State.OOMKilled` после нового старта сброшен. +1. **`oom_kill` — сумма по жизням плюс перезапуски** (заменено п. 8: так снята только метка `baseline`). На `make bench_queue_quick` (`lp`, (4, 4)) контейнер перезапустился, а счётчик показал 0: ядро завершает процесс 1, cgroup уходит раньше следующего тика, и прочитать счётчик умершей жизни нельзя. Перезапуск по политике `unless-stopped` бывает только при аварийном выходе, `docker kill` блока `kill-worker` демон считает ручной остановкой, поэтому перезапуск считается завершением ядром, и ячейка получает `oom`. Причина перезапуска в метке не проверяется отдельно: `.State.OOMKilled` после нового старта сброшен. 2. **Доля второго worker — только разбор накопленного:** от его запуска до нуля незавершённых. Окно `after` приходит после разбора и делится поровну при любом `prefetch`; с ним доля при `prefetch` 256 была 6,7 % при нуле заданий из бэклога, и H3 ложно не подтверждалась бы. Порог H3 (≤ 5 %) не менялся, уточнено только, какие задания считаются, — как и сказано в таблице решения 8: «второй берёт 0 заданий». 3. **CPU за окно — с линейной интерполяцией на краях.** Разность только по отсчётам внутри окна при тике ~1,1 с занижала CPU на ~10 %, и H1 на 10-секундном окне давала 0,84 вместо ~0,95. Порог H1 не менялся. 4. **Прокрутка блоков до метки:** в `queue_quick` нет `accept`, `restart-broker` и `w2-p2`, поэтому они один раз проверены скриптом в scratchpad поверх `run.main` с подменённым набором конфигураций (метка `quick-queue-blocks-*`, в git не идёт). Изменений в инструментах это не требует. 5. **`second_jobs`** — столбец решения 8; `broker_refused` — число проходов relay с неподтверждёнными сообщениями: так сработавший предел памяти виден в метке без разбора текста журнала. 6. **Журнал пятого API в тесте:** добавлено действие hook `backlog-api-log`, которого нет в задаче 4.2: сценарий «журнал реплики называет отказ» и запись о старте проверяются в `test_backlog_limit`, как обещает раздел «Покрытие сценариев». -7. **Красное в `make student_test` шире, чем ждёт задача 7.2:** `test_exclusion_evidence_exists` называет не только `evidence/queue/baseline/summary.md`, но и `evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`. Их нет и на `5b5f59a`: не следствие этого change. Стадия apply в `evidence/` не пишет, снять их — до отчёта (`QUESTIONS.md`, «Для пользователя после прогона»). +7. **Красное в `make student_test` шире, чем ждёт задача 7.2:** `test_exclusion_evidence_exists` называет не только файл метки (теперь `evidence/queue/baseline2/summary.md`), но и `evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`. Их нет и на `5b5f59a`: не следствие этого change. Стадия apply в `evidence/` не пишет, снять их — до отчёта (`QUESTIONS.md`, «Для пользователя после прогона»). + +Правки verify (метка переснимается как `baseline2`, каталог `baseline` не трогается, пороги H1–H9 не меняются): + +8. **Причина завершения worker — события Docker, п. 1 заменён.** Проба на Docker 29.9.2 (контейнеры с лимитом 64 МиБ, `restart: unless-stopped`): ядро завершает процесс 1 — `oom`, затем `die` с кодом 137 через ~50 мс, все 8 раз; ядро завершает дочерний процесс — `oom` без `die`; `docker kill` — `kill` с сигналом 9 и `die` с кодом 137 без `oom`; выход с кодом 3 — `die` без `oom`. `.State.OOMKilled` остаётся true только до следующего старта, поэтому нужен поток. Столбцы `worker_die_oom`, `worker_die_command`, `worker_die_other`, `worker_exit_codes`, `worker_oom_events`; `oom_kill` не переименован, это счётчик cgroup плюс `worker_die_oom`. H2 и правило рекомендации считаются по подтверждённому `oom`: условия не менялись, смысл стал тем, что записан, а аварийный перезапуск не от ядра теперь только пометка `worker_crash` (`QUESTIONS.md`, вопрос 3). +9. **Настройка, снятая не на всех классах, не кандидат.** Цикл пропускал не снятый класс, и «на каждом классе» проверялось только на снятых; (1, 1) с данными по двум классам из четырёх могла победить. Теперь она называется в сводке, а её снятые числа участвуют в «лучшей на классе». Порог 90 % прежний; на метке `baseline` итог тот же: (2, 2). +10. **Сверка принятых — и в обратную сторону.** Вложение стенда не из 202 и не из разогрева — `unexpected_rows`; больше, чем 5xx и обрывов, — пометка `unexpected`, код команды как у `lost`. В условие H6 не добавлена: его список записан до метки (`H6_FLAGS`). +11. **`lb_down` считает только слоты-серверы, и `UP 1/2` — реплика ещё в балансировке.** Прежний подсчёт брал `BACKEND` третьей репликой, и выход одной реплики не срабатывал: метка `baseline` об этом условии H7 ничего не говорит. Подготовка стенда (`wait_ready`, `failover.parse_lb_stats`) `BACKEND` отбрасывала сама, другой такой ошибки в профиле нет. Новый столбец `lb_up_min`. +12. **Queue lag по окнам:** `queue_wait_<окно>_p50_ms` и `_p95_ms` по окну прихода задания — по `attachment_id` журнала; разогрев туда не входит, в прежних столбцах на ячейку он остался. `peak_oldest_<окно>_s` — по окну тика. Литеральная доля второго worker — `second_share_all`, доля в окне `after` — `second_share_after`, столбец порога `second_share` прежний. +13. **«17 с» в спеках `load-balancing` и `service-configuration` не менялись:** дельт этих требований в change нет, а формула верхней границы всё равно меньше 30 с. Запись и предложение — `KNOWN_ISSUES.md`, там же формула уборщика. ## Open Questions diff --git a/openspec/changes/track1-queue-overload/specs/load-benchmark/spec.md b/openspec/changes/track1-queue-overload/specs/load-benchmark/spec.md index 810d515c..58e6cb63 100644 --- a/openspec/changes/track1-queue-overload/specs/load-benchmark/spec.md +++ b/openspec/changes/track1-queue-overload/specs/load-benchmark/spec.md @@ -267,11 +267,11 @@ commit (`RESUME=1`), как у серий трека 1. - throughput — готовых вложений в секунду в окне перегрузки и в окне восстановления; - очередь посекундно и её пики, в трёх местах: неопубликованные задания (outbox) и ждущие срока; очередь брокера — готовые и неподтверждённые сообщения, опубликованные и не взятые задания; взятые worker — `processing` и выданные, но не взятые; -- возраст старейшего незавершённого задания, пик и посекундно; +- возраст старейшего незавершённого задания, пик по окнам и посекундно; время задания в очереди по журналу worker: p50 и p95 по окнам прихода; - время от ответа 202 до `ready` по метаданным: p50, p95 и p99 по окнам прихода; -- время восстановления: от конца окна перегрузки до нуля незавершённых заданий; -- RSS: пик процесса worker, пик процесса обработки по его отчёту (p50 и наибольший), `memory.peak` и наибольшая анонимная память контейнера, завершения ядром из-за памяти, перезапуски контейнера worker; у перезапущенного контейнера — наибольшее и сумма по его жизням; -- CPU и троттлинг worker, S3, PostgreSQL, реплик, relay, брокера и уборщика по окнам; +- время восстановления: от ответа на последнюю загрузку окна перегрузки до нуля незавершённых заданий; +- RSS: пик процесса worker, пик процесса обработки по его отчёту (p50 и наибольший), `memory.peak` и наибольшая анонимная память контейнера, завершения ядром из-за памяти, перезапуски контейнера worker; причина каждого завершения по событиям Docker — ядро, команда или прочее с кодом выхода; перезапуски и завершения relay; у перезапущенного контейнера — наибольшее и сумма по его жизням; +- CPU и троттлинг worker, S3, PostgreSQL, реплик, relay, брокера, уборщика и LB по каждому окну; - память брокера и наличие сработавшего предела памяти; - ответы на загрузку по кодам, недосланные итерации, `failed` по кодам и причинам, попытки сверх одной, пропущенные сообщения по причинам; - контрольный поток: число ответов, ошибки, p50, p95 и p99 по окнам. @@ -281,7 +281,7 @@ commit (`RESUME=1`), как у серий трека 1. брокера. Приложение он не импортирует. Достоверность: -- принятые вложения SHALL совпасть с вложениями стенда: потерянное или зависшее — пометка ячейки, у ячейки блока рестартов и матрицы — и ненулевой код команды в конце метки; +- принятые вложения SHALL совпасть с вложениями стенда в обе стороны: потерянное, зависшее или вложение стенда, на которое никто не получил 202 и которое не объясняется ответом 5xx или обрывом, — пометка ячейки, у ячейки блока рестартов и матрицы — и ненулевой код команды в конце метки; - второго набора вариантов и второго задания у вложения SHALL не быть, иначе так же; - выборка оригиналов и вариантов SHALL скачиваться с SHA-256 из метаданных; - k6 с недосланными итерациями, выгрузка хоста в swap и упавшее хранилище — пометки ячейки; @@ -290,7 +290,7 @@ commit (`RESUME=1`), как у серий трека 1. В паспорте метки SHALL быть: лимиты и образы; значения конкуренции, prefetch и окружение worker и relay по ячейкам без секретов; классы и их параметры; интенсивности и окна; контрольный поток; план; версия ядра ВМ; состояние хоста; посторонние контейнеры. -Сводка SHALL давать по каждой ячейке медиану и разброс повторов, таблицы блоков, вывод по каждой гипотезе (требование «Очередь под перегрузкой в отчёте»), рекомендуемую настройку по её правилу и графики. +Сводка SHALL давать по каждой ячейке медиану и разброс повторов, таблицы блоков, вывод по каждой гипотезе (требование «Очередь под перегрузкой в отчёте»), рекомендуемую настройку по её правилу и графики. Настройку, снятую не на всех классах, сводка SHALL называть такой, и кандидатом в рекомендацию она MUST NOT быть. #### Scenario: Полный профиль очереди diff --git a/openspec/changes/track1-queue-overload/tasks.md b/openspec/changes/track1-queue-overload/tasks.md index 31be05b3..31292823 100644 --- a/openspec/changes/track1-queue-overload/tasks.md +++ b/openspec/changes/track1-queue-overload/tasks.md @@ -8,7 +8,7 @@ **Ожидаемо красное**, остальное разбирается по AGENTS.md: - между задачами 4.6 и 4.7 — сверка покрытия: «marker points to unknown scenario», sync раньше тестов дал бы обратное; -- `test_exclusion_evidence_exists` — по `evidence/queue/baseline/summary.md`, пока метка не снята (группа 9); падать он должен только по этому файлу. +- `test_exclusion_evidence_exists` — по `evidence/queue/baseline2/summary.md`, пока метка не снята (группа 10); падать он должен только по этому файлу и файлам вне change, что снимаются на финальном шаге лабы. Решения по ходу работы — design, новый раздел «Уточнения apply»; вопросы и решения без пользователя — `QUESTIONS.md`, `## track1-queue-overload`; дефект, найденный попутно, — `KNOWN_ISSUES.md`. Сервисы — только на портах и `self.uow` (`service-layer.md`), новый метод repo — порт, SQL, фейк и строка контракта. @@ -59,9 +59,9 @@ - [x] 4.6 Прочее: `images` и `contract.py` без изменений, если хватает; маркеры `@pytest.mark.spec("queue-overload", …)` на всех тестах; прежние тесты не правятся (решение 13). Проверка: `uv run pytest student-tests --collect-only -q -m fault` видит новые тесты; `git diff --stat student-tests/` — только новые тесты, `run_failures.py`, `conftest.py`, `fault_hook.py`, `spec_coverage.py`. -- [x] 4.7 Сверка покрытия: `queue-overload` в `CAPABILITIES`; исключения девяти сценариев (нужны открытая нагрузка, счётчики и рестарт контейнера) со ссылкой `evidence/queue/baseline/summary.md` и командой `make bench_queue`; sync всех дельт в основные спеки (`/opsx:sync`): сверка читает только `openspec/specs/`. +- [x] 4.7 Сверка покрытия: `queue-overload` в `CAPABILITIES`; исключения девяти сценариев (нужны открытая нагрузка, счётчики и рестарт контейнера) со ссылкой `evidence/queue/baseline2/summary.md` и командой `make bench_queue`; sync всех дельт в основные спеки (`/opsx:sync`): сверка читает только `openspec/specs/`. - Проверка: `make student_test` — сверка: нет ни «no test», ни «marker points»; `test_exclusion_evidence_exists` называет только `evidence/queue/baseline/summary.md`. + Проверка: `make student_test` — сверка: нет ни «no test», ни «marker points»; `test_exclusion_evidence_exists` называет только `evidence/queue/baseline2/summary.md`. ## 5. Стенд `bench/` @@ -135,13 +135,53 @@ Проверка: код 0; `meta.json`: `git.dirty` false, `host_state`, план 57 ячеек; `swapouts_delta` 0 или пометка разобрана: настоящая помеха — переснять под новой меткой. - [x] 9.2 Коммит метки. `make student_test` на рабочем стенде после `make run_docker`. - Проверка: `test_exclusion_evidence_exists` зелёный. **Оговорка:** по метке зелёный, файл `evidence/queue/baseline/summary.md` он больше не называет; остаётся красным по трём файлам вне change (`evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`), их снимают на финальном шаге лабы на итоговом коде. + Проверка: `test_exclusion_evidence_exists` зелёный. **Оговорка:** по метке зелёный, файл метки он больше не называет (ссылка переведена на `evidence/queue/baseline2/summary.md`, снова красная до задачи 10.20); остаётся красным по трём файлам вне change (`evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`), их снимают на финальном шаге лабы на итоговом коде. - [x] 9.3 `REPORT.md`, раздел «Очередь под перегрузкой»: таблицы из `summary.md` — throughput, очередь, p50, p95, p99 до `ready`, RSS, `memory.peak`, CPU и троттлинг по настройкам и классам; блоки; backpressure и ограничение принятой работы (таблица решения 4 с числами метки); восстановление; вывод по каждой гипотезе; компромисс latency и ресурсов; рекомендация и решение о значениях по умолчанию; обоснование предела по измеренному потолку; S3 как общий ресурс приёма и worker; завершение процесса 1 ядром; ограничения метода, в том числе память S3 на долго живущем стенде (`KNOWN_ISSUES.md`). «Трек 1 уровня 5» в таблице критериев; разделы «Сервисы», «Ограничения», «Следующие шаги», «Ответы на вопросы защиты» — по изменениям; шаг защиты. Проверка: числа совпадают с `summary.md` метки; `make lint`, `make check`, `openspec validate track1-queue-overload --strict`. - [x] 9.4 Если правило решения 12 меняет значения по умолчанию — отдельный commit значения, `make bench_queue_quick`, строка в отчёте. Иначе — запись в отчёте, что значения оставлены, и почему. Проверка: `git log` называет шаг; `make test`. -- [ ] 9.5 Коммит отчёта основной сессией. +- [x] 9.5 Коммит отчёта основной сессией (`a8ef6ad`). Проверка: `git status` чист, шапка отчёта называет commit метки. + +## 10. Замечания проверки + +Находки verify. Метка переснимается целиком под именем `baseline2` на коммите с правками: каталог `baseline` не трогается (`bench.md`, «Результаты»). Пороги H1–H9 не меняются. Задачи 10.1–10.19 — код, инструмент, спеки и правила на рабочем дереве; 10.20–10.21 — на закоммиченном коде. + +- [x] 10.1 C1: `lb_down` считает только слоты-серверы (`svname` не `BACKEND` и не `FRONTEND`), подсчёт — в `bench/overload.py`, проверка в `--selftest`; другие подсчёты `UP` профиля очереди сверены. + + Проверка: `--selftest` красный до правки; одна реплика `UP` плюс `BACKEND` `UP` — да, обе `UP` — нет. +- [x] 10.2 C2: задача 9.5 отмечена. +- [x] 10.3 W1: queue lag в сводке; `queue_wait` по окнам — новые столбцы в конце `cells.csv`, столбцы в таблице сводки, определение в `REPORT.md`. +- [x] 10.4 W2: `cpu_worker_per_job_s` — `ready` до `recovery_end`. + + Проверка: `--selftest` красный до правки. +- [x] 10.5 W3: уточнение порога H3 в `REPORT.md` рядом с гипотезой, столбцы литеральной доли и доли окна `after`. +- [x] 10.6 W4: худший случай дорогих файлов назван неизмеренным расчётом: `REPORT.md`, комментарий `src/config/settings.py`, `settings.md`, решение 2. +- [x] 10.7 S1: арифметика `REPORT.md`, «Предел 250»; решение 2 о копиях при (2, 2) и (2, 256). +- [x] 10.8 S2: спек — восстановление от последней загрузки окна (дельта и основной). +- [x] 10.9 S3: CPU и троттлинг по окнам и ролям — новые столбцы. +- [x] 10.10 S4: столбцы перезапусков relay, сверка принятых в обратную сторону: лишние строки БД — пометка, как `lost`. +- [x] 10.11 S5: причина завершения worker из `docker events`: разные столбцы для ядра, команды и прочих; `oom_kill` не переименован; правило и H2 — по подтверждённому `oom`. + + Проверка: `--selftest` — ядро, `docker kill`, код выхода; проба событий Docker на живом контейнере. +- [x] 10.12 S6: `recommend` не считает настройку, не снятую на части классов, кандидатом; сводка называет «снята не на всех классах». + + Проверка: `--selftest` красный до правки. +- [x] 10.13 S7: условие H6 для `lp` (4, 4) в r3 названо в `REPORT.md`. +- [x] 10.14 S8: тест значения `-1` настройки предела. +- [x] 10.15 S9: «17 с» до тела — с закрытием соединения 21 с в правилах; граница уборщика проверена, правка формулы вне change — `KNOWN_ISSUES.md`. +- [x] 10.16 S10: счёт готовых ячеек при прерывании. +- [x] 10.17 Ссылки на метку: `spec_coverage.py`, спеки, правила, `AGENTS.md`, задачи — `evidence/queue/baseline2/summary.md`; причина пересъёмки — `REPORT.md`. + + Проверка: `test_exclusion_evidence_exists` называет новый файл, пока метка не снята: так и должно быть. +- [x] 10.18 Прокрутка: `make bench_queue_quick` и блоки, которых в ней нет, на рабочем дереве. +- [x] 10.19 Регресс: `make lint`, `make check`, `make validate PYTHON=.venv/bin/python`, `make service_test`, `make service_test_db`, все `--selftest`, `openspec validate track1-queue-overload --strict`, `make test`, `make student_test`, `make failure_checks FAULT_ARGS='-k backlog'`. +- [ ] 10.20 Метка: `make bench_queue QUEUE_LABEL=baseline2` на коммите с правками, коммит метки. + + Проверка: код 0; `git.dirty` false; план 57 ячеек; `test_exclusion_evidence_exists` этот файл больше не называет. +- [ ] 10.21 `REPORT.md` — числа, вердикты и рекомендация по `baseline2`, `lb_down`, lag, причины перезапуска, литеральная доля H3; `S1` пересчитан на новой метке. + + Проверка: числа совпадают со сводкой `baseline2`, `make check`, `openspec validate track1-queue-overload --strict`. diff --git a/openspec/specs/load-benchmark/spec.md b/openspec/specs/load-benchmark/spec.md index f2e1fcbf..8acacc78 100644 --- a/openspec/specs/load-benchmark/spec.md +++ b/openspec/specs/load-benchmark/spec.md @@ -2194,11 +2194,11 @@ commit (`RESUME=1`), как у серий трека 1. - throughput — готовых вложений в секунду в окне перегрузки и в окне восстановления; - очередь посекундно и её пики, в трёх местах: неопубликованные задания (outbox) и ждущие срока; очередь брокера — готовые и неподтверждённые сообщения, опубликованные и не взятые задания; взятые worker — `processing` и выданные, но не взятые; -- возраст старейшего незавершённого задания, пик и посекундно; +- возраст старейшего незавершённого задания, пик по окнам и посекундно; время задания в очереди по журналу worker: p50 и p95 по окнам прихода; - время от ответа 202 до `ready` по метаданным: p50, p95 и p99 по окнам прихода; -- время восстановления: от конца окна перегрузки до нуля незавершённых заданий; -- RSS: пик процесса worker, пик процесса обработки по его отчёту (p50 и наибольший), `memory.peak` и наибольшая анонимная память контейнера, завершения ядром из-за памяти, перезапуски контейнера worker; у перезапущенного контейнера — наибольшее и сумма по его жизням; -- CPU и троттлинг worker, S3, PostgreSQL, реплик, relay, брокера и уборщика по окнам; +- время восстановления: от ответа на последнюю загрузку окна перегрузки до нуля незавершённых заданий; +- RSS: пик процесса worker, пик процесса обработки по его отчёту (p50 и наибольший), `memory.peak` и наибольшая анонимная память контейнера, завершения ядром из-за памяти, перезапуски контейнера worker; причина каждого завершения по событиям Docker — ядро, команда или прочее с кодом выхода; перезапуски и завершения relay; у перезапущенного контейнера — наибольшее и сумма по его жизням; +- CPU и троттлинг worker, S3, PostgreSQL, реплик, relay, брокера, уборщика и LB по каждому окну; - память брокера и наличие сработавшего предела памяти; - ответы на загрузку по кодам, недосланные итерации, `failed` по кодам и причинам, попытки сверх одной, пропущенные сообщения по причинам; - контрольный поток: число ответов, ошибки, p50, p95 и p99 по окнам. @@ -2208,7 +2208,7 @@ commit (`RESUME=1`), как у серий трека 1. брокера. Приложение он не импортирует. Достоверность: -- принятые вложения SHALL совпасть с вложениями стенда: потерянное или зависшее — пометка ячейки, у ячейки блока рестартов и матрицы — и ненулевой код команды в конце метки; +- принятые вложения SHALL совпасть с вложениями стенда в обе стороны: потерянное, зависшее или вложение стенда, на которое никто не получил 202 и которое не объясняется ответом 5xx или обрывом, — пометка ячейки, у ячейки блока рестартов и матрицы — и ненулевой код команды в конце метки; - второго набора вариантов и второго задания у вложения SHALL не быть, иначе так же; - выборка оригиналов и вариантов SHALL скачиваться с SHA-256 из метаданных; - k6 с недосланными итерациями, выгрузка хоста в swap и упавшее хранилище — пометки ячейки; @@ -2217,7 +2217,7 @@ commit (`RESUME=1`), как у серий трека 1. В паспорте метки SHALL быть: лимиты и образы; значения конкуренции, prefetch и окружение worker и relay по ячейкам без секретов; классы и их параметры; интенсивности и окна; контрольный поток; план; версия ядра ВМ; состояние хоста; посторонние контейнеры. -Сводка SHALL давать по каждой ячейке медиану и разброс повторов, таблицы блоков, вывод по каждой гипотезе (требование «Очередь под перегрузкой в отчёте»), рекомендуемую настройку по её правилу и графики. +Сводка SHALL давать по каждой ячейке медиану и разброс повторов, таблицы блоков, вывод по каждой гипотезе (требование «Очередь под перегрузкой в отчёте»), рекомендуемую настройку по её правилу и графики. Настройку, снятую не на всех классах, сводка SHALL называть такой, и кандидатом в рекомендацию она MUST NOT быть. #### Scenario: Полный профиль очереди diff --git a/service-tests/unit/test_settings.py b/service-tests/unit/test_settings.py new file mode 100644 index 00000000..1cf705fb --- /dev/null +++ b/service-tests/unit/test_settings.py @@ -0,0 +1,28 @@ +"""Значения `[uploads]` (спек `service-configuration`, «Неверный параметр +загрузок»). Сама секция, а не `Settings`: тот читает `.env` и `config.toml`. +""" + +import pytest +from pydantic import ValidationError + +from src.config.settings import Uploads + + +@pytest.mark.parametrize( + ("field", "value"), + [ + ("max_concurrent", 0), + ("max_waiting", -1), + ("max_unfinished_jobs", -1), + ("body_timeout_seconds", "abc"), + ], +) +def test_wrong_value_names_field(field: str, value: object) -> None: + with pytest.raises(ValidationError) as caught: + Uploads(**{field: value}) + assert [error["loc"] for error in caught.value.errors()] == [(field,)] + + +def test_zero_turns_backlog_limit_off() -> None: + assert Uploads(max_unfinished_jobs=0).max_unfinished_jobs == 0 + assert Uploads().max_unfinished_jobs == 250 diff --git a/src/config/settings.py b/src/config/settings.py index 6e11e4b4..01af2f31 100644 --- a/src/config/settings.py +++ b/src/config/settings.py @@ -248,8 +248,9 @@ class Uploads(BaseModel): body_timeout_seconds: float = Field(default=30, gt=0) # незавершённых заданий стенда, при которых загрузка получает 429; 0 — без # предела (design change `track1-queue-overload`, решения 1–2): предел / - # потолок worker — срок ожидания, поэтому 250 при ~0,9 задания/с на самом - # дорогом классе меньше `[relay] republish_after_seconds` + # потолок worker — срок ожидания: 250 при ~0,9 задания/с на самом дорогом + # измеренном классе — ~270 с. Файл на лимите CPU процесса (15 с) этим не + # покрыт и не мерился: расчёт 250 × 15 с ≈ 1 ч разбора max_unfinished_jobs: int = Field(default=250, ge=0) diff --git a/student-tests/spec_coverage.py b/student-tests/spec_coverage.py index 8100e3e6..c8cf4fc9 100644 --- a/student-tests/spec_coverage.py +++ b/student-tests/spec_coverage.py @@ -199,7 +199,7 @@ EXCLUDED: dict[Scenario, Exclusion] = { ), check=( f"make bench_queue: {where} — " - "evidence/queue/baseline/summary.md" + "evidence/queue/baseline2/summary.md" ), ) for scenario, where in (