Files
mtusi2026lab5/REPORT.md
T
2026-11-02 08:23:06 +03:00

167 KiB
Raw Blame History

Отчёт — лабораторная 5

  • Автор, группа: Сафронов Роман Николаевич, БВТ2301
  • Целевая оценка; выбранный трек 5: оценка 5, трек 1 «Очередь под перегрузкой»
  • Состояние отчёта: закрыты уровень 3 (change async-attachments) и уровень 4 (change pipeline-reliability); уровень 5, трек 1 — change track1-queue-overload, раздел «Очередь под перегрузкой». Все доказательства исключений сверки покрытия сняты на стенде этой лабы
  • Ветка решения: solution/bvt2301-safronov, в неё по очереди вливаются feat/async-attachments, feat/pipeline-reliability, feat/unit-of-work, feat/track1-queue-overload
  • Commit: трек 1 — код d68a016, метка b104690 (раздел «Очередь под перегрузкой»); уровни 3 и 4 — d8fe2e8 (ветка feat/unit-of-work, перенос на единицу работы и правки verify); снятое на 9639aa1, 6ba74b1, 399da05, e2a6427 и ff1a83b названо в разделе доказательств
  • PR: по шаблону .github/pull_request_template.md, заголовок ЛР 5 — БВТ2301 — Сафронов — на 5; номер — после публикации
  • Согласования с преподавателем: три договорённости лаб 1–4 действуют, новых в лабе 5 нет (раздел «Согласования с преподавателем»). Открытые вопросы преподавателю — 12, раздел «Открытые вопросы преподавателю»; решения без пользователя — QUESTIONS.md
  • Источники, библиотеки и помощь ИИ — последний раздел

Запуск из чистого clone

Версии. Образ API: python:3.12.14-slim-trixie, uv 0.12.17. LB: haproxy:3.4.6-trixie. PostgreSQL: postgres:18.6-trixie. Valkey: valkey/valkey:9.1.2-trixie. S3: chrislusf/seaweedfs:4.48. Брокер: rabbitmq:4.3.7. Все закреплены тегом и digest в Dockerfile и docker-compose.yml. Приложение: Python 3.12, FastAPI, aio-pika 10.2.1 (aiormq 7.2.4), Pillow 13.0.0, aiobotocore; остальное строго по uv.lock. Проверено на Docker 29.9.2, Compose 5.6.1, macOS на Apple M3 Pro.

Нужно на машине: Docker с BuildKit и Compose v2, make, openssl, curl, python3 3.9+ (публичные проверки и драйвер скилла), uv (make validate, make student_test, make test_isolated, make failure_checks, make bench*, make run_dev). Свободные порты 127.0.0.1: 8080 (LB), 5433 (PostgreSQL), 6380 (Valkey), 8334 (S3), 5673 (AMQP), 18088 (make test_isolated).

Действий оператора нет. make env_setup создаёт .env и config.toml из шаблонов, подставляет случайные пароли и ключи и печатает только имена. В существующий .env он дописывает недостающие переменные (секреты брокера и ключи worker при переходе с лабы 4), прежние строки не меняет. Пароль брокера, как и пароль PostgreSQL, задаётся при первом создании volume.

Способ 1: всё в compose — make run_docker

git clone <fork> && cd <каталог clone> && git checkout solution/bvt2301-safronov
make run_docker       # env_setup + build + up -d: postgres, valkey, s3, rabbitmq → migrate, s3-bootstrap → api × 2, relay, worker, cleaner → haproxy
make replicas         # дождаться healthy реплик; готовность стенда — haproxy (healthy) и /health/ready через LB
make check
uv sync && make validate PYTHON=.venv/bin/python
make test             # публичный smoke: 202, опрос до ready, оригинал и настоящий JPEG thumbnail
make instances        # ≥2 X-Instance-Id одной сессии через LB
make s3_check         # приватность bucket: права ключей API, уборщика и worker
make student_test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make replicas
python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 defense-scenario
python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 defense-faults   # шаг 4 защиты, ~2–4 мин
make replay           # реестр failed, только показ; APPLY=1 ATTACHMENT=<id> — вернуть в работу
make failure_checks   # отдельный стенд <проект>-failures, ~40 мин; рабочий стенд не трогается

Миграции применяет одноразовый сервис migrate, bucket и пользователей S3 — s3-bootstrap; реплики, relay, уборщик и worker их ждут. Очередь объявляют relay и worker при подключении: отдельного bootstrap брокера нет, реплики API к брокеру не обращаются.

Способ 2: сервис на хосте — make run_dev, make run_worker, make run_relay

make run_dev          # терминал 1: Postgres и миграции с хоста, Valkey, S3 с bootstrap, брокер в compose; API на 127.0.0.1:8080 с reload
make run_worker       # терминал 2: worker на хосте; ключи worker — из .env в окружение процесса, значения не печатаются
make run_relay        # терминал 3: relay на хосте; без него задания ждут в PostgreSQL
curl -s http://127.0.0.1:8080/health/ready
make test
EXPECT_REPLICAS=1 make student_test

Ожидание готовности — /health/ready отвечает 200. Остановка процессов — Ctrl+C.

Вариант README без make: make env_setup, docker compose --env-file .env config --quiet, docker compose --env-file .env up -d --build.

Остановка и удаление данных

  • make stop — остановить контейнеры; make down — удалить контейнеры. Volumes postgres_data, s3_data, rabbitmq_data остаются.
  • make wipe_data — намеренное удаление учебных данных и volumes (спрашивает yes).

Архитектура и решения

клиент → HAProxy (127.0.0.1:8080) → api × 2 ──┬─ PostgreSQL (источник истины: метаданные, задания = outbox, варианты)
                                              ├─ Valkey (кэш карточек чатов)
                                              └─ S3: <база>/staging/<id>/original
relay → PostgreSQL: state = 'queued' AND published_at IS NULL, срок наступил; истёкшие аренды
      → RabbitMQ: durable-очередь <база>.attachment.process.v1, publisher confirm, затем отметка published_at
                    │ job_id, attachment_id, pipeline_version, attempt…
                    ▼
worker → PostgreSQL: claim с арендой и номером попытки → render: отдельный процесс на задание, лимиты, без секретов
       → S3: <база>/attachments/<id>/original, …/v1-thumbnail, v1-crop, v1-optimized
       → PostgreSQL: ready или failed с fencing, затем ack
cleaner → PostgreSQL + S3 (pending, staging у ready и по сроку у failed, сверка bucket и БД)
make replay → relay replay: реестр failed и возврат работы с аудитом

Перенесено из лаб 2–4 без изменения поведения (подробности — REPORT.md репозитория mtusi2026lab4-safronov): вход Basic → Bearer-сессия в PostgreSQL, пароль — Argon2id (RFC_9106_LOW_MEMORY: t=3, m=64 MiB, p=4), SHA-256 токена в БД; кэш карточек; реплики без состояния за HAProxy, идемпотентность сообщений, make rolling_update; приватный S3 с тремя пользователями, места загрузки, уборщик и сверка.

Изменено на уровне 3 (design change async-attachments):

  • POST …/attachments — 202 со снимком queued;
  • worker: claim задания под FOR UPDATE, чтение staging и сверка размера и SHA-256 со строкой, PUT оригинала в конечный ключ, варианты, фиксация ready вместе с вариантами и заданием одной транзакцией, ack;
  • состояния queued, processing, ready, failed в API; pending наружу не виден (404);
  • скачивание не готового вложения — 409, отсутствующий вариант готового — 404; failed в сообщении — 409, а повтор отправленного сообщения с тем же ключом — тот же 201;
  • схема только расширена: attachment_jobs, attachment_variants, attachments.staging_key и error_code, более широкий CHECK статуса (NOT VALID).

Изменено на уровне 4 (design change pipeline-reliability):

  • порядок приёма: строка pending с ключами → PUT в staging → queued с заданием одной транзакцией → 202. Брокера в пути запроса нет, у реплик ни клиента, ни пароля;
  • outbox — те же строки attachment_jobs (state = 'queued' AND published_at IS NULL); relay публикует с подтверждением под FOR UPDATE SKIP LOCKED, отмечает только подтверждённые, возвращает истёкшие аренды и потерянные сообщения;
  • сообщение — подсказка, истина в строке задания: дубль при живой аренде и сообщение раньше срока подтверждаются без эффекта; аренда job_timeout + lease_margin без пульса, номер попытки — fencing;
  • варианты crop и optimized; декодирует только отдельный процесс на задание с лимитами;
  • backoff с jitter, постоянные и временные ошибки, реестр failed в PostgreSQL и make replay с аудитом (attachment_job_replays, attempt_base);
  • prefetch отдельно от concurrency; очистка staging уборщиком, класс сверки orphan_staging;
  • схема только расширена: ревизии c7e2f1a04b56 и d3f9a6b2c1e7.

Единица работы (design change unit-of-work, Cosmic Python, главы 2 и 6). С PostgreSQL сервисы всех процессов работают только через абстракции src/core/ports/: AbstractUnitOfWork и абстрактные repo; реализации на SQLAlchemy выбирают точки входа (src/api/dependencies.py, src/worker/main.py, src/relay/main.py, src/cleaner/main.py). Остальные зависимости конкретные и названы: Cache, ObjectStorage, JobPublisher, ImageRenderer сервис импортирует как типы и получает конструктором (сигнатуры фейков сверяет тест, design.md, решение 8), а src.infra.password и логгер вызывает прямо из модуля (уточнение 20). Граница транзакции одна и видна в сервисе: async with self.uow: — один блок, одна транзакция; явный await self.uow.commit(), выход без него — откат. Вложенный блок и repo вне блока или после фиксации — ошибка, в том числе на фейке. Доменной модели, агрегатов и message bus нет: логика и так в сервисах, а границы транзакций заданы контрактом. Кэш Valkey и S3 в единицу работы не входят: фиксация и откат на них не действуют. Соединение занято на шаг: JSON-ручка получает его на вход и на операцию отдельно, а на хэш пароля, между шагами и на передачу ответа оно в пуле. [database] request_timeout_seconds — срок блока вместе с откатом при выходе; на JSON-ручках та же настройка ещё и общий срок запроса (request_deadline), иначе два шага дали бы до 12 с при timeout server 10 с, а очередь хэшей шла бы без срока. Поведение API, контракт, схема и настройки те же.

Схема слоёв и поток отправки сообщения (каждая связь сверена с импортами и вызовами кода; поиском по связям помогал граф кода graphify, он только подсказка: схема написана руками):

flowchart TD
    subgraph entry["Точки сборки"]
        deps["src/api/dependencies.py"]
        procs["src/worker, src/relay, src/cleaner (main.py)"]
    end
    subgraph api["API"]
        routers["src/api/routers/v1/*"]
    end
    subgraph core["Домен"]
        services["src/core/services/*"]
        ports["src/core/ports/*: AbstractUnitOfWork, Abstract*Repository"]
        clientrepos["src/core/repos: chat_cache, attachment_object"]
    end
    subgraph infra["Реализации"]
        uow["src/infra/db/uow.py: SqlAlchemyUnitOfWork"]
        scope["src/infra/db/scope.py: session_scope, deadline_scope"]
        sqlrepos["src/core/repos/*: SqlAlchemy*Repository"]
        clients["src/infra: Cache, ObjectStorage, JobPublisher, ImageRenderer"]
        password["src/infra/password.py"]
    end
    pg[("PostgreSQL")]
    routers --> deps
    deps --> services
    procs --> services
    deps --> uow
    procs --> uow
    deps --> scope
    services --> ports
    services --> clientrepos
    services -- "тип клиента, вызовы издателя и процесса обработки" --> clients
    services -- "хэш пароля" --> password
    clientrepos --> clients
    uow -. реализует .-> ports
    sqlrepos -. реализует .-> ports
    uow --> scope
    uow --> sqlrepos
    sqlrepos --> pg
sequenceDiagram
    participant R as message router
    participant D as request_deadline, get_current_session
    participant S as MessageService.send_message
    participant U as SqlAlchemyUnitOfWork
    participant P as PostgreSQL
    participant C as chat_cache
    D->>U: блок входа: sessions.get_current_session
    U->>P: проверка соединения, SELECT, ROLLBACK
    R->>S: chat_id, sender_id, text, idempotency_key
    S->>U: async with self.uow
    S->>C: require_member: карточка из кэша
    C-->>S: промах
    S->>U: chats.get_chat
    S->>U: attachments.get_attachments, если есть вложения
    S->>U: idempotency.claim_key
    S->>U: messages.insert_message, связи
    S->>U: commit
    U->>P: проверка соединения, BEGIN, выражения, COMMIT
    S-->>R: MessageFullDTO

Быстрые тесты сервисов — каталог service-tests/ вне образа и вне student-tests/: make service_test гоняет ветки всех сервисов на фейках без хранилищ и docker, make service_test_db на временной базе проверяет настоящую единицу работы, общий срок запроса и тот же набор условий repo, что и на фейке (service-tests/repo_contract.py). Блокировки и поведение под конкуренцией фейк не воспроизводит: это по-прежнему make failure_checks.

Цена шага — вторая выдача соединения на двухшаговой ручке, новых соединений нет. Её снижает проверка соединения при выдаче одним запросом ; вместо трёх (_ping_once, опирается на внутренние имена адаптера, смену имён ловит make service_test_db). Осталось то, что в таблицах ниже: цену приняли, готовые меры (чтение без транзакции, соединение Core вместо сессии) не применялись (design.md, решение 7).

Обмены с PostgreSQL на запрос (журнал log_statement = all, проба до кода, design.md, Context; на commit не переснимались: выражения те же):

Ручка До На шаг без меры С мерой (_ping_once)
GET /users/me 6 6 4
GET …/messages 7 12 8
POST …/messages 8 13 9

Потолок и CPU реплики до и после, закрытая модель, 1 реплика 1 CPU, один повтор на ячейку: caffeinate -isu uv run python bench/run.py --profile quick --label unit-of-work-before и unit-of-work-aa на b2fb88f (src как на 9efab79, временный git worktree), --label unit-of-work-after на 6ba74b1; make bench_compare BEFORE=unit-of-work-before AFTER=unit-of-work-after AA=unit-of-work-aa и make bench_compare BEFORE=unit-of-work-aa AFTER=unit-of-work-after AA=unit-of-work-before. Метки — evidence/bench/unit-of-work-*/, сравнения — evidence/compare/unit-of-work-before__unit-of-work-after.md и evidence/compare/unit-of-work-aa__unit-of-work-after.md. Метки сняты до правок verify (BoundedCloseConnection, таймер блока при общем сроке): на пути без отказа те правки убирают один таймер блока и не добавляют обменов; метки не переснимались. У всех трёх git.dirty false, host_warnings пусты, swapouts_delta 0; посторонние контейнеры на хосте — domains-api-1, domains-bot-1, domains-postgres-1 (названы в паспортах). Первая съёмка unit-of-work-before дала предупреждение о выгрузке 27708 страниц в swap и переснята (bench.md): порядок меток — aa, after, rollout, затем before, в той же сессии хоста; отброшенная метка в git не идёт.

Порядок съёмки: aa 20:19, after 20:23, затем rollout, before 20:32 UTC. Код aa и before один, поэтому обе метки — «до», и каждая служит уровнем шума для другой (bench_compare считает шум от своего «до»: одна пара меток даёт 14,8 и 17,4 %, 34,8 и 53,4 %).

Сценарий «До» Шум A/A, наибольшее Δ RPS Δ RPS по 9 ячейкам: медиана (мин…макс) Ячеек ниже «до» Вывод bench_compare p50 при 1 клиенте, мс (1k, 5k, 10k)
история aa, сразу перед after 17,4 % (5k × 1) −14,1 % (−21,1…−6,3) 9 из 9 эффект — 1k × 1 (−21,1 %) и 5k × 1 (−17,5 %), остальные в пределах шума 1,78 → 2,22; 1,79 → 2,16; 1,83 → 2,22
история before, после rollout 14,8 % (5k × 1) −6,6 % (−18,8…−3,2) 9 из 9 эффект — 1k × 1 (−16,2 %) и 1k × 16 (−18,8 %), остальные в пределах шума 1,86 → 2,22; 1,95 → 2,16; 1,85 → 2,22
отправка aa, сразу перед after 53,4 % (5k × 16) −12,6 % (−18,7…−2,1) 9 из 9 всё в пределах шума 2,01 → 2,40; 2,06 → 2,33; 2,06 → 2,41
отправка before, после rollout 34,8 % (5k × 16) −4,3 % (−23,5…+37,5) 7 из 9 в пределах шума, кроме 5k × 16: +37,5 % — выброс ячейки «до» 2,05 → 2,40; 2,07 → 2,33; 1,89 → 2,41

Шум отправки задан одним выбросом: 5k × 16 в before — 383 RPS при 588 в aa. Без этой ячейки наибольшее расхождение A/A — 14,2 % (10k × 1, 433 и 495 RPS; считано не командой, а по evidence/bench/unit-of-work-{aa,before}/runs.csv), и −23,5 % той же ячейки от before выходит за него; от aa она даёт −12,6 %.

CPU реплики на запрос от aa: выше в 18 ячейках из 18, история +116…+266 мкс, отправка +26…+332 мкс. От before: выше в 15 из 18, исключения — 5k × 1 истории (−99), 5k × 1 и 5k × 16 отправки (−3 и −681, та же ячейка-выброс). p95 и все ячейки — в evidence/compare/.

Что показывают данные. Соединение на шаг снижает потолок реплики на этой закрытой модели: от метки того же кода, снятой прямо перед after, ниже все 18 ячеек, медианы −14,1 % на истории и −12,6 % на отправке, и в тех же 18 ячейках выше CPU реплики на запрос. От метки, снятой позже, медианы −6,6 и −4,3 %, ниже 16 ячеек из 18.

Чего данные не показывают. Точной величины: на ячейку один повтор, две метки одного кода расходятся до 14–17 % даже без выброса, а по правилу bench_compare эффектом названы только 2 ячейки истории из 9 в каждом сравнении. Ячейки одной метки сняты подряд и независимыми не считаются: 18 из 18 говорит об устойчивости знака, а не о размере. before ниже aa в 13 ячейках из 18 при том же коде; если хост за эти 13 минут замедлялся, ближнее сравнение цену завышает, а дальнее занижает, и данные этого не различают. Поэтому цена — снижение потолка примерно от 4–7 до 13–14 % по медианам, а не одно число.

С оценкой design.md (потолок −1…−22 %, p50 при 150/с +0,2…0,5 мс) цена не расходится: от aa все 18 ячеек внутри (−2,1…−21,1 %), от before вне её три ячейки: +0,4 %, +37,5 % и −23,5 %. p50 здесь при 1 клиенте закрытой модели, а не при 150/с, прирост +0,21…+0,52 мс.

CPU на успешный запрос при постоянных 200 запросах в секунду (100 записей, 100 чтений; две реплики разных версий в одном прогоне): bench/run.py --profile rollout --from b2fb88f --label unit-of-work-previous на 6ba74b1, evidence/rollout/unit-of-work-previous/summary.md, git.dirty false, host_warnings пусты:

Компонент До замены, мкс После замены, мкс
API всего 3066 3398
PostgreSQL 478 560

Уровень шума — два прогона замены на один и тот же новый код: evidence/rollout/unit-of-work/summary.md даёт после замены API 3113 мкс и PostgreSQL 524 мкс, этот прогон — 3398 и 560. Расхождение одного кода (отношение чисел двух summary.md, считано вручную): API 285 мкс, 9,2 %; PostgreSQL 36 мкс, 6,9 %. Рост в прогоне выше: API на 332 мкс, 10,8 %, — того же порядка, поэтому отличить его от шума нельзя; PostgreSQL на 82 мкс, 17,2 %, — вдвое больше расхождения, но пара прогонов одна, и этого мало для вывода. Значения «до» двух прогонов для шума не годятся: там разный прежний код.

Замена с b2fb88f на 6ba74b1: 10,2 с, ошибок 0 / 0 / 0, 12001 сообщение = 12001 ключ. Удержание соединения на запрос по пробе design.md (Context) ниже на 20–36 %; на commit отдельно не измерялось.

Транзакционные границы. Ключ эффекта — первичный ключ attachment_variants (attachment_id, pipeline_version, variant), логическая работа — UNIQUE (attachment_id, pipeline_version) в attachment_jobs. Вызовов S3 и брокера внутри блоков единицы работы нет, кроме двух осознанных исключений с коротким сроком: публикация relay (2 с < срока блока 6 с < простоя транзакции 10 с: блокировка строки и есть признак «публикует другой relay») и DELETE уборщика под блокировкой строки. Намеренные особенности перенесены без изменения порядка: уборка зависшей загрузки — два блока (пометка, затем объект и строка), вход закрывает блок чтения до KDF, занятый ключ идемпотентности снимает блокировку фиксацией до ответа, а компенсация загрузки различает сбой выражения и сбой на самой фиксации флагом перед явным commit(): автокоммит при выходе этого бы не дал (design.md, решение 10).

Варианты и лимиты обработки

Вариант Формат Размер Параметры Метаданные
thumbnail JPEG вписан в 256 × 256, вниз, без увеличения quality=85 EXIF и ICC не пишутся
crop JPEG 128 × 128, центр, маленькие растягиваются quality=85, альфа на белый то же
optimized WebP вписан в 1280 × 1280, без увеличения quality=80, method=4 (method=6 на пробе в 3,5 раза дольше без выигрыша) EXIF, XMP, ICC нет; ориентация применена; прозрачность сохранена

Все три — из одного декодирования, результат детерминирован (design, таблица «Пробы»). Pillow нет ни в репликах, ни в процессе 1 worker (evidence/worker/process.md).

Лимит Механизм Значение Превышение
байты размер объекта против строки до чтения тела; CHECK контракта 10 MiB source_corrupted, processing_failed, постоянная
пиксели width × height до декодирования 40 млн limit_pixels, invalid_image, постоянная
память RLIMIT_AS процесса обработки 450 МиБ limit_memory, invalid_image, постоянная
CPU RLIMIT_CPU, RLIMIT_CORE = 0 15 с limit_cpu, invalid_image, постоянная
время родитель убивает процесс 40 с, меньше срока попытки 60 с timeout, временная

Настоящий случай «дорогого» файла — прогрессивный JPEG в пределах контракта, один скан повторён 445 227 раз: test_limit_cpu_scan_bomb.

Бюджет памяти контейнера worker (1 ГБ). Замер двух файлов разом, команда driver.py --port 8080 worker-memory, два прогона на 9639aa1 (evidence/worker/memory.md): пик процесса обработки на 40 Мпкс (render_peak_kib, лимит 450 МиБ) зависит от типа файла: PNG RGBA и всё, что переводится в RGBA (серый с альфой, RGB с tRNS, палитра с tRNS), — 357 МиБ, серый 16 бит — 404 МиБ, а на обеих границах контракта сразу, 40 Мпкс и ~10 MiB файла, — 367 и 414 МиБ. VmHWM процесса 1 при двух телах ~10 MiB — до 159 МиБ. Самый дорогой случай, два серых 16 бит на обеих границах: memory.peak контейнера 926 и 705 МиБ в двух прогонах (пик зависит от совпадения пиков двух процессов), oom_kill 0; у двух PNG 10 MiB из шума — 262 МиБ. Опора — верхняя оценка суммой пиков: 159 + 2 × 414 = 987 МиБ < 1 ГБ. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка.

Сервисы стенда и лимиты

Сервис Роль CPU Память Порт на хосте
haproxy LB, единственная публичная точка 1 256 МБ 127.0.0.1:8080
api × 2 приём, без состояния 1 на реплику 512 МБ на реплику нет
relay публикация намерений, истёкшие аренды, python -m src.relay, без healthcheck 0,25 256 МБ нет
worker обработка, python -m src.worker, без healthcheck 1 1 ГБ нет
cleaner незавершённые загрузки, очистка staging, сверка 0,25 256 МБ нет
postgres источник истины, volume 2 1 ГБ loopback 5433
valkey кэш, без persistence 0,5 128 МБ loopback 6380
s3 SeaweedFS, volume 1 512 МБ loopback 8334
rabbitmq брокер, volume, предел памяти 400 МиБ 1 512 МБ loopback 5673
migrate (разовый) миграции 0,5 256 МБ нет
s3-bootstrap (разовый) bucket, политики, пользователи 0,5 128 МБ нет

Сумма постоянных сервисов: 9,0 CPU, 4992 МБ при двух репликах; вместе с разовыми — 10,0 CPU, 5376 МБ.

Соединения PostgreSQL: API_REPLICAS × 10 + migrate 1 + cleaner 1 + worker 2 + relay 1. При двух репликах 25; во время поочерёдной замены (третья реплика) 35; max_connections 100. Переполнения пула нет (max_overflow 0).

Лимит worker 1 ГБ: расчёт — раздел «Варианты и лимиты обработки», проверяет test_max_pixels_fit_worker_memory. На метке baseline4 при конкуренции 2 memory.peak до 836 МиБ на самом дорогом классе; конкуренция 4 в этот лимит на нём не помещается (раздел «Очередь под перегрузкой»).

Предел принятой работы: [uploads] max_unfinished_jobs 250 незавершённых заданий на стенд, 0 — без предела. Обоснование по измеренному потолку — там же.

Соответствие переменных .env.example

Имена лаб 1–4 — без изменений, таблицы в отчёте лабы 4 («Соответствие переменных», «Соответствие имён skeleton S3_*»). Новые имена лабы 5:

Имя skeleton Где у нас Почему так
BROKER_URL_FILE [broker] мостами из RABBITMQ_* (BROKER__HOST, BROKER__PORT, BROKER__USER, BROKER__PASSWORD) значения, а не файл, как DATABASE_URL_FILE: пароль нужен и контейнеру брокера, строка URL с паролем не собирается
WORKER_CONCURRENCY [worker] concurrency (2) читает только worker
JOB_MAX_ATTEMPTS [worker] max_attempts (5) то же
JOB_TIMEOUT_SECONDS [worker] job_timeout_seconds (60) то же
STAGING_RETENTION_SECONDS [cleaner] staging_retention_seconds (86400) читает только уборщик; значение из .env.example skeleton

Новые настройки уровня 4 (значения по умолчанию, вывод записи о старте — evidence/worker/process.md, evidence/relay/process.md):

  • [worker]: prefetch 2, lease_margin_seconds 10, retry_base_delay_seconds 5, retry_max_delay_seconds 300, render_timeout_seconds 40, render_cpu_limit_seconds 15, render_memory_limit_mib 450, graceful_shutdown_seconds 8 (не больше 8);
  • [relay]: poll_interval_seconds 0,25, batch_size 100, max_published_backlog 1000 (0 — без предела), republish_after_seconds 300, failure_pause_seconds 2.

Секреты по сервисам: пароль брокера — только rabbitmq, relay, worker, у api настроек брокера нет; ключи S3_WORKER_* — только s3-bootstrap и worker; у worker нет пароля Valkey и ключей API и уборщика; у relay нет S3 и Valkey; в окружении процесса обработки секретов нет.

Критичные и некритичные зависимости /health/ready

Зависимость В готовности Причина и поведение при отказе
PostgreSQL да без него не работают сессии и данные: обязательный путь стоит, 503
Valkey нет кэш: отказ — обход, чтение из PostgreSQL
S3 нет нужен только путям байтов вложений: они отвечают 503, текст и история работают
Брокер нет брокера в пути запроса нет: загрузка отвечает 202, намерение ждёт в PostgreSQL
Relay нет без него задания ждут в PostgreSQL, приём не страдает
Worker нет к синхронному пути не относится

Отказ брокера. Загрузка — 202, а не 503 (на уровне 3 было 503): намерение уже в PostgreSQL, relay пишет «Broker is unavailable» и опубликует после возврата; 503 на загрузке теперь только от S3 и PostgreSQL. Проверки: test_upload_with_broker_stopped, test_upload_with_broker_paused. Отказ relay. Загрузка — 202, задание queued с пустой отметкой, следующий запуск публикует (test_relay_killed_before_publish). Отказ worker. API принимает, relay публикует; resize синхронно не делается: Pillow в процессе API не загружен (_imaging нет в /proc/1/maps, evidence/worker/process.md).

Разрыв COMMIT и publish и окна отказа

Разрыв закрыт transactional outbox на тех же строках: намерение и queued — одна транзакция, публикует отдельный relay по этим строкам, а не процесс запроса. Отдельной таблицы нет: это было бы второе состояние той же работы. LISTEN/NOTIFY отвергнут: опрос всё равно нужен для сроков, а пустая выборка стоит 0,05 мс.

Окно Что происходит Что видит клиент
после staging до записи задания pending и объект staging; их убирает уборщик 503 или обрыв
после COMMIT queued до ответа работа идёт: relay опубликует обрыв; вложение станет ready, клиент о нём не знает, как и в лабе 4
после COMMIT до publish (relay упал) намерение в БД, следующий проход публикует 202 уже получен
после publish до confirm исход неизвестен: новая публикация, возможен дубль опрос queued
после confirm до отметки published_at откат отметки, новая публикация, дубль — no-op опрос queued или processing
после записи S3 до COMMIT результата аренда истекает, новая попытка пишет те же ключи опрос processing, затем queued
после COMMIT результата до ack повторная доставка — no-op с ack опрос ready

Сбои внедрены снаружи, без точек сбоя в коде (триггер на filename прогона, docker kill): driver.py defense-faults на рабочем стенде → evidence/attachments/defense-faults.md, те же окна — test_defense_faults. Запись «Разрыв COMMIT и publish» из KNOWN_ISSUES.md удалена.

Смесь версий и порядок обновления (design, Migration Plan). Шага оператора нет: секретов не прибавилось. Без простоя: docker compose up -d s3-bootstrap, make rolling_update (две ревизии, затем реплики), docker compose up -d --no-deps worker cleaner, затем docker compose up -d --no-deps relay; до запуска relay загрузки отвечают 202 и ждут. Worker обновляется раньше relay: прежний worker делает только thumbnail. Откат: make rolling_update COMMIT=<прежний> MIGRATE=0 COMPOSE_FILE=docker-compose.yml:infra/rollback/broker.compose.yml (прежним репликам нужен пароль брокера, только на время отката), прежние worker и уборщик, relay останавливается, схема остаётся. Новых статусов и error_code нет, поэтому 500 на чтении, как при переходе 201 → 202, здесь нет; проба — evidence/migrations/pipeline-reliability.md.

Согласования с преподавателем

Дата Договорённость Где учтено
2026-09-26 Лабы можно делать на FastAPI, несмотря на расхождения с контрактом (лишний 422, другой порядок кодов ошибок). Публичный smoke при этом должен проходить .claude/rules/api-contract.md, раздел «FastAPI»
2026-09-29 Конфиг через pydantic-settings: окружение → .env → config.toml → дефолты. config.toml не в git и не в образе, монтируется read-only при запуске. Это подходит под «конфигурация приходит из окружения» (README лабы 1, п. 3) и п. 6 Dockerfile.example. Требование «только env» — упрощение курса, config.toml можно использовать .claude/rules/settings.md, .claude/rules/docker.md
2026-10-20 Лаба 4: «пустой текст» сообщения — это и "", и текст только из пробельных символов. Допустимы: вложение + непустой текст, без вложения + непустой текст, вложение + пустой текст. Значит, " " с хотя бы одним вложением — 201, без вложений — 400 спек messages (change attachments, сценарий «Пробелы с вложением»), design attachments, решение 8; .claude/rules/api-contract.md

Расхождения FastAPI, разрешённые согласованием: 422 переведён в 400; битый JSON — 400 раньше 401, остальная валидация — после зависимостей.

Открытые вопросы преподавателю

Контракт допускает несколько трактовок, ответа пока нет. Взята самая строгая, проходящая публичные тесты. Подход от ответа не зависит. Вопросы 1 и 2 перенесены из лабы 4, полный разбор — в её отчёте.

  1. Все места загрузки реплики заняты: 429 или 503? Сделано: 429 rate_limited с Retry-After: 1.
  2. Что отвечает API на вложение, чей оригинал по сверке потерян? Сделано: метаданные — 200, байты — 404, ссылка в новом сообщении — 201; до пометки сверкой байты — 500.
  3. Failed-вложение прикреплять нельзя (409), а повтор с тем же Idempotency-Key обязан вернуть тот же 201. Что отвечать на повтор сообщения, чьё вложение стало failed уже после отправки? Сделано: новое сообщение — 409, повтор с ключом — 201 с тем же Message. Другой ответ меняет одну ветку send_message и сценарий idempotency.
  4. contracts/attachment-states.md требует документированный retention и cleanup неуспешных исходников без указания уровня, а README.md относит очистку к уровню 4. Закрыт уровнем 4: [cleaner] staging_retention_seconds 86400 с, очистка у ready следующим проходом, у failed по сроку. На уровне 3 очистки не было.
  5. Допустим ли на уровне 3 ответ 503 при недоступном брокере? Закрыт уровнем 4: отказ брокера больше не даёт 503, на загрузке 503 только от S3 и PostgreSQL. На уровне 3 был 503: relay ещё не было.
  6. Контракт требует EXIF orientation и alpha на белый только у thumbnail. Как с crop и optimized? Сделано: ориентация применяется у обоих (иначе EXIF, удалённый из WebP, повернул бы изображение), crop компонуется на белый (JPEG), optimized сохраняет прозрачность. Другой ответ правит одну функцию и сценарий.
  7. Контракт называет replay «явным операторским», но не говорит, как его вызывать. Достаточно ли команды в контейнере? Сделано: make replay, HTTP-ручки нет: в API нет роли оператора. Другой ответ добавляет ручку поверх той же транзакции.
  8. Изображение, не уложившееся в лимиты времени или памяти обработки, — это invalid_image или отдельный код? Сделано: invalid_image, точная причина — в записи для оператора. Другой ответ добавляет значение enum и требует обновить реплики раньше worker.
  9. Контракт требует retention «неуспешных и непривязанных исходников», но молчит о конечных объектах, которые успела записать неудачная попытка. Сделано: по истечении срока удаляются и они, метаданные failed остаются. Другой ответ убирает один шаг очистки.
  10. Предел незавершённых заданий: 429 или 503? Контракт называет 429 «ограничением частоты запросов», здесь ограничено количество принятой работы; 503 — «зависимость недоступна». Сделано: 429 rate_limited с Retry-After: 5, как у занятых мест: зависимости живы, реплика готова. Другой ответ меняет строку DOMAIN_ERRORS и сценарии.
  11. Как долго загрузка обязана отвечать 202 при остановленном worker? Рубрика уровня 3 показывает «worker остановлен → upload 202», трек 1 требует ограничить принятую работу. Сделано: пока незавершённых меньше предела (250); дальше 429, а текст, история, метаданные, готовые байты и /health/ready работают. Другой ответ — значение настройки.
  12. Требуется ли на уровне лабы закрыть чтение секретов worker процессом обработки? Он идёт под тем же UID и может прочитать /proc/1/environ (раздел «Ограничения и следующие шаги»). Сделано: кодом не исправлено, в окружении самого процесса обработки секретов нет. Предложение — PR_SET_DUMPABLE=0 в процессе worker до запуска процессов обработки: одна строка на старте worker и сценарий.

Ответы на вопросы защиты

Чем publisher confirm отличается от consumer ack? Confirm — брокер сообщает издателю, что принял сообщение на себя: durable-очередь, persistent-сообщение, записано. Это граница между relay и брокером: только после неё relay ставит отметку published_at, неподтверждённое остаётся намерением и публикуется снова. Ack — потребитель сообщает брокеру, что сообщение можно удалить. Worker шлёт его только после фиксации исхода в PostgreSQL (ready, failed, queued со сроком следующей попытки) или решения «эффекта не нужно». Это разные участки пути: confirm ничего не говорит об обработке, ack — о доставке. Ни тот, ни другой больше не определяют ответ клиенту: 202 — это COMMIT в PostgreSQL.

Что именно уже сохранено в момент 202? Проверенный оригинал целиком в staging приватного S3, строка вложения и намерение обработки в PostgreSQL (queued, attempt 0, одна транзакция). Сообщения в очереди может ещё не быть: его опубликует relay, и брокер в этот момент может быть недоступен. Вариантов и объекта в конечном ключе ещё нет. Проверка — test_durable_state_at_202, переживание — test_api_killed_after_202, test_relay_killed_before_publish, test_broker_restart_keeps_job, test_broker_kill_keeps_confirmed.

Почему повторная доставка нормальна и где ключ идемпотентности job? Подтверждение и результат работы нельзя зафиксировать атомарно: процесс может умереть между COMMIT и ack, relay — между confirm и отметкой, и сообщение придёт снова. Это at least once, а не exactly once. Эффект идемпотентен: ключ — (attachment_id, pipeline_version, variant), первичный ключ attachment_variants, вставка ON CONFLICT DO NOTHING; ключи объектов одни и те же при каждом повторе, логическая работа — UNIQUE (attachment_id, pipeline_version). Сообщение — подсказка, истина в строке: доставка готовой работы подтверждается без записи (test_redelivery_of_ready_is_noop, test_crash_after_commit_before_ack: attempt 1, тот же updated_at), ready не откатывается, replay готового — отказ already_ready.

Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля? Только сроком: флаг redelivered этого не доказывает, брокер ставит его и после nack. Попытка жёстко ограничена: шаги прерывает asyncio.timeout(job_timeout_seconds), процесс обработки убивается, поэтому аренда job_timeout + lease_margin (70 с) обходится без пульса. Истёкшая аренда значит «мёртв или заморожен», такую попытку возвращает relay. Пока аренда жива, дубль подтверждается без эффекта и без траты номера (busy, test_duplicate_during_processing), долгая живая попытка не теряет работу (test_long_attempt_keeps_lease). Новая попытка получает новый номер, и фиксация условна: state = 'processing' AND attempt = :своя. Размороженный прежний процесс получает superseded и ничего не меняет, в том числе пока новая попытка ещё идёт: тогда решает только номер (test_hung_worker_lease_fencing). Цена — после KILL следующая попытка ждёт аренду, до 70 с (наблюдали 70 с, evidence/attachments/defense-faults.md). Пульс отвергнут: запись на задание каждые несколько секунд, зависимость от event loop и ложные срабатывания под перегрузкой.

Где работа перестаёт приниматься и ускоряться, и почему предел — 429? Приниматься — на местах загрузки реплики и на пределе незавершённых заданий: оба уровня отвечают 429 с Retry-After. Ускоряться — на CPU worker: при 1 CPU конкуренция сверх двух не поднимает потолок, а на lp ломает обработку; у файлов на границе байтов ещё на CPU S3, общем для приёма и обработки. За входом клиент видит только дольше неизменный queued. 429, а не 503: зависимости живы, реплика готова и остаётся в LB, а текст, история, метаданные и готовые байты работают. Трактовка — вопрос 10 преподавателю. Числа — раздел «Очередь под перегрузкой».

Сценарий защиты

Порядок автоматизирован: driver.py --port 8080 defense-scenario → evidence/attachments/defense.md, тот же порядок на стенде отказов — test_defense_scenario.

  1. make test: 202, опрос до ready, оригинал и настоящий JPEG thumbnail.
  2. docker compose stop worker, загрузка — 202, снимок queued; сообщение с вложением — 201; скачивание — 409; текстовое сообщение — 201; в очереди ≥ 1 сообщение, потребителей 0.
  3. scripts/restart.sh — рестарт LB, реплик, PostgreSQL, Valkey, S3 и брокера с сохранением volumes; сообщение в очереди, прежний токен читает queued. docker compose start worker — та же запись ready; оригинал с тем же SHA-256, thumbnail 256 × 160, crop 128 × 128, optimized WebP 320 × 200. В файле — ID и StartedAt до и после, без токенов. Relay не трогается.
  4. driver.py --port 8080 defense-faults → evidence/attachments/defense-faults.md: шесть окон на рабочем стенде (таблица ниже). Триггеры — только на уникальный filename прогона, после прогона их нет, worker и relay запущены при любом исходе.
Окно Действие Начато попыток Итог
после записи объектов до COMMIT kill worker, ожидание аренды 2 ready через 70 с, те же SHA-256 в S3 и метаданных
после COMMIT до ack заморозка и kill worker, сообщение вернулось 1 ready, no-op, тот же updated_at, очередь пуста
после COMMIT queued до publish kill relay, загрузка 202, 0 сообщений, запуск 1 ready без ручного задания
после confirm до отметки kill relay, сообщение есть, отметки нет, запуск — 2 сообщения 1 ready, дубль без эффекта
replay failed staging подменён, failed source_corrupted, реестр без изменений, объект возвращён, --apply 2 ready, то же задание, attempt_base 1, запись аудита
replay готового --apply на ready 1 код 3, already_ready, ничего не изменилось
  1. Для 5 — выбранный эксперимент, трек 1: make bench_queue_quick (~11 мин, рабочий стенд — make stop) на глазах или заранее и разбор evidence/queue/baseline4/summary.md: таблица настроек, плато предела, второй worker, рестарты.

Доказательства критериев

В шапке каждого файла — команда, дата, commit и стенд. На 9639aa1 (код src/ и bench/ тот же, что на 5ee3257, изменён только драйвер скилла: новые команды worker-memory, freeze-sessions, freeze-lb) сняты evidence/tests/student-test-lb.md, evidence/tests/test-isolated.md, evidence/cache/hits.md, evidence/auth/passwords-and-tokens.md, evidence/idempotency/replay-after-restart.md, evidence/worker/memory.md, evidence/storage/freeze-sessions.md. На b104690 (коммит файла 4a7d89d, шесть проверок предела заданий) снят evidence/tests/failure-checks.md. На d8fe2e8 (правки verify: сессии после заморозки, один срок на JSON-запрос, тест одновременных доставок) снят evidence/tests/service-tests.md. На 6ba74b1 (единица работы, поведение то же) сняты метки evidence/bench/unit-of-work-after/ и evidence/rollout/unit-of-work*/, а ещё evidence/replicas/test-persistence.md, evidence/failover/test-failover.md, evidence/attachments/defense-faults.md, evidence/s3/privacy.md, evidence/worker/process.md, evidence/relay/process.md. На 399da05 снята таблица «Красные прогоны» в failure-checks.md. Остальные файлы уровня 4 сняты на e2a6427: из кода приложения 399da05 меняет только src/utils/image_variants.py, одну ветку перевода в RGBA, а 6ba74b1 поведения не меняет. d8fe2e8 меняет только путь отказа: метки и файлы на 6ba74b1 не переснимались, потому что на пути без отказа правка убирает один таймер блока и обменов с PostgreSQL не добавляет, а make failure_checks на новом commit те же отказы прошёл. Остались снятыми на прежнем коде ff1a83b и названы так в шапках: метка evidence/uploads/baseline/, evidence/rollout/async-attachments/, evidence/migrations/async-attachments.md, evidence/s3/worker-key.md: это доказательства перехода уровня 3, их поведение уровень 4 не менял.

Уровень 3

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab5 public API scenario evidence/tests/test-isolated.md
Минимум лаб 1–4 сохранён с переходом 201 → 202 make student_test через LB 224 passed, реплики выполнены; сверка: 389 сценариев, 358 проверены, 31 исключение evidence/tests/student-test-lb.md
Тот же набор на временной базе make test_isolated smoke PASS; 218 passed, 6 skipped (реплики); уборка полная evidence/tests/test-isolated.md
Отказы make failure_checks (b104690) 147 passed, pytest 2214 с, crash markers 0 evidence/tests/failure-checks.md
Ветки сервисов и настоящая единица работы make service_test, make service_test_db (d8fe2e8) 201 passed за 1,44 с без хранилищ; 75 passed за 32,47 с на временной базе; 16 регрессий дают названный красный. С тестами предела заданий сейчас 215 и 78 passed (прогон перед коммитом этой правки, файл доказательства не переснимался) evidence/tests/service-tests.md
Заморозка PostgreSQL: сессий сверх пула нет, одна запись об отказе driver.py --port 8080 freeze-sessions (TCP-прокси пробы, сервер не трогается), driver.py freeze-lb (docker pause на своём временном проекте, рабочий mtusi-lab5 — код 2); то же в тестах test_no_sessions_over_pool_after_freeze, test_deadline_in_second_block_single_record 503 за 4,00–4,03 с при сроке 2 с, записей пула нет, сессий через прокси 0 во всех раундах; через LB 503 за 8,01–8,09 с, 504 нет, сессий до и после каждой заморозки поровну evidence/storage/freeze-sessions.md
202 только после устойчивого приёма и сохранения задания test_durable_state_at_202, test_upload_with_broker_stopped, test_upload_with_broker_paused к 202 объект в staging, строка и намерение в одной транзакции; брокер остановлен или заморожен — по-прежнему 202, намерение ждёт (на уровне 3 было 503) evidence/tests/failure-checks.md
Остановка API после ответа не теряет работу test_api_killed_after_202 реплика убита после 202, вложение становится ready evidence/tests/failure-checks.md
Отдельные broker и worker в общем compose driver.py broker-check, driver.py worker-process образ с тегом и digest, volume, AMQP только на loopback; PID 1 python -m src.worker, лимиты 1 CPU / 1 ГБ evidence/broker/stand.md, evidence/worker/process.md
Сообщения durable broker-check, test_queue_durable очередь durable, сообщение persistent evidence/broker/stand.md, evidence/tests/failure-checks.md
Доставка at least once, ack после устойчивого эффекта test_worker_killed_during_processing, test_redelivery_of_ready_is_noop worker убит посреди обработки — задание доводится; регрессия «ack до фиксации» делает тест красным (design, «Уточнения apply», п. 12) evidence/tests/failure-checks.md
Недоступность worker не вызывает синхронный resize test_worker_down_api_serves, worker-process API принимает и отвечает, _imaging нет в процессах реплик evidence/tests/failure-checks.md, evidence/worker/process.md
Состояния в API test_attachment_becomes_ready, test_queued_while_worker_stopped, test_processing_visible, test_undecodable_becomes_failed queued, processing, ready, failed видны в метаданных evidence/tests/student-test-lb.md, evidence/tests/failure-checks.md
Оригинал неизменен test_original_published_unchanged, driver.py attachment-storage те же байты и SHA-256; байты только в приватном bucket evidence/tests/failure-checks.md, evidence/attachments/storage.md
Thumbnail по контракту test_thumbnail_*, test_download_thumbnail 256 × 160 у fixture, округление вниз, минимум 1 px, EXIF, alpha на белый, настоящий JPEG, размеры и SHA-256 сходятся с метаданными evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Ограниченный retry [worker] max_attempts = 5, test_transient_error_retried, test_attempts_exhausted временная ошибка повторяется под тем же job_id, исчерпание — failed с retry_exhausted evidence/worker/process.md, evidence/tests/failure-checks.md
Финальное failed с безопасным error_code test_undecodable_becomes_failed, test_staging_corrupted, журнал invalid_image, processing_failed; причина для оператора — в задании и журнале evidence/worker/logs.md, evidence/tests/failure-checks.md
Повтор не создаёт второго набора вариантов test_ready_failure_retried, test_redelivery_of_ready_is_noop; проба ограничения второй вариант с тем же именем — 23505 pk_attachment_variants evidence/attachments/storage.md, evidence/migrations/async-attachments.md
В сообщении нет bytes и credentials test_job_message_matches_schema сообщение проходит contracts/jobs.schema.json, только ID и служебные поля evidence/tests/failure-checks.md
Демонстрация: worker остановлен → … → ready driver.py --port 8080 defense-scenario все строки expected = got, StartedAt API и брокера новые, у relay прежний; thumbnail 256 × 160, crop 128 × 128, optimized 320 × 200 evidence/attachments/defense.md
Принятое задание переживает рестарт брокера с volume test_broker_restart_keeps_job, test_broker_kill_keeps_confirmed, test_broker_recreated сообщения на месте после stop, KILL и up --force-recreate evidence/tests/failure-checks.md
Очереди разных баз разделены make test_isolated KEEP_TEST_DB=1, broker-check --require-test-queue, make test_isolated очередь временной базы есть после первого и нет после второго evidence/broker/isolated.md
Сохранность и hook make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS; api, haproxy, postgres, rabbitmq, s3, valkey — те же контейнеры и новый StartedAt, relay, worker и cleaner прежние evidence/replicas/test-persistence.md
Отказ реплики make test-failover stop и kill failed_attempts 0, восстановление 1,72 и 0,85 с evidence/failover/test-failover.md
Принявшая реплика остановлена driver.py attachment-failover --mode stop|kill файл отдаёт другая реплика, SHA-256 тот же, постороннему 404 evidence/attachments/failover.md
Согласованность БД и S3 driver.py upload-consistency 503, строки pending не видны, уборщик убрал по ключу staging, объектов без строки 0 evidence/attachments/consistency.md
Приватность S3, права worker make s3_check PASS: 90 checks; worker: запись и чтение — да, удаление, список, админ — 403 evidence/s3/cleaner-staging.md (и evidence/s3/worker-key.md, ff1a83b)
Журнал worker проба на стенде общий request_id записей задания, filename 0 раз, сообщение не по схеме — error без содержимого evidence/worker/logs.md
Миграция только расширяет, откат без отката схемы проба на временной базе, make rolling_update COMMIT=cc33a03 MIGRATE=0 и возврат (ff1a83b) CHECK NOT VALID, по lock_timeout — без изменений; прежний образ работает, чтение нового статуса — 500 evidence/migrations/async-attachments.md
Сроки LB пути загрузки driver.py lb-upload-timeouts 202 после 12 с молчания, 504 через 10 и 30 с, 400 в формате контракта evidence/uploads/lb-timeouts.md
Замена реплик под нагрузкой make bench_rollout ROLLOUT_LABEL=async-attachments (ff1a83b), ROLLOUT_LABEL=pipeline-reliability (e2a6427), ROLLOUT_LABEL=unit-of-work (6ba74b1) 8,52, 8,67 и 8,68 с, ошибок 0, новые миграции, записей столько же, сколько ключей (12000 и 12001) evidence/rollout/async-attachments/summary.md, evidence/rollout/pipeline-reliability/summary.md, evidence/rollout/unit-of-work/summary.md
Память реплики при загрузках make bench_uploads (ff1a83b) «с лимитом» 10 MiB: пик 172,9 / 180,1 / 185,6 MiB при 10 / 20 / 40 клиентах, OOM 0, 5xx 0 evidence/uploads/baseline/summary.md
Секретов в доказательствах нет поиск значений из .env по evidence/ 17 значений, 0 совпадений evidence/tests/secrets.md

Исключения сверки покрытия подтверждены файлами этой лабы: evidence/cache/hits.md, evidence/auth/passwords-and-tokens.md, evidence/idempotency/replay-after-restart.md сняты на 9639aa1, test_exclusion_evidence_exists зелёный.

Уровень 4

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Crop 128 × 128 по контракту test_crop_center, test_crop_small, test_crop_orientation_alpha, test_download_crop_optimized центр, маленькие растягиваются, ориентация, alpha на белый, JPEG; размеры и SHA-256 по байтам evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Optimized WebP, параметры качества и удаление метаданных описаны test_optimized_fit, test_optimized_small, test_optimized_no_metadata, test_optimized_alpha; раздел «Варианты и лимиты обработки» вписан в 1280, без увеличения; quality=80, method=4; EXIF, XMP, ICC нет; прозрачность цела evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Лимит по bytes test_limit_oversized_staging объект больше строки не читается: processing_failed evidence/tests/failure-checks.md
Лимит по пикселям test_limit_pixels invalid_image, причина limit_pixels evidence/tests/failure-checks.md
Лимит по времени test_limit_cpu_scan_bomb, test_limit_render_timeout настоящий дорогой JPEG прерван по CPU: invalid_image; срок процесса — временная ошибка evidence/tests/failure-checks.md
Лимит по памяти worker test_limit_memory, test_max_pixels_fit_worker_memory, test_pixel_limit_png_modes, test_render_killed, driver.py worker-process RLIMIT_AS — invalid_image; 40 Мпкс укладывается в любом типе PNG, включая серый с альфой и RGB с tRNS; убитый процесс обработки не роняет worker; лимиты 1 CPU / 1 ГБ; два файла на обеих границах — memory.peak 705–926 МиБ, сумма пиков 987 МиБ, OOM нет (driver.py worker-memory) evidence/tests/failure-checks.md, evidence/worker/process.md, evidence/worker/memory.md
Разрыв PostgreSQL и брокера закрыт outbox test_upload_with_broker_stopped, test_upload_with_broker_paused, test_relay_survives_broker_outage, test_relay_survives_database_outage, driver.py relay-process, broker-check 202 без брокера; у реплик нет настроек брокера; relay переживает отказы (тот же StartedAt, RestartCount 0) evidence/tests/failure-checks.md, evidence/relay/process.md, evidence/broker/stand.md
Crash между COMMIT и publish, задача доходит до ready без ручного задания driver.py defense-faults, окна «после COMMIT queued до publish» и «после подтверждения до отметки»; test_relay_killed_before_publish, test_relay_killed_after_confirm published_at пуст, 0 сообщений, после запуска relay — ready, attempt 1; при KILL после confirm — 2 сообщения, ready, attempt 1, очередь пуста evidence/attachments/defense-faults.md, evidence/tests/failure-checks.md
Состояние намерений видно оператору driver.py pipeline-state, в том числе при замороженном брокере задания по состояниям, due, аренды; брокер заморожен — available: false, код 0 evidence/relay/pipeline-state.md
Backoff с jitter test_retry_backoff_with_jitter, test_retry_waits_outside_worker, test_relay_respects_next_attempt пауза растёт случайно в [d/2, d], не занимает место конкуренции, попытка не раньше срока; регрессия «фиксированная пауза» — красный evidence/tests/failure-checks.md
Различие постоянных и временных ошибок test_undecodable_becomes_failed, test_staging_corrupted, test_transient_error_retried, test_attempts_exhausted постоянная — failed сразу (attempt 1); временная повторяется, затем retry_exhausted evidence/tests/failure-checks.md, evidence/worker/logs.md
Реестр failed make replay, test_replay_registry_dry_run, test_replay_by_code показ без изменений; выбор по коду и причине; реестр — строки PostgreSQL, отдельной DLQ нет evidence/relay/logs.md, evidence/attachments/defense-faults.md
Безопасный явный replay, не дубль успешной job driver.py defense-faults, окна replay; test_replay_returns_work, test_replay_ready_refused, test_replay_in_progress_refused, test_replay_without_source_refused, test_replay_new_budget --apply с выбором, то же задание, attempt 2, attempt_base 1, запись аудита; ready — код 3 already_ready, ничего не изменилось evidence/attachments/defense-faults.md, evidence/relay/logs.md
Остановка worker после записи объекта до ack, повтор завершает тот же результат driver.py defense-faults, окна «после записи объектов до COMMIT» и «после COMMIT до ack»; test_crash_after_objects_before_commit, test_crash_after_commit_before_ack те же SHA-256 трёх объектов в S3 и метаданных, attempt 2; после COMMIT — no-op, тот же updated_at evidence/attachments/defense-faults.md, evidence/tests/failure-checks.md
Timeout и lease зависшего processing test_hung_worker_lease_fencing, test_hung_worker_thawed_after_ready, test_long_attempt_keeps_lease, test_duplicate_during_processing, test_last_attempt_lost, test_worker_killed_during_processing истёкшую аренду возвращает relay; прежняя попытка после разморозки — superseded; живая не теряется, дубль без эффекта evidence/tests/failure-checks.md
Ограниченная конкуренция и prefetch test_concurrency_bounded, test_prefetch_bounded, test_published_backlog_limit, test_broker_memory_alarm prefetch 2 + конкуренция 2, сообщения сверх них у брокера; предел опубликованных 1000 evidence/tests/failure-checks.md, evidence/worker/process.md
Очистка staging после безопасной фиксации test_staging_removed_after_ready, test_staging_retention, test_staging_keeps_current_work, test_staging_cleanup_survives_outage, test_staging_foreign_key_kept, test_reconcile_orphan_staging, driver.py upload-consistency, make s3_check у ready убран следующим проходом (removed_ready), у failed по сроку; текущая работа цела; отказ S3 не держит сообщения; список уборщика только по двум префиксам evidence/tests/failure-checks.md, evidence/attachments/consistency.md, evidence/s3/cleaner-staging.md
Шаг 4 сценария защиты driver.py --port 8080 defense-faults шесть окон, все строки expected = got, триггеров не осталось evidence/attachments/defense-faults.md
Тесты ловят нарушение десять временных регрессий задачи 10.9 каждая даёт названный красный, откачена, хэши src совпали evidence/tests/failure-checks.md, раздел «Красные прогоны»
Журнал relay и worker, без filename и секретов проба на стенде общий request_id, причина и оператор replay, метка filename 0 раз evidence/worker/logs.md, evidence/relay/logs.md
Миграции расширяют, откат работает проба на временной базе, откат на 7f38948 и возврат CHECK NOT VALID, индексы indisvalid, планы по индексам решения 10, по lock_timeout без изменений; прежний образ работает; вложение прежнего образа — один thumbnail, crop 404, сверка без находок evidence/migrations/pipeline-reliability.md
Сроки LB после отказа от публикации driver.py lb-upload-timeouts 202 после 12 с молчания, 504 через 10 и 30 с, 400 в формате контракта; цепочка 26 с и 73 с evidence/uploads/lb-timeouts.md
Очереди разных баз разделены make test_isolated KEEP_TEST_DB=1, broker-check --require-test-queue, make test_isolated очередь временной базы есть после первого и нет после второго evidence/broker/isolated.md
Замена реплик с двумя ревизиями под нагрузкой make bench_rollout ROLLOUT_LABEL=pipeline-reliability 8,67 с, ошибок 0, a1d4c7e90b23 → d3f9a6b2c1e7, записей 12000 = ключей 12000, dirty false evidence/rollout/pipeline-reliability/summary.md

Трек 1 уровня 5

Change track1-queue-overload, код d68a016, метка baseline4 — b104690. Гипотезы, таблицы и выводы — раздел «Очередь под перегрузкой».

Критерий Команда Результат Файл
≥3 настройки на разных размерах make bench_queue QUEUE_LABEL=baseline4 4 настройки × 4 класса (12 конфигураций) × 3 повтора evidence/queue/baseline4/summary.md
Throughput, очередь, queue lag, p95 до ready, RSS там же таблица «Настройки и классы» evidence/queue/baseline4/cells.csv, timeline.csv
Backpressure и ограничение принятой работы там же, make failure_checks FAULT_ARGS='-k backlog' плато 250 против 423; 429 от мест, затем от предела; 6 проверок отказов test_backlog_* (-k backlog выбирает ещё test_published_backlog_limit — предел опубликованных у relay) evidence/queue/baseline4/summary.md, evidence/tests/failure-checks.md
Восстановление там же ноль незавершённых без оператора в 57 ячейках, потерянных и зависших 0, failed 0 в этой метке; в baseline и baseline3 на lp (4, 4) — 2 и 4 задания в failed, возврат — make replay evidence/queue/baseline4/cells.csv
Компромисс latency и ресурсов там же раздел «Очередь под перегрузкой» REPORT.md

Эксперименты и отказы

Поочерёдная замена на версию с брокером: метка async-attachments

Гипотеза: миграция и замена реплик с 04f8592 на ff1a83b идут без ошибок клиента, потому что схема только расширяется, а публикация ленива и не нужна чтениям и записи сообщений.

Методика — make bench_rollout: git.dirty false, swapouts_delta 0, посторонних контейнеров нет. Две реплики API 1 CPU / 512 МБ, PostgreSQL 2 CPU / 1 ГБ, Valkey 0,5 CPU / 128 МБ, HAProxy 1 CPU / 256 МБ, k6: 100 записей с ключом и 100 чтений в секунду, один прогон. В профиле только сообщения и история: загрузки не участвуют, поэтому смесь 201 и 202 он не показывает.

Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
8,52 с 1 / 1 с 5c3e1f0a9b7d → a1d4c7e90b23 0 / 0 / 0 200 / мин. 200 4 / 8 мс 12000 сообщений = 12000 ключей, повторов 0

CPU API всего: 0,54 ядра до и 0,55 после, 0,78 во время. Гипотеза подтверждена. Сырые данные — evidence/rollout/async-attachments/.

Поочерёдная замена на версию с relay: метка pipeline-reliability

Гипотеза: две ревизии (атомарная и индексы CONCURRENTLY) и замена реплик с 7f38948 на e2a6427 идут без ошибок клиента: схема только расширяется, а новым репликам брокер не нужен. Методика та же: git.dirty false, swapouts_delta 0, посторонних контейнеров нет, питание от сети. Загрузки в профиле не участвуют.

Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
8,67 с 1 / 2 с a1d4c7e90b23 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 5 / 72 мс 12000 сообщений = 12000 ключей, повторов 0

CPU API всего: 0,61 ядра до, 0,95 во время, 0,62 после. Гипотеза подтверждена. Сырые данные — evidence/rollout/pipeline-reliability/.

Поочерёдная замена на единицу работы: метки unit-of-work и unit-of-work-previous

Гипотеза: API, схема и настройки те же, поэтому замена на 6ba74b1 идёт без ошибок клиента и с версии до pipeline-reliability, и с предыдущего commit. Методика та же: git.dirty false, swapouts_delta 0, host_warnings пусты, питание от сети; посторонние контейнеры на хосте — domains-api-1, domains-bot-1, domains-postgres-1 (названы в паспортах).

Метка, откуда Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
unit-of-work, 7f38948 (make bench_rollout ROLLOUT_LABEL=unit-of-work) 8,68 с 0 / 2 с a1d4c7e90b23 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 6 / 161 мс 12001 сообщение = 12001 ключ
unit-of-work-previous, b2fb88f (bench/run.py --profile rollout --from b2fb88f) 10,2 с 1 / 3 с d3f9a6b2c1e7 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 7 / 180 мс 12001 сообщение = 12001 ключ

CPU API на запрос до и после замены у unit-of-work: 3089 и 3113 мкс, PostgreSQL 493 и 524 мкс; у unit-of-work-previous — раздел «Единица работы» выше. Гипотеза подтверждена. Сырые данные — evidence/rollout/unit-of-work/, evidence/rollout/unit-of-work-previous/.

Память реплики при загрузках: метка baseline

Снята на ff1a83b, потому что на неё ссылаются исключения сверки лабы 4; с этой меткой новые не сравниваются (с уровня 4 профиль не запускает брокер). Методика — make bench_uploads: одна реплика 1 CPU / 512 МБ без swap, 72 прогона, 50 мин, медиана из 3 повторов; worker не запущен, задания ждут в очереди. Поправки к чтению — evidence/uploads/README.md.

Вариант, 10 MiB C = 10: пик, MiB C = 20 C = 40 OOM при 40 Загрузок/с при 10 p95 при 10, мс
с лимитом 172,9 180,1 185,6 0/3 10,50 1253
без лимита 227,6 331,0 OOM 3/3 9,00 1480

H1 (пик ограничен местами) и H4 (нет 503 по сроку S3) выполнены. H2 в сводке — «нет»: вариант «до» теперь 04f8592, где места уже есть, поэтому прежнее поведение он не показывает; настоящее «до» — отчёт лабы 4. H3 в сводке — «нет»: на 1 MiB «с лимитом» даёт 85–89 % «без лимита» при пороге 90 %, на 10 MiB — 117–121 %. Память приёма после перехода на брокер в границах прежних сценариев спека: ~185 MiB из 512 при 40 клиентах.

Очередь под перегрузкой

Трек 1 уровня 5, change track1-queue-overload. Основная метка — baseline4: код commit d68a016, метка commit b104690 (dirty false, 57 ячеек из 57, 2 ч 00 мин, swapouts_delta 0, сна нет, предупреждений о хосте нет, посторонних контейнеров нет). src/ и bench/ на коммитах меток baseline2–baseline4 те же, что на 5ee3257; после них bench/run.py получил только поле паспорта с образами S3 и брокера. Паспорт baseline4 его не содержит, поле появилось после метки; её образы (git show d68a016:docker-compose.yml): S3 chrislusf/seaweedfs:4.48@sha256:4e61d15fd35994cb1e43e1e553dff106794841fd9a99ade2fc8c8bfce4d7872d, брокер rabbitmq:4.3.7@sha256:bd88985187aa73cd598fa0d8b31d49b2f814a6d9e58f6d5a89bae588669d946a. Гипотезы и правило записаны и закоммичены раньше первой метки, пороги с тех пор не менялись. Числа порогов — из проб стадии propose (design, раздел «Пробы»); числа результатов ниже — из evidence/queue/baseline4/summary.md, cells.csv и timeline.csv, если не названа другая метка.

Четыре метки. Снято четыре, основная выбрана правилом, записанным заранее и не зависящим от вердиктов: меньше задетых выгрузкой ячеек, при равенстве — меньше swapouts_delta (QUESTIONS.md; openspec/changes/archive/2026-11-02-track1-queue-overload/tasks.md, 10.20б). Остальные каталоги остаются в репозитории как запись.

Метка Код Commit метки Выгрузка, страниц Ячеек с host_swap Статус
baseline d667fa3 7999002 0 0 снята до правок инструмента, запись
baseline2 5ee3257 9639aa1 309 432 5 запись
baseline3 1373e7d d68a016 26 046 1 (lp-c2p256-r1) запись
baseline4 d68a016 b104690 0 0 основная

Почему baseline переснята: проверка нашла ошибки инструмента, которые нельзя поправить задним числом. Что в ней неверно:

  • lb_down считал строку BACKEND репликой, и выход одной реплики не срабатывал: условие H7 «lb_down нет» метка не проверяла;
  • cpu_worker_per_job_s занижен на ~6–11 %: CPU до конца восстановления делился на все ready, включая окно after (медианы конфигураций матрицы baseline к baseline4, без lp-c4p4: 5,6–8,8 % при конкуренции до двух, 8,2–10,8 % при четырёх);
  • каждый перезапуск worker считался завершением ядром: причина в метке не проверялась;
  • queue lag есть только на ячейку, а не по окнам, в сводке его нет; CPU и троттлинг — не по всем окнам и ролям;
  • нет счётчика перезапусков relay, лишние строки в базе не искались.

Пороги H1–H9 и порог правила рекомендации не менялись.

Главное. В основной метке подтверждены H1, H2, H3, H5, H6, H7, H8, H9, H4 не подтверждена (1 ячейка из 33 ниже порога, разбор ниже). H2 разошлась между метками: в baseline3 она «нет», разбор ниже. Рекомендация правила — (2, 2) во всех четырёх метках, значения по умолчанию оставлены. Конкуренция сверх двух при 1 CPU не ускоряет, а на lp (4, 4) ломает обработку: ядро завершало процессы во всех 12 ячейках четырёх меток, в основной — oom_kill 68 и 5 завершений процесса 1, throughput разбора 0,36 вместо 0,96. Настоящее ускорение даёт второй worker.

Команда: make bench_queue QUEUE_LABEL=baseline4 (занятая метка — отказ, ~2 ч 10 мин, RESUME=1), самопроверка — make bench_queue_quick (~11 мин, метка в git не идёт).

Методика. Стенд mtusi-bench: LB, две реплики API 1 CPU / 512 МБ, PostgreSQL 2 CPU / 1 ГБ, Valkey, S3 1 CPU / 512 МБ, брокер 1 CPU / 512 МБ, relay 0,25 CPU / 256 МБ, worker 1 CPU / 1 ГБ, уборщик 0,25 CPU / 256 МБ — лимиты рабочего стенда, без swap; у worker — restart: unless-stopped, как на рабочем стенде. Каждая ячейка — свежий стенд на новых volume.

  • Настройки (конкуренция, prefetch): (1, 1), (2, 2) — значения по умолчанию, (4, 4), (2, 256).
  • Классы: s — JPEG 1600 × 1200, q85, ~0,5 MiB; m — PNG из шума ~3,5 Мпкс, ~10 MiB; lj — JPEG 8000 × 5000, q88, ~8,6 MiB; lp — PNG RGBA 8000 × 5000, значащие 4 бита на канал, ~10 MiB. Файлы детерминированы от зерна, размеры и SHA-256 — в паспорте.
  • Матрица: (2, 2) и (4, 4) на всех классах; (1, 1) на m и lp; (2, 256) на s и lp, по три повтора, круги с перестановкой от зерна; план — в паспорте до первой ячейки.
  • Интенсивность одна на класс для всех настроек, низкая / высокая, загрузок/с: s 1,5 / 8, m 1,5 / 6, lj 1,2 / 6, lp 0,5 / 2,5. Открытая модель (constant-arrival-rate), ответ не повторяется: 429 — отказ.
  • Окна: before 10 с низкой λ; over 20 с высокой (блоки предела и рестартов — 25 с, приёма — 45 с); recovery — до нуля незавершённых, не дольше 420 с; after 10 с низкой λ.
  • Контрольный поток всё время: запись 10/с, чтение истории 10/с, скачивание готовых 5/с.
  • Блоки: gate-on и gate-off — s, (2, 2), 20/с, предел по умолчанию и выключен; accept — m, (2, 2), 15/с, 45 с; w2-p2, w2-p256 — второй worker в конце over; kill-worker — KILL и запуск посреди over; restart-broker — compose restart посреди over.
  • Шум: разброс — min–max трёх повторов. Разница двух конфигураций считается эффектом, только если их разбросы не пересекаются и разница медиан больше наибольшего разброса пары; иначе «в пределах шума». Отдельной метки A/A нет: настройка по умолчанию повторяется в каждом круге.

Определения.

Что Как считается Откуда
Очередь, outbox queued, не опубликовано, срок наступил PostgreSQL
waiting queued, не опубликовано, срок не наступил: пауза следующей попытки PostgreSQL
published queued, брокер подтвердил, никто не взял PostgreSQL
broker_ready, broker_unacked сообщения в очереди брокера и выданные, не подтверждённые метрики брокера
processing взято, идёт аренда PostgreSQL
prefetched max(0, broker_unacked − processing): у worker, ждёт места конкуренции вычисляется
unfinished outbox + waiting + published + processing: то, что считает предел PostgreSQL
oldest_s возраст старейшего незавершённого PostgreSQL
Throughput вложений с updated_at статуса ready в окне over и в окне recovery, делённые на длину окна GET /attachments/{id}
Время до ready updated_at у ready минус момент ответа 202; p50, p95, p99 по окну прихода; before и after — повторы сводятся вместе GET /attachments/{id}, k6
Queue lag возраст старейшего незавершённого, пик по окну тика (peak_oldest_<окно>_s), и время задания от подтверждения брокером до взятия, p50 и p95 по окну прихода (queue_wait_<окно>_*_ms) PostgreSQL, журнал worker
Восстановление от последней загрузки окна over до нуля незавершённых k6, PostgreSQL
RSS VmHWM процесса 1 worker, render_peak_kib процесса обработки (p50, наибольший), memory.peak, наибольшая anon, oom_kill; у перезапущенного контейнера — наибольшее и сумма по жизням /proc, журнал, cgroup
Причина завершения worker worker_die_oom (oom и код 137), worker_die_command (kill), worker_die_other (остальное, worker_exit_codes) docker events

Гипотезы.

№ Гипотеза Подтверждено, если
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 мс
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/с; пик незавершённых ≤ 290; готовых/с в окне ≤ 1,5 при ≥ 2,4 в окне восстановления; контрольный поток: запись и чтение p95 ≤ 200 мс, скачивание ≤ 1 с, без 5xx

Вердикт считает bench/overload.py в сводке метки: «подтверждено», «нет», «нет данных».

Уточнения условий (пороги те же).

  • H3, доля второго worker. Порог говорит «среди заданий, завершённых после его запуска», а код считает только до нуля незавершённых. Окно after к опыту не относится: оно приходит после разбора бэклога, большого prefetch уже нечем держать, и новые задания брокер делит поровну при любом prefetch. Измерено: при prefetch 256 буквальная доля (second_share_all, все завершённые после запуска) — 6,7 / 6,9 / 6,1 %, то есть при буквальном прочтении порога ≤ 5 % H3 — «нет». Вердикт считает прежний second_share (только разбор): 0 заданий во всех повторах. В самом окне after (second_share_after) доля 0,50 / 0,50 / 0,47. Порог не менялся, уточнение названо здесь, а не спрятано.
  • H2 и правило рекомендации — по подтверждённому oom. В baseline любой перезапуск считался oom; с baseline2 это только завершение, подтверждённое событиями Docker, или счётчик cgroup. Условия не менялись, смысл стал тем, что в них написано; аварийный перезапуск не от ядра — пометка worker_crash, условие правила он не нарушает (QUESTIONS.md, вопрос 3). В baseline2–baseline4 таких завершений нет (worker_die_other 0).

Правило рекомендации. Кандидат — настройка без oom и failed ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а prefetch равен конкуренции. Настройка, снятая не на всех классах, не кандидат: по плану это (1, 1) и (2, 256), сводка их называет, порог 90 % прежний. Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором make bench_queue_quick. Компромисс latency и ресурсов — вывод из таблиц метки; проверяемая формула: concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса).

Вердикты основной метки (evidence/queue/baseline4/summary.md, раздел «Гипотезы»).

№ Вердикт На чём
H1 подтверждено (4, 4) / (2, 2) по throughput восстановления: s 2,46 / 3,08, m 2,75 / 2,85, lj 1,98 / 2,34, lp 0,36 / 0,96; (1, 1) / (2, 2): m 2,50 / 2,85, lp 0,93 / 0,96
H2 подтверждено duration_ms p50 (4, 4) / (2, 2): s 1504 / 619, m 1400 / 660, lj 1822 / 814, lp 4105 / 2029 мс; memory.peak (2, 2) не выше 836 МиБ; lp (4, 4) — 1024 МиБ во всех повторах; lj (4, 4) — до 305 МиБ. На lp условие неустойчиво, разбор ниже
H3 подтверждено пик очереди брокера при (2, 256) — 0, при (2, 2) на s — 96 из 100; второй worker взял 47–49 % заданий при prefetch 2 и 0 при 256; буквальное прочтение — «нет», см. уточнение выше
H4 нет m-c1p1-r1 0,780 при нижней границе 0,8; разбор ниже
H5 подтверждено пик 250 с пределом против 423 без него; p95 80,2 против 130,6 с; восстановление 80,5 против 137,5 с; все 429 — от предела, Retry-After 5; загрузка before p50 16 против 16 мс
H6 подтверждено lost, stuck, duplicate, sha_mismatch — 0 во всех ячейках, 2280 проверенных SHA-256, failed 0, unexpected_rows 0
H7 подтверждено вне accept наибольшие p95 за все окна: запись 38,5, чтение 16,6, скачивание 105,6 мс; 5xx контрольного потока нет; lb_down нет: lb_up_min 2 во всех 57 ячейках, в этой проверке подсчёт уже верный
H8 подтверждено kill-worker: заданий с повтором 2 во всех повторах, восстановление 58,5 с, завершение — команда; restart-broker: повторов 0, 5xx нет, восстановление 45,6 с, у relay перезапусков и завершений 0
H9 подтверждено первый busy на 2,9–3,1 с, первый backlog на 33,9–36,3 с; CPU S3 в первые 30 с 1,00; принято 302–310 за 45 с; пик 279–286; готовых/с 0,80–0,98 в окне и 2,92–3,07 после

Вердикты всех меток. Числа условий и причины — evidence/queue/<метка>/summary.md.

№ baseline baseline2 baseline3 baseline4 (основная)
H1 подтверждено подтверждено подтверждено подтверждено
H2 подтверждено подтверждено нет: lp, duration (4, 4) / (2, 2) = 0,965 подтверждено
H3 подтверждено подтверждено подтверждено подтверждено
H4 нет: 2 ячейки m-c1p1, 0,797 и 0,778 нет: 3 ячейки m-c1p1, 0,794, 0,762, 0,727 нет: 2 ячейки m-c1p1, 0,785 и 0,781 нет: 1 ячейка m-c1p1, 0,780
H5–H9 подтверждено подтверждено подтверждено подтверждено
Рекомендация (2, 2) (2, 2) (2, 2) (2, 2)

H2 разошлась между метками, и это видно по самой конфигурации. lp (4, 4) от прогона к прогону сильно плавает. Основная метка подтверждает H2, но устойчивым подтверждением на lp это считать нельзя: условие не выполнилось в одной метке из четырёх, а в самой baseline4 один повтор дал 2844 мс. На остальных классах отношение устойчиво: s 2,37–2,68, m 2,10–2,12, lj 2,17–2,29.

Метка Перезапуски, сумма failed Восст., с: медиана (min–max) Готовых/с разбора duration_ms p50 (4, 4), r1 / r2 / r3 p50 (2, 2), медиана Отношение
baseline 16 2 187,1 (83,1–249,1) 0,24 1831 / 4288 / 3902 2060 1,894
baseline2 5 0 102,0 (86,0–108,1) 0,43 4291 / 4212 / 3733 2089 2,016
baseline3 18 4 220,7 (163,7–332,5) 0,20 4381 / 1997 / 1984 2070 0,965
baseline4 5 0 95,0 (65,8–186,4) 0,36 4211 / 2844 / 4105 2029 2,023

Разбор H2 «нет» в baseline3. Вердикт и порог не меняются.

  • Откуда 0,965. Отношение — медиана трёх медиан. При (2, 2) всё стабильно: 2070 / 2039 / 2092 мс. При (4, 4) один повтор — 4381 мс, как обычно, а два — 1997 и 1984 мс, и медиана попала на них. render_ms p50 упал вместе с ними (3992 / 1823 / 1875 мс): снижение в самой обработке, а не в S3 или PostgreSQL.
  • Значения двух видов. Из 12 ячеек lp (4, 4) четырёх меток восемь лежат в 3733–4381 мс, четыре ниже: 1831, 1984, 1997, 2844 мс. То есть низкие значения бывают и в других метках (baseline r1, baseline4 r2); там они не стали медианой.
  • Предположение: в медиану попадают в основном задания, пережившие перезапуски. Данные его не подтверждают, но и не опровергают. Журналы в метку не копируются, стенд удалён, поэтому по отдельным заданиям проверить нечем. Есть только косвенное:
    • Доля готовых после первой гибели процесса 1 (косвенно: первая секунда, где processing больше конкуренции: строки убитого процесса ждут аренду, timeline.csv). Признак двух видов не разделяет: у низких 75–92 %, но у шести из восьми высоких тоже 70–92 % (baseline3 r1: 91 % и 4381 мс). Корреляция с duration_ms по 12 ячейкам −0,30.
    • Число перезапусков. Связь есть, но неполная: все 6 ячеек с 0–3 перезапусками — 3733 мс и выше; из 6 ячеек с 4–10 перезапусками четыре низкие, две высокие (baseline r3 — 5 и 3902 мс, baseline3 r1 — 5 и 4381 мс). Корреляция −0,78 на 12 точках: это связь, а не доказательство причины.
    • Доля заданий с повтором: корреляция −0,55, baseline2 r2 — 60 % и 4212 мс.
  • Что видно из кода, а не из замера. duration_p50_ms считается по всем записям «Attachment became ready» журнала worker, а не только по окну перегрузки. Туда входят 12 файлов s разогрева и задания окон before и after, идущие почти без конкуренции. В lp-c4p4-r2 метки baseline3 это 22 записи из 73 (12 + 5 + 5). Значит, расчётом, медиана уходит к низким значениям, как только ещё ~15 из 51 задания окна over выполняются не при полной конкуренции. Поэтому условие на lp чувствительно: кого именно касается это снижение, метка не показывает.
  • Выгрузка хоста здесь ни при чём по условию: её единственная ячейка в baseline3, lp-c2p256-r1, в условие H2 не входит.

Выгрузка хоста. В двух метках хост выгружал страницы в swap (таблица меток выше), третья пересъёмка прошла чисто, и пользователь принял решение не переснимать бесконечно: при выгрузке результат сохраняется, после baseline3 — ещё один прогон, больше пересъёмок нет (QUESTIONS.md). Причина выгрузки не установлена. Задетые ячейки baseline2 по времени восстановления выше ближнего соседнего повтора:

Ячейка Страниц за ячейку Восст., с Ближний соседний повтор, с Разница
gate-on-s-c2p2-r3 23 380 85,57 84,40 +1,4 %
w2-p256-s-c2p256-r1 1 852 36,40 34,48 +5,6 %
gate-off-s-c2p2-r3 4 524 157,44 142,38 +10,6 %
lp-c1p1-r3 25 068 40,34 36,41 +10,8 %
accept-m-c2p2-r3 197 012 106,22 94,03 +13,0 %

Эффект 1–13 % с объёмом не растёт: 23 380 страниц — +1,4 %, 4 524 — +10,6 %. Похожий разброс бывает и без пометки: восстановление к среднему двух соседних повторов выше 5 % у 22 ячеек из 198 без пометки (конфигурации без задетых ячеек, без lp-c4p4), например s-c4p4-r1 чистой baseline4 +9,6 %. Причинная связь выгрузки с задержкой не показана. Без пяти ячеек вердикты и рекомендация baseline2 те же.

Оговорка к H6: lp (4, 4). В основной метке условие «p95 after ≤ 1,5 × p95 before» содержательно: before 1,36 / 1,30 / 1,28 с, after 1,31 / 1,28 / 1,35 с. Но в baseline и baseline3 оно проходило без смысловой нагрузки: у одного повтора p95 before 83,27 с и 78,44 с, потому что окно задето OOM, и о возврате задержки условие там ничего не доказывало; сам after был 1,31–1,63 с. Порог не менялся.

Настройки и классы (evidence/queue/baseline4/summary.md, «Ячейки по конфигурациям»; медиана и min–max трёх повторов). «Процесс» — пик процесса обработки по его отчёту: p50 / наибольший. Queue lag — пик возраста старейшего незавершённого по окнам before / over / after; ожидание — время задания в очереди p50 / p95, по окнам прихода before; over; after.

Класс (c, p) Готовых/с: окно восстановление Пик незаверш. Пик брокера До ready over p50 / p95 / p99, с Восст., с memory.peak, МиБ VmHWM, МиБ Процесс, МиБ CPU worker, S3 Троттлинг worker OOM Перезапуски Queue lag, с Ожидание в очереди, мс
s (2, 2) 3.10 (3.05–3.10) 3.08 (3.05–3.08) 100 (97–100) 96 (95–97) 16.3 / 30.4 / 31.9 32.5 (32.4–32.6) 175 (175–176) 114 49 / 49 0.99, 0.07 0.99 0 0 0.5 / 12.1 / 0.5 2 / 4; 15544 / 29570; 2 / 3
s (4, 4) 2.65 (2.50–2.70) 2.46 (2.32–2.49) 107 (106–108) 102 (101–104) 20.9 / 41.1 / 42.6 43.4 (43.4–47.6) 250 (249–251) 116 49 / 49 1.00, 0.08 0.99 0 0 0.4 / 12.9 / 0.4 2 / 3; 19022 / 39208; 2 / 4
s (2, 256) 3.00 (3.00–3.10) 3.08 (3.05–3.15) 99 (98–100) 0 (0–0) 16.3 / 30.5 / 32.0 32.5 (32.4–32.5) 175 (175–175) 114 49 / 49 1.00, 0.07 1.00 0 0 0.4 / 12.0 / 0.5 2 / 3; 15572 / 29721; 2 / 3
m (1, 1) 2.30 (2.05–2.30) 2.50 (2.37–2.53) 77 (76–80) 76 (75–78) 16.6 / 30.2 / 31.2 32.3 (30.2–32.4) 154 (154–154) 136 58 / 58 0.73, 0.71 0.13 0 0 0.7 / 12.3 / 0.4 2 / 413; 16136 / 29785; 2 / 59
m (2, 2) 2.85 (2.70–2.90) 2.85 (2.82–2.95) 66 (63–67) 62 (61–64) 11.7 / 21.5 / 22.4 23.2 (22.4–23.3) 210 (210–211) 160 58 / 58 0.96, 0.77 0.88 0 0 0.3 / 10.5 / 0.4 1 / 3; 10967 / 20533; 2 / 2
m (4, 4) 2.75 (2.75–2.75) 2.75 (2.57–2.78) 66 (66–67) 62 (61–63) 12.3 / 23.1 / 23.9 24.4 (24.2–26.3) 300 (294–300) 200 58 / 58 0.97, 0.79 0.94 0 0 0.4 / 10.5 / 0.6 1 / 2; 10681 / 21535; 1 / 2
lj (2, 2) 2.25 (2.20–2.25) 2.34 (2.34–2.37) 76 (76–77) 74 (73–74) 16.5 / 30.7 / 32.0 32.3 (32.3–32.5) 204 (204–206) 152 57 / 57 0.96, 0.62 0.93 0 0 0.7 / 12.2 / 0.6 1 / 2; 15586 / 29734; 2 / 2
lj (4, 4) 2.15 (2.10–2.15) 1.98 (1.95–2.17) 77 (77–78) 74 (73–74) 19.4 / 37.3 / 38.7 39.5 (36.3–40.4) 295 (276–305) 188 57 / 57 0.98, 0.63 0.97 0 0 0.7 / 12.6 / 0.6 1 / 2; 17210 / 35123; 1 / 3
lp (1, 1) 0.85 (0.85–0.85) 0.93 (0.93–0.93) 34 (33–35) 33 (32–34) 19.1 / 34.9 / 36.2 36.5 (35.5–37.1) 467 (466–470) 136 367 / 368 0.88, 0.29 0.21 0 0 1.1 / 13.1 / 1.1 2 / 1104; 17896 / 33663; 1 / 2
lp (2, 2) 0.90 (0.90–0.90) 0.96 (0.96–0.99) 33 (32–34) 32 (30–32) 18.9 / 33.0 / 34.2 33.9 (33.9–35.0) 834 (825–836) 160 367 / 368 0.97, 0.30 0.97 0 0 1.1 / 12.3 / 1.0 1 / 2; 16790 / 30859; 2 / 2
lp (2, 256) 0.90 (0.90–0.90) 0.96 (0.96–0.96) 33 (32–34) 0 (0–0) 19.0 / 33.6 / 34.9 34.8 (33.5–35.1) 831 (694–836) 160 367 / 368 0.97, 0.30 0.98 0 0 1.1 / 12.2 / 1.1 2 / 2; 16922 / 31475; 2 / 2
lp (4, 4) 0.85 (0.50–0.85) 0.36 (0.21–0.51) 34 (34–40) 30 (29–32) 21.4 / 98.5 / 98.8 95.0 (65.8–186.4) 1024 (1024–1024) 206 367 / 368 0.98, 0.31 0.97 68 5 1.1 / 12.4 / 0.6 2 / 2; 9499 / 29496; 2 / 2
  • VmHWM у lp (4, 4) (206 МиБ) — только последняя жизнь контейнера: его читают в конце ячейки, а контейнер за ячейку перезапускался до 4 раз. Это не наибольшее значение за ячейку и не сравнимо с соседними строками.
  • Столбцы OOM и «Перезапуски» — суммы трёх повторов. OOM — счётчик cgroup (63) плюс завершения процесса 1, подтверждённые событиями Docker (5). Завершения worker: на всех конфигурациях, кроме lp (4, 4) и kill-worker, — ни одного; прочих (worker_die_other) нет.
  • Реплик в LB наименьшее (lb_up_min) — 2 в каждой ячейке, lb_down не сработал. Лишних строк в базе (unexpected_rows) нет.
  • Lag и oldest_s. Пик возраста в окне over ограничен длиной окна; ожидание заданий, пришедших в это окно, больше: в матрице p95 до 39,2 с по медиане строки (s (4, 4)) и до 43,4 с в отдельной ячейке (s-c4p4-r1). На m и lp при (1, 1) p95 ожидания окна before — 413 и 1104 мс при единицах у остальных; вероятно, при одном месте конкуренции следующее задание ждёт текущее, отдельно это не мерилось.

Блоки (evidence/queue/baseline4/summary.md, «Ячейки по конфигурациям» и «Блоки»; столбец второго worker — evidence/queue/baseline4/cells.csv).

Блок Принято 429 Готовых/с: окно восстановление Пик p95 до ready, с Восст., с Queue lag over, с Второй worker
gate-on: 20/с, 25 с, предел 250 356 (356–357) 175 (174–176) 3.04 3.10 250 (250–250) 80.2 80.5 (80.5–81.4) 20.7 —
gate-off: то же, без предела 532 (531–533) 0 3.04 3.08 423 (422–424) 130.6 137.5 (137.4–138.5) 20.7 —
accept: m, 15/с, 45 с 339 (333–342) 368 (365–373) 0.91 (0.80–0.98) 3.00 (2.92–3.07) 284 (279–286) 91.7 89.3 (84.4–94.5) 39.2 —
w2-p2 192 (191–193) 0 3.00 5.78 (5.53–5.85) 100 (99–101) 17.1 17.6 (17.4–18.4) 12.3 48–49 заданий, 0,47–0,49
w2-p256 192 (190–192) 0 3.05 2.99 (2.99–3.05) 100 (99–101) 31.1 33.4 (32.6–34.4) 12.1 0 заданий
kill-worker 233 (232–233) 0 2.88 2.23 (2.21–2.26) 128 (127–130) 40.1 58.5 (58.4–58.5) 19.8 —
restart-broker 233 (232–233) 0 2.56 3.02 (3.02–3.10) 137 (137–138) 42.9 45.6 (44.5–46.4) 16.8 —

Второй worker в обоих прочтениях (second_share — порог H3, только разбор; second_share_all — буквально, все завершённые после запуска; second_share_after — само окно after).

Блок, r1 / r2 / r3 second_share Заданий при разборе second_share_all Заданий всего second_share_after
w2-p2 0,471 / 0,471 / 0,485 48 / 48 / 49 0,475 / 0,470 / 0,491 56 / 55 / 57 0,500 / 0,467 / 0,533
w2-p256 0 / 0 / 0 0 / 0 / 0 0,067 / 0,069 / 0,061 8 / 8 / 7 0,500 / 0,500 / 0,467

Backpressure: где работа перестаёт приниматься и ускоряться.

Уровень Значение Что видит клиент Что показала метка
Места загрузки реплики 4 + 16, ожидание 5 с 429, Retry-After: 1 accept: 206–234 отказа с 2,9–3,1 с окна, загрузка 202 p50 4,6–5,0 с
Предел заданий 250 429, Retry-After: 5, сразу gate-on: плато ровно 250, первый отказ на ~14,7 с; accept: 131–167 отказов с 33,9–36,3 с, пик 279–286
Шлюз S3, общий с worker 1 CPU загрузка дольше accept: CPU S3 1,00 в первые 30 с, готовых/с 0,80–0,98 вместо 2,92–3,07 после окна
Outbox копит queued не выше 6, relay не узкое место; при рестарте брокера — до 32
max_published_backlog 1000 queued не достигнут ни в одной ячейке
Предел памяти брокера 400 МиБ queued не достигнут: память брокера по ячейкам 138–224 МиБ. Срабатывание проверяет test_broker_memory_alarm, отказы публикации в метке — только в restart-broker (2 прохода)
prefetch 2 queued неподтверждённых не больше prefetch во всех ячейках матрицы с (2, 2); при 256 — до 99 на s и до 34 на lp, а в очереди брокера 0
concurrency 2 processing processing не больше конкуренции, кроме ячеек с гибелью worker: строки убитого ждут аренду (kill-worker — 4, lp (4, 4) — 8 и 16 при перезапусках, 4 без них); w2-p2 — 4 на двух worker, у w2-p256 пик 2: второй не получил заданий
Лимит контейнера 1 ГБ дольше до ready, failed при исчерпании попыток (2, 2) помещается на всех классах, lp (4, 4) — нет

Клиент за входом видит только дольше не меняющееся queued, ни одного кода ошибки. Перестаёт приниматься на первых двух уровнях. Перестаёт ускоряться на CPU worker (конкуренция сверх двух), а на файлах у границы байтов — ещё на CPU S3, и там приём отнимает ресурс у обработки. Предел заданий останавливает это только на ~35-й секунде такой нагрузки: приоритета обработки над приёмом в S3 нет, это ограничение.

Разбор H4: почему «нет». Вердикт остаётся «нет»: условие записано раньше метки и нарушено; в основной метке — на одной ячейке, во всех четырёх метках — только на m-c1p1. Отношение p95 окна over к «пик / throughput окна over» (evidence/queue/baseline4/cells.csv). Правая колонка — та же величина с throughput окна recovery: это расчёт после метки, порога у него нет, и на вердикт он не влияет.

Конфигурация Записанное условие, r1 / r2 / r3 С throughput recovery, r1 / r2 / r3
s-c2p2 0,944 / 0,953 / 0,943 0,939 / 0,952 / 0,937
s-c2p256 0,934 / 0,918 / 0,946 0,960 / 0,963 / 0,932
s-c4p4 1,057 / 1,047 / 0,998 0,979 / 0,955 / 0,937
m-c1p1 0,780 / 0,902 / 0,851 0,951 / 0,931 / 0,936
m-c2p2 0,938 / 0,946 / 0,867 0,929 / 0,931 / 0,946
m-c4p4 1,018 / 0,963 / 0,962 0,952 / 0,962 / 0,973
lj-c2p2 0,908 / 0,886 / 0,885 0,946 / 0,923 / 0,955
lj-c4p4 1,034 / 0,975 / 1,041 0,962 / 0,983 / 0,957
lp-c1p1 0,869 / 0,873 / 0,855 0,955 / 0,959 / 0,938
lp-c2p2 0,888 / 0,901 / 0,926 0,948 / 0,988 / 0,987
lp-c2p256 0,899 / 0,892 / 0,917 0,957 / 0,950 / 0,980

Всего 33 ячейки без oom: по записанному условию 0,780–1,057, одна ниже 0,8; с throughput recovery 0,923–0,988.

  • Проверено по метке.
    • На m (1, 1) throughput окна over 2,05–2,30, окна recovery 2,37–2,53.
    • По timeline.csv это не разгон: готовых в секунду ровно ~2 все 20 с окна (m-c1p1-r1: первые 10 с — 2,0/с, последние — 2,1/с).
    • В окне over CPU worker 0,69–0,74 и S3 0,71, в recovery — 0,75–0,80 и 0,23–0,26.
    • Задание, пришедшее в конце окна, разбирается уже со скоростью recovery, а формула считает его по скорости over. Поэтому отношение занижено там, где эти скорости расходятся; сильнее всего — на m (1, 1).
  • Предположение, метка его не меряет: в окне over worker при (1, 1) медленнее, потому что ждёт S3, занятый приёмом. На это указывают CPU S3 и троттлинг worker 0,07–0,16, но времени ожидания S3 в метке нет.
  • Вывод. Причина в определении: в формулу гипотезы взят throughput окна, а разбирается очередь в основном после него. Это объяснение, а не отмена вердикта. Гипотеза в записанном виде не подтверждена. Данные показывают, что время до ready следует за очередью с отклонением до ~22 % вниз, и на классах с заметным S3 отношение почти всегда ниже единицы. На ячейках с oom формула неприменима (lp-c4p4: 2,461 / 2,291 / 1,409): там задержку определяют аренда и повторы.

lp (4, 4): что произошло (evidence/queue/baseline4/cells.csv).

Повтор Принято ready failed oom_kill Завершения процесса 1 (ядро) Перезапуски Событий oom Заданий с повтором Истёкших аренд processing, пик Восст., с p95 over, с CPU на задание, с
r1 62 62 0 16 1 1 9 16 4 8 95,04 98,45 1,393
r2 60 60 0 27 4 4 19 27 16 16 186,44 183,28 1,594
r3 62 62 0 25 0 0 11 13 0 4 65,82 56,36 1,464
  • Что значит. Четыре процесса по 367 МиБ не помещаются в 1 ГБ: memory.peak 1024 МиБ, наибольшая anon 968–1008 МиБ. Ядро завершает процессы обработки, задания возвращаются на новую попытку и снова занимают память. Работа делается повторно: CPU на задание 1,39–1,59 с против 1,03 при (2, 2). С первого раза не обрабатываются 21–45 % заданий. Когда завершён процесс 1, взятые задания ждут аренду 70 с (пик processing 16 при конкуренции 4), и worker простаивает: CPU в окне recovery 0,56 / 0,35 / 0,87. Итог — throughput 0,36 вместо 0,96 и p95 98,5 с вместо 33,0 с, при том же лимите. После разбора система приходит в норму: p95 окна after 1,28–1,35 с.
  • failed. В основной метке 0, но это не значит, что риска нет: в baseline 2 задания (retry_exhausted, причина render_killed), в baseline3 4 задания (retry_exhausted, причина lease_expired) на lp-c4p4-r1. Клиент получил на них 202, а теперь видит status: failed и error_code: retry_exhausted. Варианта нет, новое сообщение с таким вложением получает 409. Сами они не восстановятся: возврат — make replay ERROR_CODE=retry_exhausted APPLY=1, оригинал лежит в staging до срока хранения (24 ч). Replay в метках не запускался, его проверяют make failure_checks и driver.py defense-faults. lost 0 означает только, что каждое принятое вложение названо состоянием, а не то, что каждое обработано.
  • Расхождение с пробами. Пробы ждали редких завершений процесса 1: один подтверждённый и один по тем же признакам из пяти прогонов, и в design записано «случайно». Метки показали другое: перезапуски в 11 ячейках из 12, суммы 16, 5, 18 и 5 за три повтора, до 10 в одной ячейке, и только baseline4 r3 прошла без них. Причина расхождения разобрана только частично: на пробах стоял restart: "no", первое завершение останавливало опыт, повторяться циклу было негде; метка идёт с unless-stopped, и цикл доходит до конца. Что перезапуск снова берёт дорогие задания и завершается по той же причине — предположение: повторные завершения в метке отдельно не прослежены. Частоту трёх повторов как оценку не использовать: она только показывает, что завершение не редкость.
  • Причины перезапусков теперь измерены (docker events): все 5 перезапусков основной метки — завершение ядром, worker_die_other 0. В kill-worker — worker_die_command 3 из 3, не oom. В baseline причина не проверялась: там каждый перезапуск прибавлялся к oom_kill косвенно, поэтому её столбец с остальными метками не сравнивается.

Восстановление (evidence/queue/baseline4/cells.csv). Без действий оператора незавершённых становится ноль во всех 57 ячейках, очередь брокера пуста, not_recovered нет. Эффект не дублируется: 0 вторых заданий и наборов вариантов; лишних строк в базе нет; копий relay 0. Скорость разбора при (2, 2) не падает: по медиане recovery не ниже окна over на m, lj, lp, на s 3,08 при 3,10 — в разбросе повторов. Время до ready возвращается (H6, условие по конфигурациям). Контрольный поток — H7; в accept наибольшие p95 — запись 23,8, чтение 14,0, скачивание 371,9 мс (порог H9 — 1 с), p95 скачивания в окне over — 313,8–371,9 мс против 6,8–7,3 на s при CPU S3 ~1,0, ошибок нет. Связь с занятым S3 — предположение: отдельно не мерилась.

Сценарии «Работа копится там, где положено» и «Бэклог уходит за измеренное время» уточнены по факту этой метки (design, «Уточнения apply», п. 14; вердикты не менялись): processing — на один worker, кроме строк завершённого процесса, а условие о скорости — только для настройки, которая помещается в лимит памяти, без завершений worker и с конкуренцией до двух мест на CPU. Падение на прочих, окно восстановления при окне перегрузки: lp (4, 4) 0,36 при 0,85, kill-worker 2,23 при 2,88 (последние две строки ждут аренду), s (4, 4) 2,46 (2,32–2,49) при 2,65 (2,50–2,70).

Компромисс latency и ресурсов (вывод из таблиц выше).

  • Память без скорости. По правилу шума решения 11 (разбросы не пересекаются, разница медиан больше наибольшего разброса):
    • (4, 4) против (2, 2) — эффект в худшую сторону на s и lj: throughput ниже на 20 и 15 %; на m 2,75 и 2,85 — в пределах шума. Память выше на 43, 45 и 43 % (s, lj, m). На lp — потеря обработки.
    • (1, 1) против (2, 2) на lp — в пределах шума по скорости (0,93 и 0,96), памяти 467 МиБ вместо 834: выигрыш 44 %.
    • (1, 1) на m — эффект: на 12 % медленнее (2,50 и 2,85), памяти 154 МиБ вместо 210, потому что worker при одном задании ещё ждёт S3 (CPU 0,73).
  • CPU, а не конкуренция, поднимает потолок. Второй worker на s: 5,78 готовых/с вместо 3,08, восстановление 17,6 с вместо 32,5, ценой ещё 1 CPU и 1 ГБ лимита. Формула масштабирования этим не доказана (ограничения ниже).
  • Большой prefetch ничего не даёт и прячет очередь: та же скорость на s и lp, брокер показывает 0 готовых, второй worker простаивает, восстановление 33,4 с вместо 17,6.
  • Цена отказа клиенту. Предел обменивает принятые файлы на срок: 175 загрузок из ~532 получают 429, зато p95 до ready 80,2 с вместо 130,6. Цена проверки в окне before: p50 16 против 16 мс при разбросе 15–19 мс.
  • Формула подбора на двух точках сходится. Память: база ≈ 467 − 368 ≈ 99 МиБ на (1, 1), прогноз для (2, 2) — 99 + 2 × 368 = 835 МиБ при измеренных 834; (1024 − 99) / 368 ≈ 2,5, то есть 2 помещается, 4 нет; 3 в метке нет. CPU: при (1, 1) на m 0,73 ядра, значит, конкуренция 2 ещё даёт прирост, что и видно; при (2, 2) уже 0,96. Это согласие с данными, а не доказательство: опытов на формулу метка не ставила.

Рекомендация и значения по умолчанию (evidence/queue/baseline4/summary.md, «Рекомендация»). Правило решения 12 даёт конкуренцию 2, prefetch 2, как и в трёх других метках. (1, 1) не кандидат: на m throughput ниже 90 % лучшей, и снята не на всех классах (нет lj, s). (4, 4) не кандидат: сводка называет первую найденную причину — на lj throughput 1,98 / 2,34 ≈ 0,85 при пороге 0,90, а на lp есть и oom. (2, 256) не кандидат: снята не на всех классах (нет lj, m). На снятых s и lp условия она проходит, но условие «на всех классах» для неё не проверено; сверх того prefetch больше конкуренции ничего не добавляет (H3). worker_crash в метке нет, поэтому решение основной сессии о такой настройке не понадобилось. Значения оставлены: рекомендация совпала с (2, 2), поэтому условие смены не наступило и отдельного commit нет. Условия рекомендации: 1 CPU и 1 ГБ на worker. При другом лимите пересчитать по формуле выше; для потока только больших PNG (1, 1) экономит память без потери скорости, но это другая установка, а не значение по умолчанию.

Предел 250 по измеренному потолку. Обоснование решения 2 опиралось на пробу: потолок lp 0,92/с и ожидание ~270 с при границе 300 с ([relay] republish_after_seconds). Метка: потолок lp при (2, 2) — 0,96/с (recovery), 250 / 0,96 ≈ 260 с. Совпало только для измеренных классов: ожидание меньше 300 с, предел менять незачем. Запас меньше, чем кажется: с окном приёма (0,90/с) ~278 с, с превышением (граница H5 290, измерено до 286) ~302 с при потолке recovery и ~322 с при потолке окна, то есть за границей. Выход за границу на (2, 2) копий не даёт: выданное сразу взято, а пока в брокере есть готовые, relay не публикует заново. При (2, 256) задания старше порога получат копию, эффект нулевой по пробе (188 копий на 150 заданий, лишнего эффекта 0). В метке копий 0, но lp у предела не снимался.

Класс Потолок (2, 2), готовых/с Ожидание у предела 250, с Как получено
s 3,08 ~81 измерено: gate-on p95 80,2 с, восстановление 80,5 с
m 2,85 ~88 расчёт; accept при пике 284 измерил p95 91,7 с
lj 2,34 ~107 расчёт, у предела не снималось
lp 0,96 ~260 расчёт, у предела не снималось

Staging при заполненном пределе: 250 × 10 458 117 байт ≈ 2,4 ГиБ плюс превышение — расчёт, на lp у предела не снималось. Отставание очистки: наибольшее число ready с необнулённым staging за конфигурацию 49–196 (timeline.csv), очищается следующими проходами уборщика (60 с). Ограничение счёта, а не байтов названо ниже.

Ограничения метода.

  • Один хост и ВМ Docker Desktop (arm64, 12 CPU, 7,75 ГиБ): лимит 1 CPU — квота CFS, а не отдельное ядро; генератор и посторонние контейнеры на той же ВМ, доля их CPU видна по vm.
  • Один worker; второй — только в своём блоке и на классе, где S3 не узкое место (CPU S3 ~0,08): общая формула масштабирования не утверждается.
  • Выгрузка хоста: основная метка чистая, но две другие сняты с ней, причина не установлена (раздел «Выгрузка хоста» выше).
  • Ячейка — один класс, один файл на все загрузки: смесь размеров и разброс содержимого не мерятся.
  • Окна короткие, 20–45 с перегрузки: многочасовая перегрузка, autovacuum под длинным оборотом и рост WAL не мерятся, проба — только 90 с оборота.
  • Открытая модель без повторов: поток клиентов, послушно повторяющих после Retry-After, не мерится; отказ считается отказом.
  • PostgreSQL, relay и брокер в этих интенсивностях не упираются: их предел трек не определяет; max_published_backlog и предел памяти брокера нагрузкой не достигаются. Метка это подтвердила (таблица backpressure).
  • Одна нода S3, staging и конечный префикс на одном диске ВМ; ячейки — на свежем volume, поэтому рост памяти S3 с накопленными объектами не мерится (проба на старом стенде — KNOWN_ISSUES.md).
  • Выборки before и after малы на lp: повторы сводятся, p99 у малых выборок — только справочно.
  • Поправлено по меткам. В решении 12 стояло: завершение процесса 1 ядром при (4, 4) на lp случайно, один подтверждённый случай и один по тем же признакам из пяти прогонов. Метки показали его в 11 ячейках из 12: 16, 5, 18 и 5 раз за три повтора. Частота из трёх повторов по-прежнему не следует, но «редко» неверно. «Работа не теряется» верно только с оговоркой: в baseline 2 задания и в baseline3 4 задания ушли в failed и ждали бы make replay, в основной — ни одного.
  • Повторы lp (4, 4) не дают устойчивой оценки: три повтора этой конфигурации плавают сильнее порогов, отсюда и расхождение H2 между метками.
  • Журналы контейнеров в метку не копируются: по отдельным заданиям выводы проверить нельзя, разбор H2 опирается на медианы ячеек и посекундную шкалу.
  • duration_p50_ms и столбцы queue_wait_p*_ms на ячейку считаются вместе с разогревом (12 файлов s): одинаково во всех метках и настройках, но на lp это другой класс в той же медиане.
  • Предел считает задания, а не байты: lp в 3 раза дороже s при том же счёте; предел один на стенд, справедливости между пользователями нет.

Отказы

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Worker остановлен, рестарт API и хранилищ, worker запущен принятая работа дожидается queued → ready, те же байты (defense.md) потерь нет
Брокер остановлен при загрузке 202, намерение ждёт, остальное API работает так (test_upload_with_broker_stopped, test_readiness_without_broker_and_worker) после возврата relay публикует, потерь нет
Брокер заморожен 202 без ожидания брокера так (test_upload_with_broker_paused) потерь нет
Relay убит до публикации 202, сообщения нет, следующий запуск публикует так (defense-faults.md, test_relay_killed_before_publish) потерь нет, ручного задания нет
Relay убит после confirm до отметки дубль сообщения без второго эффекта так (defense-faults.md, test_relay_killed_after_confirm) attempt 1, потерь нет
KILL брокера и up --force-recreate с volume подтверждённые сообщения на месте так (test_broker_kill_keeps_confirmed, test_broker_recreated) потерь нет
Сообщение потеряно вместе с очередью relay публикует снова, при непустой очереди копий нет так (test_lost_message_republished, test_no_copies_while_queue_has_messages) через republish_after_seconds, 300 с
Worker убит посреди обработки или после записи объектов следующая попытка по аренде, те же ключи так (defense-faults.md, test_worker_killed_during_processing) 70 с на рабочем стенде, потерь нет, попытка посчитана
Worker убит после COMMIT до ack повторная доставка, no-op так (defense-faults.md, test_crash_after_commit_before_ack) сразу после запуска, потерь нет
Worker заморожен дольше аренды новая попытка, прежняя не фиксирует ни при живой новой, ни после её итога так (test_hung_worker_lease_fencing, test_hung_worker_thawed_after_ready) по аренде, дублей эффекта нет
Дорогой файл в пределах контракта процесс обработки прерван по CPU, worker цел так (test_limit_cpu_scan_bomb) 15 с CPU на рабочем стенде, invalid_image
S3 недоступен при обработке повторы с backoff под одним job_id, затем ready или retry_exhausted так (test_transient_error_retried, test_attempts_exhausted) рабочий стенд выдерживает сумму пауз 37,5–75 с и сроки попыток (расчёт по настройкам, design, решение 4; тесты — на коротких сроках стенда отказов); дольше — failed, возврат make replay
S3 недоступен при очистке staging проход прерван, сообщения не ждут так (test_staging_cleanup_survives_outage) следующий проход повторяет
PostgreSQL недоступен при обработке задание ждёт, попытка не считается так (test_database_outage_during_processing) потерь нет
Сообщение не по схеме отброшено, error без содержимого так (test_malformed_message_dropped, logs.md) следующие задания идут
Реплика API остановлена или убита запись через другую failed_attempts 0 (test-failover.md) 1,72 и 0,85 с, потерь нет

Ограничения и следующие шаги

Ограничения этого уровня, названные спеками:

  • Отказ S3 дольше бюджета. Сумма пауз 37,5–75 с и сроки попыток: рестарт S3 (~25 с) укладывается, более долгий отказ переводит взятые задания в failed retry_exhausted. Лечит make replay ERROR_CODE=retry_exhausted APPLY=1: это явный шаг оператора, а не автоматика.
  • Восстановление после KILL по аренде. После KILL worker следующая попытка начинается по истечении аренды, до 70 с (наблюдали 70 с). Пульс отвергнут (раздел «Ответы на вопросы защиты»). Повторная доставка уже готовой работы — сразу.
  • Дубли сообщений. Неизвестный исход публикации, crash до отметки и потерянные сообщения дают дубли: at least once. Каждый дубль — SELECT … FOR UPDATE и ack, эффект защищён ключом и fencing. Сообщения, которые держит большой prefetch дольше republish_after_seconds, брокер готовыми не считает: они могут получить копию.
  • Объект, дописанный прежней попыткой. Фиксацию fencing прежней попытке запрещает, но замороженный процесс после разморозки может записать объект теми же байтами: ключ тот же, версия декодера та же.
  • Профиль ICC отбрасывается. Учебные данные — sRGB; изображение с другим профилем изменит цвет в вариантах.
  • Лимит памяти на macOS. setrlimit(RLIMIT_AS) на хосте macOS отказывает, консольный worker это пишет в журнал (render_memory_limit_applied); на стенде Linux лимит действует.
  • Цена процесса на задание. Метка baseline4: CPU worker на задание при (2, 2) — 0,32 с на s, 0,33 на m, 0,42 на lj, 1,03 на lp (evidence/queue/baseline4/cells.csv; в baseline это число занижено, см. выше). Долю запуска процесса метка не выделяет, проба — ~100 мс на маленьком файле. Forkserver (9 мс) отвергнут сейчас: секреты родителя в окружении и свой жизненный цикл. Граница — один модуль.
  • Изоляция секретов процесса обработки неполная. В его окружении секретов нет, но он идёт под тем же UID, что процесс 1 worker, и может прочитать /proc/1/environ с ключами S3 и паролями PostgreSQL и брокера. От случайной утечки это защищает, после эксплойта декодера — нет. Предложение — PR_SET_DUMPABLE=0 в процессе worker, вопрос преподавателю (QUESTIONS.md, ## pipeline-reliability).
  • Дорогие файлы занимают worker. Предел считает задания, а не байты и CPU. Измерен файл на границе байтов и пикселей: ~1 с CPU, поток таких файлов при 250 незавершённых ждёт ~260 с. Худший случай не измерен: scan bomb в пределах контракта стоит лимит процесса, 15 с CPU, расчётом 250 × 15 с ≈ 1 час разбора и копии от relay при таком ожидании. Обоснование предела «ожидание меньше 300 с» верно только для измеренных классов, для этого файла — нет. Защиты, кроме лимита на файл, нет.
  • Завершение процесса 1 worker ядром. Конкуренция, которая не помещается в лимит памяти, стоит не только повторов: lp (4, 4) — 5 перезапусков за три прогона в основной метке, 16 и 18 в других, задания ждут аренду 70 с, в baseline и baseline3 2 и 4 задания ушли в failed retry_exhausted. Значение по умолчанию на всех классах помещается; правило подбора — раздел «Очередь под перегрузкой».
  • Приём у границы байтов отнимает S3 у worker. Готовых/с 0,80–0,98 вместо 2,92–3,07, пока S3 занят приёмом. Приоритета обработки нет, предел останавливает это на ~35-й секунде такой нагрузки.
  • Предел мягкий и один на стенд. Превышение — загрузки в полёте (измерено до 286 при пределе 250), справедливости между пользователями и чатами нет.
  • Сверка не проверяет объекты вариантов. Наличие и размер объектов вариантов сверка не проверяет: вариант без объекта даёт 500 на скачивание и error в журнале (test_missing_variant). Объекты staging она с этого уровня видит (orphan_staging).
  • Удаление очереди при работающем worker. Потребитель этого не замечает: relay создаст очередь заново, worker нужно перезапустить. На стенде такого нет, кроме уборки своей очереди после остановки своего worker.
  • Старые ready без crop и optimized. Вложения уровня 3 остаются с одним thumbnail, скачивание этих вариантов — 404; replay ready запрещён намеренно. Показано в evidence/migrations/pipeline-reliability.md.
  • Staging и конечный префикс на одном сервере S3. Устойчивость staging — устойчивость этого сервера и bucket: отказ диска или ВМ теряет и то, и другое.
  • Отставание очистки staging. Объект живёт до следующего прохода уборщика (60 с). Метка baseline4: наибольший долг по конфигурациям 49–196 вложений, разбирается следующими проходами; многочасовая нагрузка не мерилась. S3 на долго живущем стенде — KNOWN_ISSUES.md.
  • Смесь версий при замене на уровень 3 и новые статусы. С версии лабы 4: прежняя реплика отвечает 201 ready и даёт 500 на чтении строки нового статуса (evidence/migrations/async-attachments.md). Для загрузок реплик прежней версии, переживших grace, защита пометкой уборщика не гарантирована: они пометку не проверяют. Запись — KNOWN_ISSUES.md. Порядок обновления с уровня 3 — раздел «Разрыв COMMIT и publish и окна отказа».
  • Прерванное остановкой задание. Задание, прерванное docker stop дольше graceful_shutdown_seconds (8 с), считается начатой попыткой и продолжается по аренде: release на пути отмены ненадёжен. Замер на двух дорогих JPEG: 8,15 с, при замороженных PostgreSQL и брокере 9,18 с (evidence/worker/process.md). Худший случай остановки 8 + 0,5 + 0,5 + 0,5 = 9,5 с < 10 с.
  • Искажения данных скана JPEG. Структурная проверка и libjpeg байт внутри данных скана ошибкой не считают: такое вложение становится ready, а варианты будут с мусором. Проверка не декодирует пиксели при приёме намеренно.
  • Цена соединения на шаг. Двухшаговая JSON-ручка выдаёт соединение дважды: под перегрузкой запрос встаёт в очередь пула дважды, запас на ожидание у него около половины общего срока. Отказ БД при откате успешного чтения — 503, окно в один обмен: откат теперь до ответа. Отмена задачи сбрасывает соединение вместо возврата в пул (design change unit-of-work, Risks).
  • Подмена do_ping. Дешёвая проверка соединения опирается на внутренние имена адаптера asyncpg в SQLAlchemy: закреплён <2.2, смену ловят тесты test_ping_* в make service_test_db. Прерванная проверка не оставляет сессий сверх пула только потому, что BoundedCloseConnection сам обрывает внутренний _transport asyncpg (design.md, уточнение 17): смену имени ловит test_no_sessions_over_pool_after_freeze.
  • Фейки не проверяют блокировки. Быстрый тест зелёный при сломанном SKIP LOCKED: блокировки и конкуренцию доказывает только make failure_checks (таблица решения 11 design).
  • Метаданные и скачивание вложения без общего срока. Вход и блок — до 12 с при timeout server 10 с: клиент получит 504 от LB вместо 503. Дефект прежний, запись — KNOWN_ISSUES.md.
  • Цепочка LB. Брокера в пути нет, поэтому самым долгим снова стал путь компенсации: после тела проверка ~4 + tx1 6 + PUT 5 + tx2 6 ≈ 21 с, с DELETE компенсации + 5 ≈ 26 с < timeout server 30 с. Наибольшая длительность живой загрузки U = 17 + 30 + 26 ≈ 73 с < дренаж замены 90 с: до тела 2 × request_timeout_seconds + wait_timeout_seconds = 17 с; тело — [uploads] body_timeout_seconds 30 с.

Другие ограничения:

  • CHECK статуса, ck_attachments_error_code_failed и ck_attachment_jobs_attempt_base остаются NOT VALID: VALIDATE держал бы блокировку на время просмотра таблицы, а прежние строки условиям отвечают.
  • Один пользователь брокера на relay и worker; разделение прав — лаба 7.
  • Предел памяти брокера 400 МиБ блокирует публикацию: relay получает отказ по сроку 2 с, загрузка по-прежнему 202, намерения копятся в PostgreSQL (test_broker_memory_alarm), пока не достигнут предел незавершённых заданий.
  • Ранний ответ при загрузке: urllib напрямую к реплике на большом теле теряет ранний ответ; через LB и с httpx или curl — получает.
  • Keyset-пагинация: порядок задаёт (created_at, id); created_at назначает сервер, при расхождении часов реплик порядок вставки возможен только по этому ключу.

Следующие шаги. Вне трека и не сделано: приоритет обработки над приёмом в S3, предел по байтам и на пользователя, forkserver, рост памяти S3 с накопленными объектами. Подтверждено замером только то, что есть в разделах выше.

Источники, библиотеки и использование ИИ

Документация: RabbitMQ reliability, Publisher confirms and acknowledgements (из README.md задания); aio-pika — https://docs.aio-pika.com/; Pillow — https://pillow.readthedocs.io/ (Image.draft, resize с reducing_gap, EXIF); PostgreSQL 18 — NOT VALID, FOR UPDATE, lock_timeout; Harry Percival, Bob Gregory, «Architecture Patterns with Python» (Cosmic Python), главы 2 и 6 — Repository и Unit of Work; источники лаб 2–4 — в их отчётах. Поведение брокера и Pillow проверено пробами: таблица «Пробы» в openspec/changes/archive/2026-10-31-async-attachments/design.md.

Библиотеки: новые — aio-pika 10.2.1, Pillow 13.0.0 (из dev-группы в основную); уровень 4 новых не добавил: WebP уже есть в Pillow (libwebp 1.6.0); единица работы — тоже: async def тесты запускает плагин anyio, он уже в зависимостях. Остальное — uv.lock. Пробы уровня 4 — таблица «Пробы» openspec/changes/archive/2026-10-31-pipeline-reliability/design.md.

ИИ. Код, тесты, инструменты, спеки, снятие доказательств и этот отчёт сделаны с помощью Claude Code (Anthropic) по циклу OpenSpec: предложение, реализация, проверка, правки по проверке, архивация; каждую стадию вёл отдельный агент, основная сессия принимала результат и коммитила. Перенос на единицу работы (unit-of-work, по указанию пользователя) — так же, проверен наборами student-tests/ и make failure_checks без их правок и временными регрессиями; очередь под перегрузкой (track1-queue-overload) — гипотезы и правило рекомендации записаны до метки, метки сняты командой make bench_queue; метку baseline отменили ошибки инструмента, найденные проверкой, baseline2 и baseline3 не стали основными из-за выгрузки хоста в swap, основная — baseline4 (QUESTIONS.md). Выбор оценки, трека, брокера и единицы работы — решения автора; решения и отвергнутые варианты — design.md, принятые без пользователя — QUESTIONS.md. Каждый файл evidence/ снят командой из его шапки на стенде этой лабы, а не сгенерирован; числа в отчёте перенесены из выводов команд на названном commit.