Reject uploads with 429 at [uploads] max_unfinished_jobs, counted by the existing partial indexes in the membership block. Add the bench_queue profile, hypotheses H1-H9 and the fifth failure-stand API. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
436 lines
85 KiB
Markdown
436 lines
85 KiB
Markdown
# 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 с): ожидание в очереди короче порога потерянного сообщения, и копий не будет и при `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` остаётся страховкой на случай большего предела; менять его поводов нет (пробы: сообщение стоит брокеру меньше килобайта).
|
||
|
||
**`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` запроса нет.
|
||
- **Исключение:** `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`; `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` — результат настройки.
|
||
|
||
**Шум.** Объявлено заранее: разброс — 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). **Значения по умолчанию** меняются, только если рекомендация отличается от (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/baseline/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/baseline/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` — сумма по жизням плюс перезапуски.** На `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`, «Для пользователя после прогона»).
|
||
|
||
## Open Questions
|
||
|
||
Вопросы преподавателю — `QUESTIONS.md`, раздел `track1-queue-overload`: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий.
|