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

91 KiB
Raw Blame History

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 не меняются):

  1. Причина завершения 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).
  2. Настройка, снятая не на всех классах, не кандидат. Цикл пропускал не снятый класс, и «на каждом классе» проверялось только на снятых; (1, 1) с данными по двум классам из четырёх могла победить. Теперь она называется в сводке, а её снятые числа участвуют в «лучшей на классе». Порог 90 % прежний; на метке baseline итог тот же: (2, 2).
  3. Сверка принятых — и в обратную сторону. Вложение стенда не из 202 и не из разогрева — unexpected_rows; больше, чем 5xx и обрывов, — пометка unexpected, код команды как у lost. В условие H6 не добавлена: его список записан до метки (H6_FLAGS).
  4. lb_down считает только слоты-серверы, и UP 1/2 — реплика ещё в балансировке. Прежний подсчёт брал BACKEND третьей репликой, и выход одной реплики не срабатывал: метка baseline об этом условии H7 ничего не говорит. Подготовка стенда (wait_ready, failover.parse_lb_stats) BACKEND отбрасывала сама, другой такой ошибки в профиле нет. Новый столбец lb_up_min.
  5. Queue lag по окнам: queue_wait_<окно>_p50_ms и _p95_ms по окну прихода задания — по attachment_id журнала; разогрев туда не входит, в прежних столбцах на ячейку он остался. peak_oldest_<окно>_s — по окну тика. Литеральная доля второго worker — second_share_all, доля в окне after — second_share_after, столбец порога second_share прежний.
  6. «17 с» в спеках load-balancing и service-configuration не менялись: дельт этих требований в change нет, а формула верхней границы всё равно меньше 30 с. Запись и предложение — KNOWN_ISSUES.md, там же формула уборщика.

Open Questions

Вопросы преподавателю — QUESTIONS.md, раздел track1-queue-overload: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий.