Files
mtusi2026lab5/openspec/changes/track1-queue-overload/design.md
T

445 lines
91 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Design
## Context
Мотивация — `proposal.md`, раздел Why. Требования — `specs/`. Контракт — `contracts/README.md` («Формат и ошибки», «Фоновая обработка»), `contracts/openapi.json` (у загрузки уже есть 429 с `Retry-After`), рубрика — `README.md`, «Трек 1», правила измерений — `COURSE.md` и `.claude/rules/bench.md`. Основа — design архива `2026-10-31-pipeline-reliability`, решение 8 (что мерить и откуда), и `2026-11-01-unit-of-work` (порты, блоки).
### Код
Состояние — `5a97416`:
- `AttachmentService.upload`: блок с членством; затем без БД 415 и 413; затем место загрузки и `_store`. Предела принятой работы нет: 429 — только от мест (4 + 16 на реплику);
- `src/worker/main.py`: `set_qos(prefetch)`, задача на доставку, `asyncio.Semaphore(concurrency)` вокруг `service.handle`; по умолчанию 2 и 2; процесс обработки на задание; пул PostgreSQL 2;
- `AttachmentRelayService`: `room = max_published_backlog − count_published()` (1000), «потерянные» — есть отмеченные старше 300 с и ноль готовых;
- частичные индексы `attachment_jobs`: `ix_attachment_jobs_outbox`, `ix_attachment_jobs_published`, `ix_attachment_jobs_lease` — покрывают всё незавершённое;
- `bench/`: `Stand.start_broker`, лимиты `BENCH_BROKER_*`, `BENCH_RELAY_*`, `BENCH_WORKER_*` описаны и не используются; сэмплер — режимы `list`, `scan`, `peak`; профиль `uploads` идёт без worker, и задания копятся.
### Пробы (2026-11-01, scratchpad `track1/`, проект compose `q1probe`, образ `git archive 5a97416`)
**Это пробы, а не результат:** один прогон на точку, часть — при соседней пробе; они нужны, чтобы выбрать методику, значения и пороги. Условия: arm64, Docker 29.9.2, ВМ 12 CPU / 7,75 ГиБ, рядом простаивали рабочий стенд и `domains-*`. Лимиты — рабочего стенда, worker 1 CPU / 1 ГБ без swap. Секреты — синтетические, `.env` и `config.toml` не подключались. Что осталось после проб — раздел «Migration Plan».
**Кандидаты классов.** Файлы — Pillow образа, от зерна; процесс обработки — те же аргументы, что у `ImageRenderer`, 1 CPU, по одному, медиана пяти:
| Файл | Млн пикс. | MiB | Стена / CPU, мс | VmHWM, МиБ | WebP, КиБ |
|---|---|---|---|---|---|
| JPEG 640 × 480, q85 | 0,31 | 0,10 | 208 / 200 | 31 | 82 |
| `s`: JPEG 1600 × 1200, q85 | 1,92 | 0,48 | 299 / 290 | 49 | 200 |
| PNG 1600 × 1200 | 1,92 | 3,77 | 342 / 330 | 53 | 221 |
| `m`: PNG RGB из шума 1024 × 3409 | 3,49 | 9,99 | 269 / 260 | 57 | 191 |
| `lj`: JPEG 8000 × 5000, q88 | 40 | 8,60 | 365 / 350 | 57 | 158 |
| JPEG прогрессивный, те же пиксели | 40 | 7,64 | 515 / 500 | 155 | 158 |
| PNG RGB 8000 × 5000, 4 значащих бита | 40 | 8,52 | 655 / 630 | 213 | 160 |
| `lp`: PNG RGBA 8000 × 5000, 4 значащих бита | 40 | 9,97 | 1025 / 1010 | 367 | 479 |
Запуск процесса — около половины CPU малого файла: ~100 мс из 200 (проба `pipeline-reliability`: 90 мс на импорт Pillow и плагинов). Память решает формат, а не пиксели: 40 Мпкс — 57 МиБ у JPEG с `draft` и 367 МиБ у PNG RGBA.
**Потолок worker.** Загрузки при остановленном worker, затем запуск, готовых в секунду по `finished_at`, 25–120 заданий:
| Класс | (1, 1) | (2, 2) | (4, 4) | (8, 8) | Другие |
|---|---|---|---|---|---|
| 0,3 Мпкс | 4,33/с, 118 МиБ | 4,30, 142 | 3,41, 178 | 3,32, 253 | (2, 64): 4,03, 171 |
| `s` | 2,78, 147 | 2,96, 176 | 2,58, 283 | — | — |
| `m` | 2,48, 197 | 2,93, 261 | 2,63, 347 | 2,73, 591 | (2, 3): 2,39; (2, 8): 2,79 |
| `lj` | 1,91, 198 | 2,37, 249 | 2,13, 357 | 1,88, 494 | — |
| JPEG прогрессивный | — | 1,48, 401 | 1,57, 695 | — | — |
| `lp` | 0,81, 484 | 0,92, 842 | 0,89, **OOM ×10** | — | (3, 3): 0,81, **OOM ×4**; (2, 64): 0,84, 845 |
`memory.peak` — на весь прогон. У `lp` при (3, 3) и (4, 4) ядро убивало процессы обработки, задания возвращались `render_killed` и все дошли до `ready` с попытками 29 и 35 на 25 заданий. CPU worker — 1 ядро на всём прогоне, кроме (1, 1), где часть времени ждут S3 и PostgreSQL: **потолок при 1 CPU — CPU, и конкуренция сверх двух его не поднимает, а удлиняет процесс** (`render_ms` p50 на 0,3 Мпкс: 213 → 424 → 1107 → 2108 мс). Цена задания: 0,24 с CPU на 0,3 Мпкс, 0,35 на `s` и `m`, 0,45 на `lj`, 1,13 на `lp`.
**Открытая модель, настройка по умолчанию.** До окна — 15 с ниже потолка, окно перегрузки — 25 с, затем спад до нуля; контрольный поток 10 + 10 + 10 запросов в секунду:
| Класс | λ, /с | Принято | Загрузка p50 / p95, мс | Готовых/с в окне | Пик незаверш. | Восстановление, с | До `ready` p50 / p95, с | Контроль p95: запись / чтение / скачивание, мс | CPU worker / S3 |
|---|---|---|---|---|---|---|---|---|---|
| `s` | 8 | 223, все 202 | 13 / 19 | 2,9 | 126 | 45,8 | 22 / 44 | 8 / 7 / 9 | 1,03 / 0,09 |
| `m` | 6 | 174, все 202 | 141 / 279 | 2,7 | 85 | 30,2 | 16 / 29 | 46 / 12 / 85 | 0,98 / 0,95 |
| `lj` | 6 | 169, все 202 | 112 / 197 | 2,2 | 98 | 43,9 | 23 / 42 | 57 / 11 / 43 | 1,02 / 0,68 |
| `lp` | 2,5 | 71, все 202 | 393 / 601 | 0,83 | 43 | 46,3 | 25 / 45 | 24 / 12 / 29 | 0,99 / 0,32 |
| `s`, (8, 8) | 8 | 224, все 202 | 15 / 25 | 2,0 | 156 | 76,7 | 41 / 75 | 17 / 14 / 18 | 0,98 / 0,13 |
CPU — снимок `docker stats`. Очередь и задержка согласуются с простой моделью: p95 до `ready` ≈ пик незавершённых / throughput окна (отношение 0,86–1,01), восстановление — столько же (0,89–1,05); throughput в окне и при восстановлении один и тот же (провала нет). На `m` при 6/с S3 уже близко к своему 1 CPU (0,83–0,95): дальше упирается приём, а не worker. `outbox` держится на 0–2: relay не узкое место; `rabbitmq` в снимках занят только нашими вызовами `rabbitmqctl`.
**Повтор на свежем стенде, окно 20 с, как в матрице.** До окна 10 с низкой λ; после разбора — окно той же низкой λ:
| Класс, настройка | λ, /с | Принято | Загрузка p50 / p95, мс | Пик незаверш. | Восстановление, с | До `ready` в окне p50 / p95, с | p95 до окна / после, с | Контроль скачивания p95, мс | Пик worker, МиБ |
|---|---|---|---|---|---|---|---|---|---|
| `s`, (2, 2) | 8 | 176 | 13 / 19 | 99 | 32,9 | 17 / 31 | 0,62 / 0,58 | 7,5 | 174 |
| `m`, (2, 2) | 6 | 137 | 113 / 223 | 65 | 23,9 | 12 / 22 | 1,13 / 0,88 | 70 | 211 |
| `lp`, (2, 2) | 2,5 | 57 | 368 / 581 | 34 | 36,3 | 20 / 35 | 1,37 / 1,37 | 18 | 836 |
| `s`, (2, 256), старый стенд | 8 | 177 | 14 / 22 | 106 | 35,8 | 19 / 34 | 0,59 / — | 12,5 | 175 |
Время до `ready` после разбора вернулось: отношение p95 — 0,78–1,00. У (2, 256) брокер всё окно показывает готовых 0 и неподтверждённых до 98; у (2, 2) готовых 91–163 при пике 99–170.
**Память: `lp`, (4, 4), те же окна, 2,5/с.** Прогон — свежий стенд, кроме последнего:
| Прогон | Завершений ядром | Заданий с повторной попыткой | Итог |
|---|---|---|---|
| 1 | 20 процессов обработки | 20 | все `ready`, разбор ~60 с |
| 2 | 44 | 26 | все `ready`, ~78 с |
| 3 | 0, `memory.peak` 1024 МиБ | 0 | все `ready`, ~42 с |
| 4 | 3 и **процесс 1 worker** | — | контейнер `exit 137`, `OOMKilled` на 20-й секунде |
| 5, старый стенд | не снято: контейнер пересоздан раньше разбора | — | те же признаки: контейнера нет на 24-й секунде, потребителей 0, через аренду 51 задание `queued`, ничего не потеряно |
Журнал ядра прогона 4: за 1,2 мс убиты три процесса обработки (356, 233, 202 МиБ анонимной памяти) и следом процесс 1 (135 МиБ, тот же `oom_score_adj` 0): память ещё не вернулась, а других кандидатов уже нет. Значит, `oom_score_adj` у процесса обработки его не защитит: защита — конкуренция, которая помещается в лимит. На рабочем стенде worker вернётся сам (`restart: unless-stopped`), в `bench/` стоит `restart: "no"`, и ячейка зависла бы (решение 10).
**Граница приёма: `m`, (2, 2), λ выше того, что принимают реплики и S3.** Свежий стенд; CPU — снимок `docker stats`:
| λ, /с, окно | Ответы | Загрузка 202 p50 / p95, мс | Принято/с в окне | Готовых/с в окне | Пик незаверш. | Восстановление, с | До `ready` p95, с | Контроль p95: запись / чтение / скачивание, мс | CPU S3 / worker |
|---|---|---|---|---|---|---|---|---|---|
| 6, 20 с | 137 — 202 | 113 / 223 | 6,1 | 2,9 | 65 | 23,9 | 22 | 17 / 11 / 70 | 0,83 / 0,98 |
| 12, 20 с | 203 — 202, 20 — 429 | 3 320 / 5 333 | 9,4 | 0,56 | 170 | 59,9 | 58 | 31 / 22 / 384 | 0,97 / 0,07 |
| 15, 20 с | 207 — 202, 76 — 429 | 3 768 / 5 641 | 9,6 | 0,62 | 175 | 62,3 | 60 | 28 / 10 / 332 | 1,02 / 0,30 |
| 15, 40 с, предел 250 | 323 — 202, 202 — 429 `busy`, 57 — 429 `backlog` | 4 804 / 5 872 | 7,7 | 0,57 | **284** | 100,5 | 95 | 20 / 17 / 341 | 0,97 / 0,63 |
5xx нет. Выше ~8–9,6 загрузок 10 MiB в секунду упирается CPU шлюза S3; места держат ответ 3–6 с и отказывают лишним (первый `busy` — на ~10-й секунде перегрузки), предел приходит на ~35-й, а превышение — 34 из 40 возможных загрузок в полёте. **S3 — общий ресурс приёма и worker:** пока приём занимает его, готовых/с падает с 2,9 до ~0,6 (worker ждёт S3, а не CPU), сразу после окна — снова 2,87/с. k6 с телом 10 MiB — до 2,1 ГиБ при 80 VU; VU, создаваемые на ходу, теряют итерации (33–36 недосланных).
**Старый стенд: S3 убит ядром.** Один и тот же стенд ~80 мин принимал пробы (~9 200 заданий, volume не пересоздавался); S3 у него держал 330–415 МиБ при лимите 512 и `GOMEMLIMIT` 400 МиБ. При 12/с на `m` — `exit 137`, `OOMKilled`, 9 ответов 503 на загрузке; без него все 229 незавершённых заданий за ~85 с исчерпали бюджет: `failed`, `retry_exhausted`, `storage_unavailable`, возврат — `make replay`. Те же 12 и 15/с на свежем стенде: `oom_kill` 0, 322–399 МиБ (`memory.peak` 515 МиБ — с учётом страничного кэша). На рабочем стенде S3 вернулся бы сам, ячейки метки — на свежих volume; запись — `KNOWN_ISSUES.md`.
**Цена проверки предела.** Схема стенда, 300 000 завершённых заданий, свой контейнер PostgreSQL 2 CPU / 1 ГБ, `pgbench -M prepared`, один клиент, задержка на запрос:
| Незавершённых | `state IN (…)` без индекса: Parallel Seq Scan | Сумма трёх Index Only Scan | Сумма с `LIMIT 1001` на группу |
|---|---|---|---|
| ~0 | 10,8 мс | 0,045 мс | 0,047 мс |
| 1 000 | 10,6 | 0,081 | 0,092 |
| 5 000 | 11,4 | 0,233 | 0,135 |
| 25 000 | 11,7 | 0,959 | 0,129 |
| 125 000 | 15,9 | 4,876 | 0,130 |
Новый частичный индекс `(id) WHERE state IN ('queued','processing')`: 4,8 МБ на 125 000 строк, полный счёт 5,3 мс, с `LIMIT` — 0,084 мс: выигрыша перед тремя существующими нет, а цена записи есть. Под оборотом 100 заданий в секунду (четыре транзакции жизни задания, в ~30 раз больше потолка, autovacuum по умолчанию, 26 000 мёртвых строк за 90 с, 1 020 незавершённых): 0,65–1,05 мс без роста; `Heap Fetches` — все незавершённые, карта видимости на живых страницах бесполезна, потому и граница по `LIMIT`. Счётчик одной строкой в транзакциях приёма и итога: читать 0,033 мс, но потолок оборота при 2 / 4 / 8 клиентах падает с 2003 / 2879 / 2567 до 1347 / 2055 / 1311 циклов задания в секунду (−29…−49 %, в другом прогоне −16…−24 %), задержка цикла +40…+96 %.
**Прототип предела на копии кода** (образ `q1probe-gate`, решение 3 как есть; план — три Index Only Scan по трём индексам, 0,22 мс, у `_lease` `Heap Fetches` 173 на 2 живые строки до VACUUM). `s`, (2, 2), 1,5/с 10 с, затем 20/с 30 с:
| Предел | Принято / 429 | Загрузка 202 p50 / p95, мс | Пик незаверш. | Восстановление, с | До `ready` p50 / p95, с | Контроль p95: запись / чтение / скачивание, мс |
|---|---|---|---|---|---|---|
| 250 | 349 / 265 | 14 / 161 | 250, плато до конца окна | 84,3 | 50 / 85 | 8,7 / 7,8 / 10,4 |
| 0 | 615 / 0 | 14 / 41 | 513, рост до конца окна | 173,2 | 87 / 165 | 9,0 / 7,5 / 10,4 |
При пределе `p95 до ready` ровно `предел / потолок` (250 / 2,95 = 85 с). Превышения на этой интенсивности нет: загрузка `s` короче интервала между счётами. Хвост 161 мс — один прогон, причина не разбиралась; в опыте ниже его нет.
**Цена проверки на загрузку и отказа.** Свежий стенд, 25 загрузок/с, тело 0,1 MiB (доля проверки наибольшая), worker, relay и уборщик остановлены, четыре круга по 16 с, реплики пересоздаются на каждое плечо; CPU — разность `cpu.stat` на запрос, медианы кругов:
| | Загрузка p50 / p95 / p99, мс | CPU реплик, мс | CPU PostgreSQL, мс |
|---|---|---|---|
| Без проверки (предел 0) | 9,87 / 11,7 / 13,0 | 6,38 | 1,09 |
| С проверкой (предел 100 000: отказов нет, счёт до 4 400 строк) | 10,78 / 13,0 / 16,4 | 7,21 | 1,47 |
| Отказ у предела, 4 клиента без пауз, ~980 отказов/с | 3,7 / 4,7 / 5,7 | 1,89 | 0,27 |
| Отказ у предела, 16 клиентов, ~1 000 отказов/с | 14,5 / 27 / 58 | 1,90 | 0,32 |
Проверка — **+0,9 мс p50, +0,8 мс CPU реплики, +0,4 мс CPU PostgreSQL на загрузку**; это оценка сверху: значение по умолчанию обрывает счёт на 250 строках на группу, а у файлов больше доля ещё меньше. Отказ втрое дешевле загрузки, пределы 5 и 250 при бэклоге 4 400 по цене неотличимы, потолок — CPU реплик.
**Брокер.** Контейнер образа и лимитов стенда, предел памяти 400 МиБ, очередь без потребителя, сообщение 243 байта:
| Что | Результат |
|---|---|
| Память на готовое сообщение | 1 000 / 50 000 / 200 000 сообщений: cgroup 173 / 180 / 257 МиБ, анонимная ~106 МиБ, память очереди 110–430 КиБ: классическая очередь держит в памяти ~1 000 сообщений, остальное на диске. До предела памяти лимитом `max_published_backlog` и пределом заданий не дойти |
| Неподтверждённые | prefetch 1 000 / 10 000: память очереди 1,1 / 11,5 МиБ: ~1,1 КиБ на сообщение, выдача за миллисекунды |
| Цена цикла выдача — ack, 20 000 сообщений | prefetch 1 — 5 836/с, 2 — 8 637/с, 8 — 16 147/с, 64 — 17 362/с: 0,17 мс против сотен мс задания: prefetch сверх конкуренции throughput на этих заданиях поднять нечем |
| Сработавший предел памяти (`set_vm_memory_high_watermark`) | публикация без подтверждения за 4 с, закрытие соединения издателя — по сроку; потребитель на своём соединении подтверждает 100 сообщений за 0,01 с |
| `consumer_timeout` | 30 мин: сообщение, выданное worker и не подтверждённое дольше, закрывает канал. Значит, `prefetch / потолок` должен быть меньше 30 мин |
| `rabbitmqctl list_queues` | 0,54 с, 0,52 с CPU в cgroup брокера на вызов: опрашивать им — портить CPU брокера в замере |
| Плагин `rabbitmq_prometheus` из файла `enabled_plugins` при старте, `collect_statistics_interval = 1000` | старт как без него, значения свежие за ~1 с; `/metrics/detailed?vhost=%2F&family=queue_coarse_metrics` — 2,4 КБ, 4,7 мс CPU на опрос; простой 0,0044 ядра, с опросом раз в секунду 0,0056; полный `/metrics` — 224 КБ, 33 мс. Чтение из bash образа PostgreSQL (`/dev/tcp`, HTTP/1.0, контейнер сэмплера): `ready=1234 unacked=0` при тех же значениях `rabbitmqctl list_queues` |
**Большой prefetch** (`s`, 150 заданий накоплено при остановленном worker):
| Опыт | (2, 2) | (2, 256) |
|---|---|---|
| Очередь через 10 с после запуска | готовых 120, неподтверждённых 2 | готовых **0**, неподтверждённых 122 |
| Второй worker через 10 с | 5,36/с, задания 92 + 58, всего 34,1 с | 2,94/с, задания **150 + 0**, всего 53,0 с |
| Порог потерянного 15 с вместо 300 с | копий 0 | копий **188** на 150 заданий: готовых ноль, а сообщения старше порога; все — `Skipped job message` `finished`, лишний эффект 0, время то же (51,8 с) |
**Рестарты посреди перегрузки** (`s`, 8/с, 30 с, 255–257 принятых): KILL worker и запуск — все `ready`, две попытки у 2 заданий, восстановление 59,1 с (без рестарта по модели ~56), контроль p95 ≤ 10 мс; `docker restart` брокера — все `ready`, попыток сверх одной нет, 56,7 с; KILL брокера и запуск — то же, 56,6 с; загрузки — все 202.
**Шум и цена стенда.** Три повтора `drain` при (2, 2) подряд: `s` (90 заданий) 3,02 / 3,05 / 3,02 готовых/с, пик 174 МиБ; `m` (60) 2,95 / 2,89 / 2,72, 209–215 МиБ; `lp` (30) 0,97 / 0,95 / 0,97, 831–838 МиБ: разброс throughput 1–8 %, памяти до 3 %. Свежий стенд: PostgreSQL и Valkey 1,9 с, миграции 2,5, брокер 3,7, S3 7,7, bootstrap 4,6, реплики, LB, relay, уборщик 0,7, готовность 1,2, пользователь и чат 0,9 — 20,5–25 с по шести запускам.
### Что найдено до решений
1. **Узкое место при 1 CPU — сам CPU worker,** а не брокер, relay, PostgreSQL или prefetch. Поэтому сравнение настроек при том же лимите покажет не рост, а цену: выше двух — та же скорость, вдвое больше памяти, вдвое дольше обработка задания. Настоящее ускорение — второй worker.
2. **Границу памяти задаёт формат:** конкуренция 3 уже не помещается в 1 ГБ на PNG RGBA 40 Мпкс и свободно помещается на JPEG тех же пикселей. Отсюда четыре класса, а не три.
3. **Брокер не копит и не сдерживает:** 200 000 сообщений — 106 МиБ анонимной памяти. Предел памяти брокера в этой системе — защита от чужого, а не сдерживание работы: без отдельного предела на входе бэклог упрётся только в диск.
4. **Большой prefetch не вреден для одного worker и вреден для всего остального:** очередь выглядит пустой, второй worker простаивает, появляются копии «потерянных». Это видно только особыми опытами, а не по throughput одного worker.
5. **Метрики очереди нельзя снимать `rabbitmqctl`:** 0,5 с CPU на вызов в cgroup брокера.
6. **Профиль `uploads` и `test_reconcile_under_load` копят задания:** первый без worker, второй 16 загрузок в секунду при потолке ~4/с. С пределом по умолчанию они мерили бы предел; это решение 13.
7. **У файлов на границе байтов первым упирается S3, и он общий:** выше ~8–9,6 загрузок/с клиент видит 429 от мест и ответ 3–6 с, а worker в это же время падает с 2,9 до ~0,6 готовых/с. Значит, «перестаёт ускоряться» — не только CPU worker: приём может отнять у обработки её ресурс, и предел заданий — единственное, что это останавливает.
8. **Нехватка памяти контейнера опаснее, чем выглядит:** ядро убивает процессы обработки сериями и доходит до процесса 1 worker (подтверждено журналом ядра в одном прогоне из пяти, ещё в одном — те же признаки). Настройка, которая не помещается в лимит, — это не только повторы, но и остановка всего worker до перезапуска и ожидание аренды.
9. **Короткая ячейка на свежем стенде не видит рост памяти S3 с накопленными объектами:** случай на старом стенде метка не воспроизведёт; ограничение названо (решение 12).
## Goals / Non-Goals
**Goals:**
- Весь трек 1: ≥3 настройки на нескольких классах, throughput, очередь, p95 до `ready`, RSS, backpressure, ограничение принятой работы, восстановление, компромисс latency и ресурсов — с гипотезами до меток и повторяемой командой.
- Предел принятой работы без новой схемы и без лишнего шага с PostgreSQL.
- Прежние механизмы не меняются: места загрузки, цепочка сроков LB, outbox, аренда, fencing, сверка, `rolling_update`.
**Non-Goals** (сознательно, сверх `proposal.md`):
- смена значений `concurrency`, `prefetch` и лимитов контейнера заранее: решение после метки по правилу решения 12;
- ограничение по байтам и пикселям, предел на чат или пользователя (решение 1);
- замена процесса на задание forkserver: цена запуска названа пробой и меткой, замена — отдельное изменение;
- новая схема, новые индексы, новые значения `error_code`.
## Decisions
### 1. Граница принятой работы — предел незавершённых заданий, 429
Что считается: задания `queued` и `processing` — в том числе ожидающие следующей попытки и ещё не опубликованные. Именно эта работа уже обещана клиенту ответом 202, занимает staging и ждёт worker. `pending` не считается: его ответа ещё нет, он ограничен местами. `failed` и `succeeded` не считаются: работа кончилась, у `failed` staging держит срок хранения.
Что видит клиент: 429 `rate_limited`, формат ошибки, `Retry-After`, сразу, без чтения тела и ожидания места. Ни строки, ни объекта. Это та же форма, что у занятых мест: клиент обязан уметь её и так. Повтор — новая загрузка: `Idempotency-Key` не нужен, отклонённая ничего не сохранила.
**Контракт.** `contracts/openapi.json`: у `uploadAttachment` объявлены 429 с заголовком `Retry-After` — положительное целое, и 503 «Зависимость недоступна». `contracts/README.md`: «429 `rate_limited`», «Факультативный … rate limiting» не становится обязательным, но допустим. Рубрика трека прямо требует ограничения принятой работы. Противоречие одно, мягкое: 429 описан как «ограничение частоты запросов», а здесь ограничено количество работы; и уровень 3 говорит о 202 при остановленном worker. Строгая трактовка, которая проходит публичные тесты: у предела — 429, ниже него — 202 при любом состоянии брокера, relay и worker. `make test` и `tests/resilience.py` загружают единицы файлов. Вопросы преподавателю — `QUESTIONS.md`. Другой ответ меняет строку `DOMAIN_ERRORS` и сценарии.
Почему не 503: зависимость жива, реплика готова, LB и монитор не должны видеть отказ; 503 смешал бы перегрузку с падением S3.
| Вариант | Почему нет |
|---|---|
| Нет предела, копить до диска | рубрика; срок ожидания растёт без границы, рекомендовать нечего: проба 8/с против 3/с — +5 заданий в секунду, за час 18 000 заданий и 1,7 часа разбора |
| Возраст старейшего незавершённого | остановка worker дольше порога закрыла бы приём целиком: сценарий защиты «worker остановлен → 202» стал бы зависеть от часов; число принятого предсказуемо и объяснимо |
| Байты или пиксели в работе | точнее по ресурсам: `lp` стоит втрое дороже `s` при том же счёте. Но нужен `SUM` по строкам с чтением heap на каждую загрузку вместо счёта по индексу, а пикселей в строке нет; вместо этого предел выбран по худшему классу (решение 2), ограничение названо |
| Предел на чат или пользователя | справедливость, а не ограничение работы: нет индекса владельца у задания, новая схема; вне трека, ограничение названо |
| Ждать снижения счёта вместо отказа | работа уходит за секунды и минуты, держать соединение и место нельзя; для этого уже есть короткая очередь мест |
| Проверять после тела, перед `pending` | клиент передаёт 10 MiB ради отказа; реплика читает и считает SHA-256 зря |
| Жёсткий предел в транзакции `queued` | счёт под блокировкой на каждую фиксацию и компенсация записанного объекта ради точности ±40 из 250 |
### 2. Значения: предел 250, `Retry-After` 5
**Предел 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 с, с закрытием соединения на зависшем сервере до 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 не вытесняет живые загрузки, а ожидающая в очереди мест загрузка не считается заново.
**Превышение предела** — только в полёте: загрузка прошла счёт, ждёт место до 5 с и идёт до 30 с тела. На стенде 2 × (4 + 16) = 40, при замене реплик 60. Жёсткой границы нет намеренно (решение 1).
**Смесь версий:** прежние реплики предел не считают; новая схема не нужна. Новый образ с прежним уборщиком и worker совместим.
### 4. Цепочка сдерживания
| Уровень | Что ограничивает | Значение | Что видит клиент | Где видно |
|---|---|---|---|---|
| Места загрузки реплики | память приёма, одновременные загрузки | 4 + 16, ожидание 5 с | 429, `Retry-After: 1` | журнал `busy`, k6 |
| **Предел заданий (новое)** | принятая работа, срок ожидания, staging | 250 | 429, `Retry-After: 5`, сразу | журнал `backlog`, k6, счёт незавершённых |
| Шлюз S3, 1 CPU, `concurrentUploadLimitMB` 64 — общий с worker | запись байтов приёма и обработки | 1 CPU, 64 МБ | загрузка дольше, до 3–6 с на `m`; за сроком вызова — 503; готовых/с падает | CPU S3, p95 загрузки, готовых/с в окне |
| Outbox | ничего: копит намерения | — | `queued` | `outbox`, возраст |
| `max_published_backlog` | очередь брокера | 1000 | `queued` | `published`, «Relay backlog is full» |
| Предел памяти брокера | издатель получает отказ по сроку | 400 МиБ | `queued` | журнал relay; пробы: нагрузкой не достигается |
| `prefetch` | выдача worker | 2 | `queued` | `messages_unacknowledged` |
| `concurrency` | работа в процессе | 2 | `processing` | `processing`, CPU |
| Лимиты процесса и контейнера | память и CPU на задание | 450 МиБ, 15 с CPU, 1 ГБ | дольше до `ready`; `failed` при исчерпании | `oom_kill`, `render_killed`, `failed` |
Работа перестаёт **приниматься** на первых двух уровнях, перестаёт **ускоряться** — на CPU worker (`concurrency` сверх двух при 1 CPU) и, для тел у границы байтов, на CPU S3, причём там приём отнимает ресурс у обработки: предел заданий ограничивает и это. За входом клиент видит только дольше неизменный `queued`. Метка показывает это по уровням: ячейки матрицы — от outbox до `concurrency`, блок «приём» — S3, места и затем предел, блок «предел» — новый уровень отдельно. Предел памяти брокера и `max_published_backlog` при значениях по умолчанию нагрузкой не достигаются (пробы, решение 2): их работу доказывают прежние `test_broker_memory_alarm` и `test_published_backlog_limit`.
### 5. Настройки и классы
**Настройки** (`concurrency`, `prefetch`): (1, 1) — меньше памяти, простаивает на S3 и PostgreSQL; (2, 2) — значения по умолчанию; (4, 4) — больше конкуренции, чем CPU, и на `lp` больше памяти, чем лимит; (2, 256) — большой prefetch. Значение 256 больше любого бэклога ячейки: очередь брокера целиком уходит в один worker.
**Классы** — `bench/make_images.py` в контейнере на образе стенда (`--network none`, Pillow образа, зерно `Profile.queue_image_seed` = 20261101, файлы проб), файлы — в `.work/`, размеры и SHA-256 — в паспорте, больше лимита контракта — отказ до стенда:
| Класс | Файл | Зачем | λ низкая / высокая, /с |
|---|---|---|---|
| `s` | JPEG 1600 × 1200, q85 | мало пикселей: цена процесса и декодирования | 1,5 / 8 |
| `m` | PNG RGB из шума 1024 × 3409, IDAT zlib уровня 1, как тело 10 MiB профиля `uploads` | граница байтов: ввод-вывод, S3, SHA-256 | 1,5 / 6 |
| `lj` | JPEG 8000 × 5000, q88 | граница пикселей с `draft`: мало памяти | 1,2 / 6 |
| `lp` | PNG RGBA 8000 × 5000, значащие 4 бита на канал, плавная альфа | обе границы: больше всего памяти и CPU | 0,5 / 2,5 |
Построение, как на пробе: канал — `Image.frombytes("L", …, random.Random(зерно).randbytes(…))` низкого разрешения, растянутый `BICUBIC` (64 ячейки по ширине), плюс такое же поле 512 ячеек, поделённое на 6, плюс плитка шума 512 × 512 амплитуды A, повторённая на всё поле (`ImageChops.add`); зёрна каналов — `зерно + номер`, `+ 10 + номер`, `+ 20 + номер`. `s`: зерно, A = 24, `subsampling="4:2:0"`. `lj`: зерно + 200, A = 24. `lp`: зерно + 200, без плитки, `point(v & 0xF0)` на каналах; альфа — поле 64 ячеек зерна + 300, `128 + v // 2`, тоже 4 бита; `compress_level=6`. `m`: `uploads.png_noise(3409, зерно + 3409)`.
Ни один файл не тривиален для декодера: `lp` — настоящий inflate и Lanczos на 160 МБ пикселей и WebP с альфой 479 КиБ, `lj` — настоящий IDCT, `m` — масштабирование шума. Низкая λ — половина потолка настройки по умолчанию, высокая — 2–2,7 потолка, не выше того, что принимают реплики и S3. **Одна и та же λ для всех настроек класса:** сравниваются настройки при равной нагрузке.
**Ячейки матрицы** — 12 конфигураций: (2, 2) и (4, 4) на всех четырёх классах; (1, 1) на `m` и `lp` (на классах с заметным вводом-выводом и большей памятью; `s` проба показала рядом с (2, 2)); (2, 256) на `s` и `lp` (самый короткий и самый длинный процесс). Вместе с блоками решения 8 — 19 конфигураций × 3 повтора = 57 ячеек, круги: на круге — перестановка всех конфигураций от зерна `Profile.order_seed`, первая ячейка круга не равна последней прошлого (`overload.plan_cells`, как `scaling.plan_cells`). Модуль называется `bench/overload.py`, а не `queue.py`: каталог скрипта стоит первым в `sys.path`, и `queue.py` затенил бы модуль stdlib, который импортируют `concurrent.futures` и `logging.handlers`. План — в `meta.json` до первой ячейки.
### 6. Окна нагрузки
Ячейка — свежий стенд (`kill`, `down -v`, затем `Stand.start`), пользователь и чат (`prepare.js`), разогрев: 12 файлов `s` до `ready` — они же готовые байты контрольного потока (`downloads.json`). Затем:
| Окно | Длительность | Загрузки | Зачем |
|---|---|---|---|
| `before` | 10 с | низкая λ | задержка и ресурсы ниже потолка |
| `over` | 20 с (блоки предела и рестартов 25 с, приёма 45 с) | высокая λ | рост очереди |
| `recovery` | до нуля незавершённых, не дольше 420 с | нет | разбор очереди |
| `after` | 10 с | низкая λ | задержка вернулась |
Открытая модель: `constant-arrival-rate` k6 (`bench/k6/queue.js`), сценарий на окно, `timeUnit: "10s"` для дробной λ. VU создаются заранее и не прибавляются (`queue_pre_vus`: окно `over` 20, у блока «приём» 80, окна ниже потолка 4): тело — `open` на VU, создание на ходу с телом 10 MiB теряет итерации (проба: 33–36 при 8 заранее и 60–80 пределе), а 80 VU — это уже ~2,7 ГиБ k6 при запасе ВМ. Ответ не повторяется: 429 — отказ, недосланные итерации — `dropped_iterations`, пометка. Строка на загрузку: `q,<окно>,<отправка мс>,<длительность мс>,<статус>,<Retry-After>,<X-Instance-Id>,<id>` в файл консоли, полнота — сверка с итерациями. Момент приёма — отправка + длительность по часам ВМ, как в профилях `failover` и `uploads`.
Контрольный поток — готовый `bench/k6/background.js` (полнота `reconcile.line_problems`, остановка SIGINT): запись 10/с, чтение истории 10/с, скачивание готовых 5/с. Запущен до `before`, остановлен после `after`. Числа — ниже потолка API в разы: он меряет влияние перегрузки, а не нагружает.
### 7. Метрики и определения
**Очередь — три места и общий счёт.** Каждую секунду:
| Поле | Что считаем | Откуда |
|---|---|---|
| `outbox` | `queued`, `published_at IS NULL`, срок наступил: relay ещё не передал | PostgreSQL |
| `waiting` | `queued`, `published_at IS NULL`, срок не наступил: пауза следующей попытки | PostgreSQL |
| `published` | `queued`, `published_at` есть: брокер подтвердил, никто не взял | PostgreSQL |
| `broker_ready` | `messages_ready`: лежит в брокере | метрики брокера |
| `broker_unacked` | `messages_unacknowledged`: выдано worker, не подтверждено | метрики брокера |
| `processing` | взято, идёт аренда | PostgreSQL |
| `prefetched` | `max(0, broker_unacked − processing)`: у worker, но ждёт места конкуренции | вычисляется |
| `unfinished` | `outbox + waiting + published + processing`: то, что считает предел | PostgreSQL |
| `oldest_s` | возраст старейшего незавершённого | PostgreSQL |
| `staging_ready` | `ready` с необнулённым `staging_key`: долг очистки | PostgreSQL |
В строку ячейки — пики и значения на конце окна; в `timeline.csv` — посекундно. `queue_wait_ms` из журнала worker (от подтверждения брокером до взятия) — p50 и p95 по окнам: то, сколько задание провело собственно в очереди брокера и worker.
**Throughput** — готовых в секунду: вложения с `updated_at` статуса `ready` в окне `over` и в окне `recovery`, делённые на длину окна. **Время до `ready`** — `updated_at` у `ready` минус момент ответа 202; p50, p95, p99 по окну прихода (`before`, `over`, `after`); для перцентилей `before` и `after` повторы сводятся вместе: заданий в них единицы и десятки. **Восстановление** — от последней загрузки окна `over` до нуля незавершённых. **`failed`** — по `error_code` и причине.
**RSS и память:** `VmHWM` процесса 1 worker (`/proc/1/status`, `docker exec` в конце ячейки), `render_peak_kib` журнала — p50 и наибольший, `memory.peak`, наибольшие `memory.current` и `anon` контейнера, `oom_kill` (`memory.events`). `memory.peak` не нуждается в сбросе: контейнер новый в каждой ячейке; у перезапущенного worker — наибольшее по жизням (решение 10), `VmHWM` — последней жизни. **CPU и троттлинг** — ядер, доля и мс троттлинга (`cpu.stat`) worker, S3, PostgreSQL, реплик, relay, брокера, уборщика, LB по окнам, `reconcile.window_cpu`; CPU worker на задание — за всю ячейку. **Брокер:** наибольшая `memory.current` cgroup; сработавший предел памяти виден как отказ в журнале relay.
**Журналы** (`docker logs`, только разбор, в метку не копируются): worker — «Started worker» (сверка настроек), «Started job attempt» (`queue_wait_ms`, `redelivered`), «Attachment became ready» (`render_ms`, `render_peak_kib`, `duration_ms`), «Retrying job», «Attachment failed», «Skipped job message»; relay — сумма `published`, `republished`, `recovered`, «Relay backlog is full»; реплики — «Rejected attachment» по `reason`; уборщик — «Finished staging cleanup pass».
### 8. Блоки сверх матрицы
| Блок | Конфигурация | Что меряет | Что ждём по пробе |
|---|---|---|---|
| `gate-on` | `s`, (2, 2), 20/с, 25 с, предел по умолчанию | плато незавершённых, 429, задержку | плато 250, 429 ~180, p95 до `ready` и восстановление ~85 с |
| `gate-off` | то же, `UPLOADS__MAX_UNFINISHED_JOBS=0` | рост без предела | пик ~430, p95 и восстановление ~145 с |
| `accept` | `m`, (2, 2), 15/с, 45 с, предел по умолчанию | цепочку приёма: S3, места, затем предел; что с worker | 429 `busy` с ~10-й секунды, `backlog` с ~35-й, S3 у 1 CPU до предела, ~0,6 готовых/с до него, пик 250–290 |
| `w2-p2` | `s`, (2, 2), второй worker в конце `over` | ускорение от ресурса | ~5,4/с вместо ~3/с |
| `w2-p256` | `s`, (2, 256), то же | простой второго worker | второй берёт 0 заданий |
| `kill-worker` | `s`, (2, 2), 8/с, 25 с, KILL и запуск в середине | не теряем, аренда | две попытки у 2 заданий |
| `restart-broker` | `s`, (2, 2), 8/с, 25 с, `compose restart` в середине | не теряем, outbox растёт на время рестарта | попыток сверх одной нет |
Второй worker — `docker compose run -d --no-deps --name mtusi-bench-worker-2 worker` с тем же override; момент запуска — конец `over`, а не середина: новые сообщения во время `over` брокер делил бы поровну и смазывал бы опыт, а реальный ответ оператора на перегрузку — запуск после обнаружения. Базовая линия без второго worker — ячейки матрицы (`s`, (2, 2)) и (`s`, (2, 256)). Доля заданий второго — по его журналу. Лимиты те же, бюджет — решение 10.
Копии при `prefetch` больше конкуренции (проба: 188 на 150 заданий при пороге 15 с) в метку не входят: опыт требует менять порог, а на значениях по умолчанию при пределе 250 бэклог короче порога. Механизм уже назван в `REPORT.md`, эффект нулевой, и его закрывает правило `prefetch = concurrency` решения 12. При (2, 256) в матрице число копий пишется как есть (ждём 0).
### 9. Граница чёрного ящика
Генератор — только HTTP через LB. **Истина о готовности — `GET /attachments/{id}`:** после окна `after` и разбора очереди `bench/k6/queue_sweep.js` запрашивает метаданные каждого принятого вложения (`shared-iterations`, ids из строк k6): статус, `error_code`, число вариантов, `updated_at`; у выборки (10 на ячейку, от зерна) скачивает оригинал и три варианта и сверяет SHA-256 с метаданными. Живой опрос не нужен: `updated_at` у `ready` не меняется после фиксации (`clear_staging_key` его не трогает, сценарий «Готовое вложение не откатывается»), а нагрузки опроса на API в замере не будет. Новые исключения из границы чёрного ящика, только у этого профиля и только на чтение:
- `psql \watch` сэмплера — счётчики задач выше и чтение SQL в конце ячейки: одно задание на вложение, три варианта на `ready`, попытки, причины (`pg_stat_*` не нужны). Данных и схемы оркестратор не меняет;
- метрики брокера по HTTP в сети стенда;
- журналы контейнеров, разбор без копирования.
### 10. Стенд и сэмплер
- **`bench/queue.compose.yml`** (статический, третий `-f` только у этого профиля): у `rabbitmq` — read-only файлы `bench/rabbitmq/enabled_plugins` и `bench/rabbitmq/91-bench.conf` (`collect_statistics_interval = 1000`). Порт 15692 — только сеть стенда: порты сброшены в `bench.compose.yml`. У прочих профилей и рабочего стенда плагина нет. Окружение настроек — `.work/variant.compose.yml`, как у `uploads`: `WORKER__CONCURRENCY`, `WORKER__PREFETCH`, `UPLOADS__MAX_UNFINISHED_JOBS`.
- **Перезапуск worker** — `restart: unless-stopped` в `queue.compose.yml`, как на рабочем стенде, а не `"no"` из `bench.compose.yml`: проба — ядро убивает процесс 1 при (4, 4) на `lp`, и без перезапуска ячейка простояла бы до срока окна с ложными `stuck`. Столбец `worker_restarts` — `.RestartCount`, пометка `worker_restart`. Перезапуск сбрасывает cgroup того же контейнера: `memory.peak` и наибольшая `anon` — наибольшее по жизням, `oom_kill` — сумма, CPU — разности внутри жизни. У S3 остаётся `"no"`: его гибель — аномалия, она должна быть видна пометкой `storage_down`, а не пережита. `docker kill` блока `kill-worker` демон считает ручной остановкой, запуск — явный `docker start`; успей он раньше — `start` ничего не меняет.
- **`Stand.start`** при `is_queue`: S3 и bootstrap, брокер, реплики и LB, relay, уборщик и worker `--no-deps`. Уборщик работает: иначе staging копился бы мимо рабочего поведения; плановая сверка выключена (`bench.compose.yml`). `Stand.stop()` и `leftovers()` — ещё `mtusi-bench-worker-2`, `mtusi-bench-images`. Перед `down` — `compose kill`: S3 иначе останавливается ~15 с.
- **`sampler.sh`, режим `queue`:** раз в секунду — обход cgroup, как `scan` (`cg`), `vm`, `lb`; новые строки `mp <нс> <id12> <memory.peak> <anon> <oom_kill>` и `mq <нс> <ready> <unacked>` (`/dev/tcp/rabbitmq/15692`, HTTP/1.0, фильтр по имени очереди; брокер недоступен — `mq <нс> missing`). В фоне `psql \watch` — строка `jobs` с полями решения 7, один запрос в секунду на маленькой таблице свежего стенда. Контейнер: `--cgroupns host`, сеть стенда, `--env POSTGRES_PASSWORD`, 0,25 CPU / 128 МиБ. Разбор — `bench/overload.py`, `cg` и `vm` — `scaling.parse_samples`. Роли — `Stand.container_map()`: второй worker и контейнер после рестарта видны сами; сторож — тиков нет 3 с в нагрузке — отказ, как у `failover`.
- **Готовность к сравнению:** `limits` читаются у запущенных контейнеров, на все ячейки одни (кроме второго worker). Запись «Started worker» сверяется с ячейкой: расхождение — отказ.
- **Бюджет:** CPU реплики 2 + PostgreSQL 2 + LB 1 + Valkey 0,5 + S3 1 + брокер 1 + relay 0,25 + worker 1 (второй ещё 1) + уборщик 0,25 + сэмплер 0,25 = 9,25–10,25 из 12; память лимитов 5–6 ГиБ плюс k6 до ~2,7 ГиБ на блоке приёма из 7,75: занято по пробам ~3,5 ГиБ без k6, сумма лимитов до конца не выбирается. `vm_warnings` считает эти роли, сумма CPU больше ВМ — код 2 до стенда, как `level4_budget`. Посторонние контейнеры — в паспорт.
### 11. Достоверность и шум
**Пометки строки** (`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 нет: это умножило бы время, а настройка по умолчанию повторяется в каждом круге и служит опорой.
**Хост** — `bench.md`: перед меткой рабочий стенд `make stop`, питание от сети. Прирост `Swapouts` за ячейку — пометка `host_swap`: настоящая помеха, такая метка переснимается под новым именем, если задетые ячейки входят в выводы; каталог метки не перезаписывается. Прочие предупреждения о хосте, явно не влияющие на замер, прогон не останавливают (указание пользователя 2026-10-31).
### 12. Гипотезы, правило рекомендации и значения по умолчанию
Записываются в `REPORT.md` и коммитятся раньше меток замера. Числа — из проб выше. Вердикт считает `bench/overload.py`, в сводке: «подтверждено», «нет», «нет данных».
| № | Гипотеза | Подтверждено, если |
|---|---|---|
| H1 | Потолок при 1 CPU — CPU worker; конкуренция сверх двух его не поднимает | на всех классах медиана throughput окна `recovery` (4, 4) / (2, 2) ≤ 1,05; CPU worker в окне `over` при c ≥ 2 ≥ 0,85 ядра; на `m` и `lp` (1, 1) / (2, 2) ≤ 1,0 |
| H2 | Обработка задания дольше пропорционально конкуренции, память растёт на пик процесса | `duration_ms` p50 (4, 4) / (2, 2) ≥ 1,5 на всех классах; `memory.peak` (2, 2) < 1 ГБ без `oom` на всех классах; (4, 4) на `lp`: `memory.peak` ≥ 95 % лимита во всех повторах, `oom_kill` > 0 хотя бы в одном (пробы: в трёх прогонах из четырёх); (4, 4) на `lj`: без `oom`, пик ≤ 500 МиБ |
| H3 | Большой prefetch не меняет throughput одного worker и прячет очередь от брокера и второго worker | (2, 256) / (2, 2): throughput в [0,85; 1,15], p95 до `ready` в [0,8; 1,25] на `s` и `lp`; пик `broker_ready` ≤ 10 % пика незавершённых у (2, 256), ≥ 70 % у (2, 2); блок второго worker: доля второго среди заданий, завершённых после его запуска, ≥ 30 % при `prefetch` 2 и ≤ 5 % при 256, восстановление p256 / p2 ≥ 1,4 |
| H4 | Задержка под перегрузкой — это очередь | на всех ячейках матрицы без `oom` p95 до `ready` окна `over` в [0,8; 1,25] × пик незавершённых / throughput |
| H5 | Предел ограничивает принятую работу и срок ожидания | `gate-on`: пик незавершённых ≤ 290, 429 > 0, у всех `Retry-After` 5, 5xx нет, 429 = записи `backlog`; `gate-off`: пик ≥ 375; `gate-on` / `gate-off`: p95 до `ready` и восстановление ≤ 0,75; p95 до `ready` `gate-on` в [0,8; 1,25] × предел / throughput; загрузка `before` p50 `gate-on` − `gate-off` ≤ 3 мс (проба A/B: +0,9 мс) |
| H6 | Восстановление: система приходит в норму сама и никого не теряет | во всех ячейках `lost`, `stuck`, `duplicate`, `sha_mismatch` нет; восстановление ≤ 1,3 × пик незавершённых / throughput окна `over` (матрица без `oom`, предел); p95 `after` ≤ 1,5 × p95 `before` по конфигурации; `failed` только при `oom` и только `retry_exhausted` |
| H7 | Перегрузка очереди не задевает остальной API | во всех окнах всех ячеек, кроме `accept`: p95 записи и чтения ≤ 200 мс, скачивания ≤ 500 мс; 5xx контрольного потока нет; `lb_down` нет |
| 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). Настройка, снятая не на всех классах, — (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`;
- один worker; второй — только в своём блоке и на классе, где S3 не узкое место: общая формула масштабирования не утверждается;
- ячейка — один класс, один файл на все загрузки: смесь размеров и разброс содержимого не мерятся;
- окна короткие, 20–45 с перегрузки: многочасовая перегрузка, autovacuum под длинным оборотом и рост WAL не мерятся, проба — только 90 с оборота;
- открытая модель без повторов: поток клиентов, послушно повторяющих после `Retry-After`, не мерится; отказ считается отказом;
- PostgreSQL, relay и брокер в этих интенсивностях не упираются: их предел трек не определяет; `max_published_backlog` и предел памяти брокера нагрузкой не достигаются (решение 4);
- одна нода S3, staging и конечный префикс на одном диске ВМ; ячейки — на свежем volume, поэтому рост памяти S3 с накопленными объектами не мерится (проба на старом стенде — `KNOWN_ISSUES.md`);
- выборки `before` и `after` малы на `lp`: повторы сводятся, p99 у малых выборок — только справочно;
- завершение процесса 1 ядром при (4, 4) на `lp` случайно (пробы: один подтверждённый случай и один по тем же признакам из пяти прогонов): его частота из трёх повторов не следует, метка показывает, что работа не теряется.
### 13. Что ещё меняет предел
- **Профиль `uploads`:** worker в нём нет, задания копятся; `.work/variant.compose.yml` всех его вариантов получает `UPLOADS__MAX_UNFINISHED_JOBS=0` (спек, сценарий «Предел заданий не участвует»). Прежние метки не сравниваются (они и так не сравнивались, решение 16 архива).
- **Стенд отказов:** у четырёх прежних API `UPLOADS__MAX_UNFINISHED_JOBS=0` (`run_failures.py`): `test_reconcile_under_load` — 16 загрузок/с против ~4/с, остановленные worker других проверок. Пятый API — «узкий по заданиям», `BACKLOG_ENV` = `UPLOADS__MAX_UNFINISHED_JOBS=3` → `FAULT_BACKLOG_BASE_URL`, `FAULT_BACKLOG_ENV`, фикстура `backlog_api`, `assert_backlog_stand`; `pytest -m fault` без него — отказ, как у остальных.
- **`make test_isolated`, `make student_test`, `driver.py`:** значение по умолчанию; единицы загрузок, `reconcile-stress` — `upload_ready` по очереди, замкнутый контур: предела не достигают.
### 14. Файлы метки и цена
`evidence/queue/<метка>/`: `meta.json` (профиль, образы, классы и SHA-256, план, лимиты, окружение, `host_state`), `cells.csv` (строка на ячейку, новые столбцы — только в конец; готовая строка — признак для `RESUME=1`), `timeline.csv` (посекундно, с отметками окон), `summary.md`, `throughput-by-setting.svg`, `p95-by-setting.svg`, `memory-by-setting.svg`, `backlog-gate.svg` (`plots.Svg`), `raw/<ячейка>-k6.json` (итоги k6 без токенов). `quick-queue-*` — в `.gitignore`. `RESUME=1` и блокировка — как у серий.
**Время.** Ячейка матрицы: стенд с уборкой ~30 с, разогрев ~5, окна 10 + 20 + ~39 (среднее восстановление по пробам, `lp` при (4, 4) — 40–80 с) + 10, конец ~8 = ~122 с; 12 × 3 = 36 ячеек — ~73 мин. Блоки: `gate-off` ~240 с, `gate-on` ~175, `accept` ~210, `w2-*` ~100–115, `kill-worker` и `restart-broker` ~140–150, вместе 7 × 3 = 21 ячейка — ~57 мин. **Полная метка — чуть больше двух часов (~2 ч 10 мин)** плюс сборка и файлы классов ~1 мин; перезапуск worker с ожиданием аренды добавляет ячейке до 70 с. `queue_quick` — `s` (2, 2), `lp` (4, 4), предел с `UPLOADS__MAX_UNFINISHED_JOBS=40` и без него, `kill-worker`, `w2-p256`, по одному повтору, окна 5 + 10 + … + 5: ~11 мин.
### 15. Сценарий защиты и документы
**Защита:** шаг «для 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`.
## Покрытие сценариев
Сценарии спеков из `CAPABILITIES`; `fault` — `make failure_checks`, стенд с пятым API.
| Capability, сценарий | Проверка |
|---|---|
| `queue-overload` «Предел достигнут», «Порядок проверок у предела», «Остальной API у предела», «Загрузки снова принимаются» | `test_backlog_limit`, fault |
| «Завершённые задания не считаются» | `test_backlog_ignores_finished`, fault |
| «Ожидание следующей попытки считается» | `test_backlog_counts_waiting_retry`, fault |
| «Предел при остановленных брокере и relay» | `test_backlog_without_broker`, fault |
| «Превышение ограничено» | `test_backlog_overshoot_bounded`, fault |
| «Предел выключен» | `test_backlog_off`, fault |
| «Работа копится там, где положено», «Приём упирается в места загрузки», «Сначала места, затем предел», «Контрольный поток под перегрузкой», «Бэклог уходит за измеренное время», «Никого не теряем», «Время до готовности вернулось», «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` — прежние тесты, текст уточнён.
## Risks / Trade-offs
- [Предел один на стенд: один клиент может занять его целиком] → ограничение названо; места загрузки ограничивают скорость такого клиента; справедливость — отдельная тема вне трека.
- [Счёт — по числу, а `lp` втрое дороже `s`] → значение выбрано по худшему классу, у мелких файлов предел консервативен; видно в таблицах.
- [Предел отклоняет загрузки при остановленном worker] → это и есть граница; текст, история, метаданные, готовые байты и `/health/ready` работают (сценарий), `make replay` не задействован; при длинном простое оператор видит `backlog` в журнале.
- [`Retry-After` без случайной добавки: клиенты могут повторять разом] → у них 5 с; отказ — один запрос к PostgreSQL, 1,9 мс CPU реплики и 0,3 мс PostgreSQL (проба), ~1 000 отказов/с на двух репликах; места не занимает.
- [Счёт идёт в первом блоке: загрузка, попавшая в кэш чата, теперь берёт соединение] → +0,9 мс p50, +0,8 мс CPU реплики и +0,4 мс PostgreSQL на самой дешёвой загрузке (проба A/B, оценка сверху); `[database]` срок прежний; шаг прежний, цепочка LB та же.
- [Приём на границе байтов отнимает S3 у worker: ~0,6 готовых/с вместо 2,9] → предел заданий останавливает это на 250, но не раньше ~35 с такой нагрузки; места и `concurrentUploadLimitMB` пока делят ресурс как есть. Отдельный приоритет обработки — вне трека, вывод — по метке.
- [Ядро может убить процесс 1 worker, если конкуренция не помещается в лимит] → работа не теряется, контейнер перезапускается, задания возвращаются по аренде (до 70 с); значение по умолчанию на всех классах помещается; правило подбора конкуренции — `worker.md`.
- [S3 на долго живущем стенде подходит к лимиту памяти] → вне метки, `KNOWN_ISSUES.md` с предложением; рабочий стенд перезапускает его сам, а бюджет задания переживает короткий рестарт.
- [Плагин метрик брокера только в профиле] → паспорт называет; простой + 0,1 % ядра, файлы конфигурации только у этого профиля; рабочий стенд не меняется.
- [Метка ~2 ч 10 мин на ноутбуке] → `caffeinate`, `RESUME=1`, предупреждения о хосте; порядок кругами размазывает дрейф хоста по конфигурациям.
- [Одна λ на все настройки: у (1, 1) и (4, 4) очередь больше] → это и меряется; `recovery` ограничен 420 с, `not_recovered` — пометка.
- [Малые выборки `before` и `after` у `lp`: 4–5 заданий] → повторы сводятся; вывод только с разницей больше разброса, в отчёте названо.
- [Заливка одним и тем же файлом класса] → дедупликации в приложении и в S3 нет; разнообразие контента не проверяется, это ограничение синтетики, названо.
- [Один worker и один хост: второй worker на той же ВМ, S3 один] → блок `w2-*` — на `s`, где S3 не узкое место (0,09 ядра); общая формула масштабирования не утверждается.
## Migration Plan
1. Шага оператора нет: секретов и схемы не прибавилось; существующий `config.toml` — значение по умолчанию.
2. Вперёд: `make rolling_update`. Смесь реплик безопасна: прежние предел не считают.
3. Откат: `make rolling_update COMMIT=<прежний> MIGRATE=0`. Данные не менялись.
4. После проб в scratchpad остаётся `track1/` (кандидаты, скрипты, журналы). Контейнеры, сети и образы проекта `q1probe` удалены. Остались его volumes `q1probe_postgres_data`, `q1probe_rabbitmq_data`, `q1probe_s3_data`: при уборке автопроверка отказала в команде с `docker compose … down -v`, обход не применялся; удалить вручную — `QUESTIONS.md`, «Для пользователя после прогона».
## Уточнения apply
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/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
Вопросы преподавателю — `QUESTIONS.md`, раздел `track1-queue-overload`: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий.