Files
mtusi2026lab3/openspec/changes/profile-resources/design.md
T

51 KiB
Raw Blame History

Design

Context

Зачем — proposal.md, что должно получиться — дельта specs/load-benchmark. Здесь — текущее устройство и факты, на которых стоят решения.

Профили уровня «4» сегодня (bench/run.py, правило .claude/rules/bench.md, разделы профилей):

  • run_failover / run_phase: стенд, читаемый чат, курсоры (prepare_load), затем фазы режим × реплика. В фазе:

    • k6 failover.js в долгоживущем контейнере mtusi-bench-k6 (docker exec, без лимита, без метки проекта);
    • docker stop --timeout 9 / kill / pause над репликой и возврат start / unpause того же контейнера: ID не меняется;
    • события Docker фазы — после неё (stand.events, буфер демона);
    • запросы — строки fo,… с Date.now() k6.

    Все отметки — часы ВМ Docker.

  • run_rollout: реплики на образе c50b721, поток docker events проекта (Stand.project_events: create, start, kill, die, destroy), k6 на 15 + 90 + 15 с. Через 15 с — scripts/rolling-update.sh:

    • проверки и обращения к LB через docker compose exec -T haproxy bash …;
    • сборка из кэша;
    • миграция в контейнере сервиса migrate;
    • третья реплика --scale, дренаж, остановка и удаление старой.

    Контейнеры реплик меняются: ID новых заранее неизвестны. t0 — create контейнера миграции, конец — destroy последней старой.

  • Ресурсы эти профили не снимают. В REPORT.md строка «CPU / RAM» — «только лимиты».

Сэмплер трека 1 (design архива 2026-10-11-scaling-bench, решение 7):

  • bench/sampler.sh в контейнере mtusi-bench-sampler на образе PostgreSQL стенда: --cgroupns host, 0,25 CPU / 128 МиБ, метка проекта;
  • аргументы — <интервал> <роль>=<полный id>…, список задан при старте;
  • раз в секунду пишет строки cg (cpu.stat, memory.current, cpu.pressure из /sys/fs/cgroup/docker/<id>/; каталога нет — missing), vm (/proc/stat, PSI ВМ), lb (CSV статистики HAProxy);
  • в фоне psql \watch 1 — одно соединение и один запрос в секунду к PostgreSQL;
  • разбор — scaling.parse_samples, агрегаты окна — scaling.analyze_samples / container(). container() считает CPU разностью первого и последнего отсчёта окна и ждёт непрерывный счётчик. Сброс счётчика и пропуск контейнера он не переживёт.

Проверено в propose (временные контейнеры на ubuntu:22.04, удалены сразу; стенд не трогался):

  1. Жизнь cgroup на Docker Desktop 29.8 (cgroup v2, docker/<id>):

    • docker pause — каталог остаётся, cgroup.freeze = 1, usage_usec и memory.current не меняются;
    • docker stop и docker kill — каталога нет;
    • docker start того же контейнера — каталог появляется заново, и usage_usec считается с нуля (257 472 мкс через ~1 с после старта, до остановки было 525 410).
  2. docker events --filter label=… --filter event=exec_start ловит docker exec в контейнер с меткой. Action содержит команду, например exec_start: sh -c echo a|cat >/dev/null, с | внутри. Разбор rollout.parse_container_events берёт поля с краёв строки и это переживает.

  3. Цена запроса сэмплера к PostgreSQL. Тот же SQL, что в sampler.sh, 50 раз через psql с \timing в контейнере PostgreSQL рабочего стенда: медиана 0,535 мс, p90 0,633 мс, первый — 5,2 мс (холодный кэш каталога). Это время клиента, то есть верхняя граница CPU сервера.

  4. Цена PostgreSQL в треке 1 по runs.csv (scaling-b, scaling-aa, 1 × 1, фиксированные уровни):

    • на 250/с — 0,067–0,068 ядра, 268–272 мкс на успешный запрос;
    • db_commits_per_s 51–52: 50 записей в секунду плюс фон, в нём и запрос сэмплера, один в секунду;
    • линейная подгонка CPU PostgreSQL по интенсивности на прошедших SLO ступенях даёт свободный член −0,002…−0,004 ядра: постоянный фон (сэмплер, проверки LB, фоновые процессы) меньше разрешения.

    Значит, psql \watch 1 стоит не больше 0,00054 ядра — ≤ 0,8 % CPU PostgreSQL при 250/с. LB тратил 0,018–0,020 ядра на 250/с вместе с опросом статистики раз в секунду.

  5. Бюджет ВМ (12 vCPU, 7,7 GiB):

    • failover: API 2 × 1 + PostgreSQL 2 + HAProxy 1 + Valkey 0,5 + сэмплер 0,25 = 5,75 CPU; 2 × 512 МиБ + 1 ГиБ + 256 + 128 + 128 МиБ = 2,5 GiB;
    • rollout на пике (API_REPLICAS + 1 реплик): 6,75 CPU и 3,0 GiB. Миграция (0,5 CPU / 256 МиБ) идёт до третьей реплики, при двух старых, и пик не поднимает.

    k6 без лимита (bench.md): в graceful-failover при 1 200 VU — около 400 МиБ. Его CPU раньше не мерили, теперь мерим.

  6. Чем код новых меток отличается от baseline.

    • failover/baseline — commit 459f84c. После него в приложении:
      • колонка messages.instance_id и её миграция;
      • 503 на «too many clients» (68edc66);
      • пул 10 + 0 вместо 10 + 5 (9c3959d);
      • в haproxy.cfg — runtime API (stats socket) на loopback.
    • rollout/baseline — код de654a1. После него — тот же пул, 503, lock_timeout миграции 2 с вместо 5 с и правки scripts/rolling-update.sh (5e102e6, 84161c0).
    • k6: в failover.js и prepare.js поведение то же (комментарии, цикл чатов записи с одним чатом по умолчанию).

    Поэтому сравнение доступности новой метки с baseline — проверка, что поведение то же, а не A/B влияния сэмплера.

Goals / Non-Goals

Goals:

  • CPU и память каждого компонента и занятые ядра ВМ по окнам обоих профилей. Посекундно — на тех же часах, что шкала фазы.
  • Один сэмплер на все профили стенда. Серии трека 1 не меняют ни поведение, ни формат отсчётов.
  • Наблюдатель не трогает то, что меряет: не обращается к PostgreSQL и LB, не запускает процессов в контейнерах стенда, не меняет нагрузку, окна, лимиты и пороги.
  • Метки resources и отчёт с измеренными числами, рядом с baseline.

Non-Goals:

  • Метрики PostgreSQL (pg_stat_*) и счётчики LB (повторы, перенаправления, очереди) в профилях уровня «4». Сэмплер это умеет, но вопросы профилей — CPU и память. Без них наблюдатель не нагружает PostgreSQL и LB совсем.
  • Графики SVG профилей уровня «4»: посекундной таблицы и сводки достаточно.
  • Пересъёмка baseline без сэмплера и A/B «с сэмплером / без»: один прогон на фазу шумит сильнее, чем мог бы повлиять сэмплер (решение 9).
  • Изменение нагрузки, окон, лимитов, порогов, k6, compose стенда, кода приложения.
  • Пункты KNOWN_ISSUES.md: события фазы failover из буфера демона (сэмплер событий не добавляет, кроме своего старта до фаз) и swapouts_delta при счётчике 0 (в паспорте остаются start и end). Их исправление — отдельный change по просьбе.
  • Сравнение меток уровня «4» командой (make bench_compare их не берёт). Рядом в отчёте ставятся числа из файлов меток.

Decisions

1. Тот же sampler.sh, режим scan

Второй аргумент scan вместо списка <роль>=<id> включает режим поиска:

  • cgroup. На каждом тике сэмплер обходит /sys/fs/cgroup/docker/*/. Берутся только каталоги с именем из 64 hex, то есть контейнеры: buildkit и прочие служебные пропускаются. Для каждого пишется та же строка cg <нс> - <id12> …, с ролью -. Каталог пропал между обходом и чтением — строка missing, как раньше.

  • ВМ — строка vm, как раньше.

  • Без psql и без опроса LB. В режиме scan фоновый psql \watch не запускается, статистика HAProxy не запрашивается. Наблюдатель не держит соединение с PostgreSQL и не шлёт запросов LB. Вместо оценки малых накладных расходов (Context, п. 4) их просто нет.

  • Роли — у оркестратора. Stand.container_map() строит отображение id12 → (роль, имя):

    • docker ps -a --no-trunc --filter label=com.docker.compose.project=mtusi-bench с меткой com.docker.compose.service: api, postgres, valkey, haproxy, migrate;
    • k6 и сэмплер — по имени: mtusi-bench-k6, mtusi-bench-sampler.

    Отображение снимается при старте сэмплера и перед разбором. У rollout к нему добавляются create из потока событий проекта. Новые реплики и контейнер миграции видны и после удаления старых. Строки остальных cgroup отбрасываются, их число пишется в meta.resources.unmapped. Так чужой контейнер в ВМ (рабочий стенд при самопроверке) в результаты не попадает.

  • Контейнер сэмплера в режиме scan — без сети, метки проекта и паролей.

    • --network none: соединения ему не нужны. Свойство «не обращается к приложению, хранилищам и LB» обеспечено устройством контейнера, а не только кодом скрипта.
    • Без POSTGRES_* в окружении: секреты только там, где нужны.
    • Без метки проекта. Метка есть у серий. Здесь она сделала бы сэмплер «сиротой» проекта для docker compose up в scripts/rolling-update.sh: compose печатает предупреждение, а скрипт меряется. leftovers() и Stand.stop() и так находят сэмплер по имени.
  • Серии не меняются. run_cell по-прежнему передаёт список <роль>=<id>. Режим list — прежний код целиком, с psql и LB. Формат строк тот же, разбор — тот же scaling.parse_samples: роль - для него обычная строка.

Отвергнуто:

  • Список и перезапуск сэмплера при смене контейнеров: пропуск отсчётов ровно во время замены.
  • Список и файл целей, который оркестратор дописывает по событиям: нужен поток-наблюдатель, и остаётся гонка первых секунд новой реплики. Обход cgroup видит её на следующем тике сам.
  • Сокет Docker в контейнер сэмплера ради меток: это доступ уровня root к ВМ, и в образе PostgreSQL нет docker CLI.
  • docker stats — нет троттлинга, шаг ~2 с. docker exec cat в контейнеры — процесс попадает в измеряемую cgroup (решение 7 design scaling-bench).

2. Время жизни сэмплера

  • Поле профиля sample_resources: bool = False, True у failover, failover_quick, rollout, rollout_quick. Признак методики живёт в Profile (bench.md) и попадает в meta.profile. Интервал, CPU и память сэмплера — прежние поля sample_interval_s (1), sampler_cpus (0,25), sampler_memory (128m).

  • Старт — после prepare_load (стенд готов, данные и курсоры есть), до первой нагрузки. У rollout — после containers_before, до потока событий и k6.

    • Проверка старта, как у серий: за 5 с есть строки cg всех работающих контейнеров проекта, k6 и самого сэмплера, и строки vm. Строк lb и PostgreSQL в режиме scan не ждём.
    • Лимиты сэмплера, прочитанные у контейнера, — в meta.limits.sampler.
  • Остановка — после последней нагрузки (failover — после последней фазы, rollout — после k6 и скрипта). Stand.stop() удаляет сэмплер и при сбое, как сейчас.

  • Между фазами сэмплер работает дальше (повтор записей, сверка, ожидание реплик). Отсчёты вне нагрузки в таблицы не идут. Один контейнер на весь прогон — один create/start в событиях демона до первой фазы. Буфер событий, по которому failover ищет действие (KNOWN_ISSUES.md), он не расходует.

  • Сторож. После нагрузки каждой фазы (и после нагрузки rollout) проверяется:

    • сэмплер работает;
    • в окне нагрузки соседние тики vm не дальше 3 с друг от друга.

    Иначе BenchError с фазой: метка без ресурсов не годится для цели change.

3. Счётчики → интервалы

Модуль bench/resources.py, чистые функции, stdlib. Вход — отсчёты scaling.parse_samples, отображение ролей, моменты запуска контейнеров.

  • Тик — отметка строк vm. Все строки одного тика несут одну отметку ns: она берётся один раз в начале цикла.

  • Интервал контейнера — пара соседних отсчётов (prev, cur]. Он несёт приросты usage_usec, nr_periods, nr_throttled, throttled_usec, PSI и память на конце.

  • Сброс — usage_usec уменьшился или между отсчётами есть момент запуска контейнера из событий Docker: cgroup новая, это start после stop / kill (Context, п. 1). Тогда cur начинает новый сегмент. Второе условие страхует первое: счётчик до остановки почти всегда больше (в нём наполнение и прежние фазы), но на событие опираться надёжнее.

  • Свежий сегмент — сброс, или контейнер впервые виден позже первого тика (новая реплика, миграция). Счётчики новой cgroup идут с нуля. Поэтому значение первого отсчёта — CPU от запуска до него. Оно относится к интервалу (s, cur], где s — момент запуска из событий Docker:

    • failover — событие возврата фазы;
    • rollout — start из потока событий проекта.

    Если момента нет, s — предыдущий тик: cgroup появилась после прошлого обхода.

  • Первый отсчёт контейнера на первом тике — база, а не прирост. Иначе в окно попал бы CPU наполнения стенда.

  • Пропуск тика без сброса (usage_usec не уменьшился) — продолжение. Прирост делится на весь промежуток. Так ложный пропуск, например задержка сэмплера, не превращается в «свежий» CPU всей жизни контейнера.

  • Пауза — отсчёты идут, прирост 0, память прежняя.

  • Остановка — отсчёты кончаются. CPU между последним отсчётом и выходом процесса, не больше одного интервала, не виден: cgroup удалена. Это ограничение 1 с разрешения (Risks).

4. Окна

Отметки — часы ВМ Docker, наносекунды. Разгон 2 с с первого запроса фазы — вне окон, как before_rows[2:] у failover.analyze: k6 только что создал 1 200 VU.

Профиль Окно Начало Конец
failover before первый запрос фазы + 2 с действие (событие Docker)
failover down действие возврат (start / unpause)
failover after возврат отправка последнего запроса фазы
rollout before первый запрос + 2 с первое exec_start проекта после первого запроса — первое обращение скрипта к LB
rollout prepare то же exec_start t0 — create контейнера миграции
rollout during t0 destroy последней старой реплики (как окно ошибок rollout.analyze)
rollout after тот же destroy отправка последнего запроса
  • failover: окна совпадают с окнами ошибок failover.analyze.
  • rollout: during и after — те же, что окна ошибок. Окно ошибок «до» делится на before и prepare. Иначе проверки скрипта и сборка из кэша (последние 1–3 с до t0) попали бы в установившееся «до» и в CPU на запрос.
    • Начало подготовки берётся из потока событий проекта: в фильтр Stand.project_events добавляется event=exec_start (Context, п. 2). Оркестратор во время нагрузки docker exec не делает, k6 — вне проекта. Поэтому первое exec_start проекта после первого запроса — скрипт.
    • Существующий разбор от этого не меняется: start_time и container_event ищут действия по точному имени.
    • Не нашлось — prepare пусто, before кончается на t0, в сводке пометка.
    • Хвост скрипта после destroy — ожидание ухода адреса и ready слота, несколько обращений к LB. Он остаётся в after: доли миллисекунды CPU LB на фоне ~95 с окна.
  • Опорная точка шкалы — действие (failover) или t0 (rollout). Это та же точка, что у timeline.csv. t_s посекундной таблицы — конец интервала отсчёта в секундах от неё.

5. Агрегаты окна

Для каждого компонента и окна [w0, w1):

  • CPU-секунды — сумма приростов интервалов. Интервал, который пересекает границу, делится пропорционально длине. Окна уровня «4» короткие (2–20 с), отсечение по целым интервалам дало бы ошибку до 10 %.
  • Среднее CPU = CPU-секунды / (w1 − w0), то есть по всему окну, а не по времени жизни контейнера:
    • суммы по компонентам складываются;
    • остановленная реплика честно показывает ~0;
    • сколько секунд окна контейнер работал — отдельное поле present_s с пометками partial и absent.
  • Посекундный максимум — наибольшее значение интервалов, чей конец внутри окна.
  • Пик памяти — наибольший memory.current отсчётов внутри окна.
  • Доля троттлинга — Δnr_throttled / Δnr_periods. Ожидание CPU — Δ PSI some total / длина окна.
  • api-total — сумма по репликам: CPU-секунды и среднее складываются. Пик памяти — наибольшая по тикам сумма memory.current реплик: у rollout на пике работают три реплики.
  • ВМ — Δ(занято jiffies) / 100 / длина окна, посекундный максимум, ожидание CPU ВМ.
  • Успешных в секунду — успешные запросы фазы с отправкой в окне, делённые на его длину.

Роли.

  • failover: api-target (реплика фазы), api-other, api-total, postgres, haproxy, valkey, k6, sampler, vm.
  • rollout: api-old (ID из containers_before), api-new (containers_after), api-total, migrate, postgres, haproxy, valkey, k6, sampler, vm. Реплика вне обоих списков — api; в успешном прогоне её нет.

6. CPU на успешный запрос — только в установившихся окнах

Где считается.

  • failover, before: обе реплики в LB, ошибок нет, процессы не запускаются и не останавливаются.
  • rollout, before и after: две реплики одной версии, скрипт не работает.

Формула — CPU компонента × 10⁶ / успешных в секунду. Считается для всех компонентов, включая k6 и ВМ.

Где не считается и почему.

  • failover, down:

    • pause — половина запросов ждёт 504 10 с, CPU тратится на соединения и ожидание;
    • stop / kill — LB ждёт timeout connect 0,5 с и повторяет запрос, у stop ещё идёт graceful shutdown.

    Делитель — успешные — не связан с этой работой.

  • failover, after: запуск процесса (импорт, uvicorn, пул) — разовая цена отказа. На запрос она выглядела бы как подорожание сервиса.

  • rollout, prepare и during: сборка, миграция, старт третьей реплики, дренаж и остановка — цена процедуры, а не запросов.

В этих окнах показываются абсолютные числа: среднее, максимум, CPU-секунды. Сводка называет причину пустой ячейки.

С числами трека 1 CPU на запрос не сравнивается напрямую: другая смесь (50/50 запись/чтение против 70/20/10) и другой читаемый чат (1 000 против 10 000). В отчёте это сказано.

7. Файлы, паспорт, сводка, вывод

samples.csv — посекундно, только интервалы, чей конец внутри нагрузки фазы:

phase, window, t_s, role, instance, cpu_cores, throttled_ms, pressure_ms, mem_mib
  • window: warmup, before, down, after у failover; warmup, before, prepare, during, after у rollout;
  • instance — id12, у реплики это её X-Instance-Id; у vm пусто;
  • phase — 01-stop-r1 и т. п.; у rollout — rollout.

Поля в духе scaling.SAMPLE_FIELDS. Таблица своя: каталоги и смысл t_s разные.

resources.csv — строка на фазу × окно × компонент:

phase, mode, window, start_s, end_s, seconds, role, instance, present_s,
cpu_mean_cores, cpu_max_cores, cpu_seconds, throttled_ratio,
pressure_share, mem_peak_mib, ok_rps, us_per_ok_request, flags
  • start_s / end_s — от опорной точки;
  • flags: absent, partial, no_samples;
  • us_per_ok_request пусто вне установившихся окон.

phases.csv, timeline.csv, rollout.csv, replicas.csv не меняются: их столбцы сравниваются с baseline.

meta.json:

  • limits.sampler — лимиты, прочитанные у контейнера;
  • resources.mode = scan;
  • resources.interval_s;
  • resources.budget — сумма лимитов CPU и памяти на пике, число реплик на пике, CPU и память ВМ, генератор «без лимита»;
  • resources.containers — id12 → имя и роль;
  • resources.unmapped;
  • у rollout — rollout.script_start_at.

summary.md. В шапке строка лимитов дополняется: «сэмплер 0,25 CPU / 128m, k6 без лимита».

  • failover:
    • после таблицы фаз — раздел «Ресурсы по фазам». Строка — фаза × окно. Столбцы: API всего, цель, вторая (CPU ср. / макс.; пик МиБ), PostgreSQL, HAProxy, Valkey, k6, сэмплер, ВМ, успешных в секунду;
    • таблица «CPU на успешный запрос до действия» по фазам и компонентам;
    • абзац определений и причина пустых ячеек;
    • в разделе каждой фазы — таблица «компонент × окно» с ячейкой ср. / макс. ядер; пик МиБ (присутствовал N с).
  • rollout: раздел «Ресурсы по окнам замены»:
    • строки — каждая старая и новая реплика с ID, миграция, API всего, PostgreSQL, HAProxy, Valkey, k6, сэмплер, ВМ;
    • столбцы — before, prepare, during, after;
    • таблица CPU на запрос before / after;
    • определения.

Разметку рисуют resources.render_failover / render_rollout. Их вызывают failover.render_summary и rollout.render_summary (новый необязательный аргумент), так что прежние метки рендерятся как раньше.

Вывод в терминал после фазы — строка ресурсов: API всего, цель, PostgreSQL и ВМ по трём окнам, сэмплер. У rollout — то же по четырём окнам.

8. Бюджет ВМ и лимиты

  • level4_budget(profile, vm_cpus, vm_memory) — CPU и память на пике:
    • реплик на пике replicas (+ 1 у rollout);
    • плюс PostgreSQL, LB, Valkey, сэмплер;
    • плюс генератор, если у него есть лимит (здесь нет).
  • В main(), как у серий: сумма CPU больше NCPU ВМ — сообщение и код 2 до стенда. Иначе бюджет — в meta.resources.budget. Сейчас 5,75 и 6,75 из 12.
  • vm_warnings: у профилей с sample_resources учитываются память сэмплера и у rollout replicas + 1 реплик (3,0 GiB + 1,5 GiB запаса при 7,7 GiB — без предупреждения).
  • k6 без лимита: его CPU и пик памяти теперь в таблицах. В отчёте сумма лимитов плюс измеренный k6 сравнивается с 12 vCPU.

9. Наблюдатель не меняет то, что меряет

  • Нагрузка, фазы, окна, лимиты стенда, пороги и k6 — те же. Новое в Profile — только sample_resources. Поля сэмплера уже были (в паспорте baseline их нет: они появились позже, с сериями). Проверка — сравнение meta.profile и meta.limits новой метки и baseline в evidence. Различия допустимы только в полях наблюдения и в полях, добавленных после baseline.

  • Стенд от сэмплера ничего не получает:

    • ни соединений, ни запросов к PostgreSQL и LB (решение 1);
    • ни процессов в контейнерах стенда;
    • ни событий Docker в фазах.

    Его CPU — в своей cgroup под лимитом 0,25 и отдельной строкой sampler. В занятых ядрах ВМ он виден, вычитается по таблице.

  • Режим list серий — те же psql и опрос LB, что раньше. Оценка по данным трека 1 (Context, п. 4): ≤ 0,8 % CPU PostgreSQL при 250/с, меньше при большей интенсивности. В отчёт трека 1 она не идёт: change его не касается.

  • Доступность новых меток ставится рядом с baseline (решение 10). Это проверка «то же поведение», а не A/B сэмплера: различаются ещё код и сессия хоста (Context, п. 6). Отдельный A/B «с сэмплером / без» отвергнут. Один прогон на фазу — 0–4 ответа 502 гонки keep-alive в фазах stop / kill от прогона к прогону (keep-alive.md, самопроверки). Влияние сэмплера, который не трогает стенд, на этом фоне не различить.

10. Метки, порядок, сравнение с baseline

  • Метки: evidence/failover/resources/ (make bench_failover FAILOVER_LABEL=resources) и evidence/rollout/resources/ (make bench_rollout ROLLOUT_LABEL=resources). baseline остаются: это доказательства своих change и прежних строк отчёта.

  • Порядок — правило bench.md, «Измеренное состояние — commit»:

    1. код и правило стенда, make lint, самопроверки модулей;
    2. commit кода;
    3. быстрые профили на чистом дереве;
    4. проверка хоста, затем bench_failover, commit метки;
    5. проверка хоста, затем bench_rollout, commit метки;
    6. evidence, отчёт и документы, commit.

    В этом режиме коммиты делает агент apply без подтверждения (бриф основной сессии): английский conventional style, строка Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>.

  • Проверка хоста перед каждым полным замером. Плохо — замер не запускается, apply останавливается и отдаёт отчёт основной сессии.

    • питание от сети (pmset -g batt);
    • давления на память нет, свободной памяти хватает на 7,7 GiB ВМ (memory_pressure);
    • посторонних контейнеров нет: make stop, затем docker ps;
    • Swapouts (vm_stat) до и после;
    • Zoom не запущен (pgrep -x zoom.us);
    • средняя нагрузка за 5 мин < 8 (LC_ALL=C sysctl -n vm.loadavg);
    • Spotlight утих: mds, mds_stores, mdworker* < 15 % CPU в ps -Ao %cpu,comm;
    • ВМ — 12 CPU (docker info).

    Условия Zoom, нагрузки и Spotlight — опыт попытки 2 трека 1 (design архива scaling-improvement, «Найдено в apply», п. 3).

  • Сравнение с baseline — таблица рядом, числа из phases.csv / rollout.csv / replicas.csv обеих меток:

    • failover, по фазе: исключение LB (граница), причина, ошибки в окне отказа с кодами, минимальная доля успешных, восстановление, p95 до / максимум в окне, возврат в LB, ошибки после возврата, повтор и сверка, пометки;
    • rollout: замена, ошибки до / во время / после, минимальная доля, p95, первый ответ новой и последний старой, ответы старых после дренажа, шаги, сверка.

    Сравнение — по классу результата. Один прогон: 0–4 ответа 502 гонки keep-alive в фазе stop / kill — разброс, а не расхождение (keep-alive.md, rolling-update-checks.md).

    Расхождение:

    • ошибки там, где у baseline их не было, кроме этих 502;
    • пометки over_bound, no_lb_out, no_lb_up, dropped;
    • восстановление stop / kill > 1 с, pause > 7 с;
    • ошибки после возврата;
    • у rollout любая ошибка или ответ старой после дренажа;
    • шаг замены вдвое дольше.

    Расхождение описывается в отчёте с причиной или пометкой «причина не установлена». Если нарушено требование load-balancing — обнаружение выше формулы, восстановление > 10 с, ошибки после возврата, ошибки при плановой замене, — apply останавливается с вопросом до отчёта: это уже не наблюдение, а поведение стенда.

11. Документы и отчёт

  • REPORT.md правит apply. Основная сессия правит его параллельно, поэтому перед правкой — свежий Read.
    • Шапка: change в списке «Сделано по changes»; фразу «после clean clone менялись только документы» уточнить — изменился стенд bench/, код приложения, compose и скрипты — нет.
    • Сводная таблица «Эксперименты и отказы»:
      • «Лимиты» — сэмплер 0,25 CPU / 128 МиБ у failover и rollout;
      • «CPU / RAM» — измеренные числа: API на реплику до действия, выжившая в окне отказа (ср. / макс.), перезапуск, PostgreSQL, LB, k6, ВМ; пики памяти; CPU на запрос до действия; у rollout — окна и три реплики на пике;
      • «Файлы» — метки resources.
    • Абзац о проверке хоста — Swapouts новых меток.
    • Разделы «Отказ каждой реплики под нагрузкой» и «Поочерёдная замена под нагрузкой» — подраздел «Ресурсы (change profile-resources)»:
      • методика: режим scan, окна, определения, правило CPU на запрос, бюджет;
      • таблица по окнам;
      • сравнение доступности с baseline;
      • накладные расходы наблюдателя;
      • вывод: запас до лимитов, цена отказа и замены;
      • ограничения.
    • Таблица доказательств — строки уровня «4» про профили дополняются метками resources.
    • «Ограничения и следующие шаги» — по факту, например «CPU/RAM уровня 4 — один прогон».
  • .claude/rules/bench.md:
    • таблица инструментов: resources.py, sampler.sh;
    • разделы профилей: сэмплер, окна, файлы;
    • «Что не меняется между метками»: сэмплер у профилей уровня «4»;
    • раздел серий: режим list против scan.
  • AGENTS.md:
    • вступление: change в списке;
    • таблица команд: bench_failover, bench_rollout;
    • карта кода: bench/resources.py, sampler.sh, run.py, каталоги меток evidence/failover/<метка>/ и evidence/rollout/<метка>/ с samples.csv и resources.csv, evidence/tests/profile-resources-checks.md.
  • Makefile — комментарии целей bench_failover и bench_rollout. Цели skeleton не трогаются.

12. Регрессия

  • Код приложения, compose, Dockerfile, scripts/ не меняются. Поэтому make test, make student_test, make test_isolated и make failure_checks не перезапускаются. В evidence — git diff --stat <до> <после> -- src Dockerfile docker-compose.yml scripts infra pyproject.toml uv.lock пуст.

  • Стенд bench/:

    • make lint;
    • uv run python bench/resources.py --selftest и uv run python bench/scaling.py --selftest;
    • bash -n bench/sampler.sh;
    • все быстрые профили на закоммиченном коде: bench_quick, bench_restore_quick, bench_failover_quick, bench_rollout_quick, bench_scaling_quick.

    Серии — тот же сэмплер в режиме list, их проверка обязательна. make check — для Makefile.

  • Сторож — быстрый failover, посреди первой фазы docker rm -f mtusi-bench-sampler: код ≠ 0, причина называет фазу, стенд убран (сценарий «Наблюдатель остановился»).

  • Самотест resources.py (синтетические строки):

    • непрерывный контейнер;
    • stop → пропуск тиков → start со сбросом: CPU после запуска — в окне возврата, в окне отказа ~0;
    • пауза — 0;
    • новая реплика с первого тика после запуска: CPU от момента запуска;
    • деление интервала на границе окна;
    • ложный пропуск без сброса — продолжение;
    • немаппированный ID отброшен и посчитан;
    • api-total и пик суммарной памяти;
    • ВМ;
    • CPU на запрос только в установившихся окнах.

Risks / Trade-offs

  • [Разрешение 1 с] → CPU остановки после последнего отсчёта (≤ 1 с работы процесса) не виден. Первый интервал новой cgroup без события запуска делится от предыдущего тика. Контейнер, живший меньше интервала, может не попасть ни в один тик: миграция живёт ~2 с (baseline: «миграция 2 с»). Пусто — пометка absent, а не ноль. Окна 2–20 с. Чаще 1 с сэмплер не опрашивает: так же, как у серий.
  • [memory.current — память cgroup, а не RSS] → в ней страничный кэш файлов: у PostgreSQL — данные и WAL, у k6 — скрипты. Пик — по отсчётам раз в секунду, короткий всплеск между ними не виден. В отчёте — как «память cgroup (пик по отсчётам)». Это тот же счётчик, что у серий и у лимита OOM.
  • [Обход cgroup читает и чужие контейнеры] → только счётчики, строки отбрасываются по отображению, лог сэмплера — в .work/, а он удаляется. Замер для отчёта всё равно без посторонних контейнеров.
  • [Отображение ролей пропустит контейнер, созданный и удалённый между снимками] → у rollout добавлены create из потока событий. В успешном прогоне таких нет. Иначе — unmapped в паспорте.
  • [Граница prepare зависит от того, что скрипт первым делом обращается к LB] → так устроены его предусловия: первая проверка — lb "show info" через docker compose exec -T haproxy. Нет события — пустое окно и пометка, а не сбой.
  • [k6 без лимита] → его CPU теперь виден. Если он возьмёт заметную долю ВМ, это строка таблицы, а не скрытая помеха. Пропуски итераций по-прежнему пометка dropped.
  • [Один прогон на фазу и одна замена] → поведение и порядок величин, а не распределение. Так в отчёте и сказано.
  • [Сравнение с baseline смешивает код, сессию хоста и наблюдателя] → решение 9: классы результата и названные различия, без вывода о влиянии сэмплера по одному прогону.
  • [Сторож роняет прогон при пропуске отсчётов] → за ~6 мин полного профиля метка без ресурсов бесполезна. Повтор прогона дешевле. Серии на том же сэмплере часами не теряли отсчёты.
  • [Пропорциональное деление считает CPU равномерным внутри интервала] → внутри одной секунды, при окнах 2–20 с и отдельной посекундной таблице.

Migration Plan

  • Метки baseline и их строки в отчёте остаются. Новые метки добавляются рядом, сравнения меток уровня «4» командой нет.
  • Прежние каталоги меток рендерятся как раньше: аргумент ресурсов у render_summary необязателен, файлов samples.csv / resources.csv у них нет.
  • Откат — git revert commit кода. Метки resources остаются доказательством commit, на котором сняты.

Найдено в apply

  1. Проверки здоровья дают exec_start (решение 4). PostgreSQL, Valkey и HAProxy стенда проверяются раз в 5 с через docker exec, и эти события приходят в поток проекта (docker events --filter event=exec_start на рабочем стенде: /bin/sh -c pg_isready …, bash -c exec 3<>/dev/tcp/127.0.0.1/8404 …, /bin/sh -c test "$(valkey-cli …)"). Предпосылка «первое exec_start проекта после первого запроса — скрипт» неверна. Поправка: rollout.script_start(events, since, ignore) отбрасывает действия проверок здоровья; их строит Stand.healthcheck_actions() из Config.Healthcheck.Test работающих контейнеров (CMD-SHELL → /bin/sh -c <команда>, CMD → аргументы через пробел — так их пишет Docker). В метках начало подготовки — запуск скрипта (через 15 с после первого запроса).
  2. Заморозка и пропорциональное деление (решения 3, 5). Первый полный failover (6505b5e) дал у pause в окне отказа 0,011–0,012 ядра и посекундный максимум 0,76–0,81: интервал, задевающий pause, нёс работу до неё, а задевающий unpause — всплеск после неё, и деление по длине относило их доли к окну отказа. Поправка 2d267bf (resources.thaw): CPU такого интервала относится к незамороженной части (моменты — события Docker), присутствие считается по всему интервалу. Метка переснята, первый прогон отброшен.
  3. Посекундный максимум (решение 5) — по всем интервалам, задевающим окно, а не только с концом внутри: иначе в коротком окне среднее с долями граничных интервалов выходило больше максимума.
  4. «Контейнер был» и «контейнера не было» (решение 5, Risks). Остановленная реплика в окне отказа — CPU 0 и пометка absent (контейнер известен по другим окнам); контейнер, не попавший ни в один отсчёт за прогон, — пустые значения и absent. Окно нулевой длины (начало подготовки не найдено) — пометка empty.
  5. sampler.sh: каталог пропал посреди чтения. Раньше получалась строка нулей (usage_usec 0 похож на сброс); теперь чтение молча, и пустые usage_usec или memory.current дают missing. Касается и режима list, но там контейнеры посреди ячейки не пропадают.
  6. Первый интервал после запуска завышен (Risks, разрешение 1 с). Счёт новой cgroup идёт с её создания, а начало интервала — событие start, оно чуть позже: реплика после docker start — до 1,06 ядра при лимите 1, у миграции интервал в доли секунды — 1,52 при лимите 0,5. В отчёте — ограничение.
  7. Хост между прогонами (решение 10). После каждого прогона давление на память хоста доходило до уровня 2, и Swapouts росли, пока система освобождала память; перед замером ждали уровня 1, свободной памяти ≥ 50 % и неизменных Swapouts. Первый полный rollout (309a00d) всё равно выгрузил 7 236 страниц (замена 12,0 с, p95 337 мс) и отброшен; повтор после закрытия приложений пользователя — без выгрузки.
  8. Фаза 06-pause-r2 метки failover/resources. В первые ~6 с окна «до» — всплеск у всех компонентов сразу (ВМ до 4,3 ядра), p95 до действия 729 мс без ошибок, swap 0. Причина не установлена; по решению основной сессии метка не переснималась, в отчёте фазы 1–5 и 06 — отдельно.