fix: correct queue overload bench accounting after verify
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -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`:
|
||||
|
||||
+17
-3
@@ -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`.
|
||||
|
||||
|
||||
@@ -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()` и только при
|
||||
|
||||
+16
-12
@@ -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)
|
||||
|
||||
|
||||
@@ -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/`
|
||||
|
||||
@@ -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, иначе
|
||||
|
||||
@@ -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 мин
|
||||
|
||||
@@ -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/<PLOTS>/` |
|
||||
| `make bench_ab BEFORE=... AFTER=... REAPPLY=<commit> [SERIES=...]` | «до» и «после» одного изменения подряд (два прогона `bench`): `bench` для `BEFORE`, commit доказательств, `git revert` commit отката `REAPPLY`, `bench` для `AFTER`; с `SERIES` — серия трека 1 вместо матрицы (`make bench_scaling`). Нужно чистое рабочее дерево; сама делает два коммита |
|
||||
|
||||
@@ -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 без общего срока. Найдено
|
||||
|
||||
+10
-2
@@ -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` косвенно. Условие не менялось, потому что записано до метки. В метке таких случаев не ждём (пробы: только ядро). Появится — считать настройку некандидатом? Сейчас: пометка в сводке, решение — в отчёте.
|
||||
|
||||
@@ -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), справедливости между пользователями и чатами нет.
|
||||
|
||||
+491
-48
@@ -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(
|
||||
|
||||
+93
-14
@@ -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],
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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: Полный профиль очереди
|
||||
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -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: Полный профиль очереди
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
|
||||
|
||||
@@ -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 (
|
||||
|
||||
Reference in New Issue
Block a user