Files
mtusi2026lab6/REPORT.md
T
ricoromaandClaude Opus 5.5 db3340d811 bench: capture uploads and queue labels with telemetry on
make bench_uploads TELEMETRY=on (label baseline) and make bench_queue
TELEMETRY=on QUEUE_LABEL=baseline4 on b3a5ab8 for the coverage
exclusions; record last-step decisions and draft report sections.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 09:33:17 +03:00

1151 lines
141 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## Архитектура и решения
```text
клиент → HAProxy (127.0.0.1:8080) → api × 2 ──┬─ PostgreSQL (источник истины: метаданные, задания = outbox с контекстом W3C, варианты)
│ /metrics :8404 ├─ Valkey (кэш карточек чатов)
│ └─ S3: <база>/staging/<id>/original
relay → PostgreSQL (намерения, снимок очереди раз в 5 с) → RabbitMQ (заголовки traceparent / tracestate)
worker → PostgreSQL + S3 (оригинал и три варианта; процесс обработки на задание)
cleaner → PostgreSQL + S3 (pending, staging, сверка)
api, worker, relay ──OTLP/HTTP protobuf :4318──▶ otel-collector (сети default и telemetry)
otel-collector ◀─scrape haproxy:8404/metrics │ memory_limiter → batch → очереди экспорта по байтам
├─▶ prometheus (scrape :8889 экспортёра; правила записи и оповещения)
├─▶ loki (OTLP /otlp)
└─▶ tempo (OTLP :4318)
grafana (127.0.0.1:3000) → prometheus, loki, tempo — сеть telemetry, provisioning из git
```
**Источник истины и транзакционные границы — как в лабе 5** (раздел «Архитектура и решения»
`REPORT.md` репозитория `mtusi2026lab5-safronov`): PostgreSQL — данные, сессии, ключи идемпотентности и
задания; загрузка — строка `pending` → PUT в staging → `queued` с заданием одной транзакцией → 202;
relay публикует намерения с подтверждением, worker фиксирует результат с fencing; единица работы
(`async with self.uow:`, один блок — одна транзакция) во всех процессах. Бизнес-API не менялся:
`contracts/openapi.json` лабы 6 отличается от лабы 5 только `info`, `tests/` совпадают.
**Перенесено из лабы 5 без изменения поведения:** вход Basic → Bearer-сессия (Argon2id, SHA-256 токена),
кэш карточек, ≥ 2 реплики без состояния за HAProxy, идемпотентность сообщений, `make rolling_update`,
приватный S3 с пользователями API, уборщика и worker, места загрузки и предел незавершённых заданий,
уборщик и сверка, брокер, relay, worker, replay. Код перенесён commit `9cc6c0c` (источник —
`mtusi2026lab5-safronov`, `046ec9e`), список и найденное при переносе — `QUESTIONS.md`, «Перенос из
лабы 5».
**Изменено в лабе 6** — четыре change OpenSpec (`openspec/changes/archive/`):
| Change | Уровень | Что добавлено | Изменение схемы и процессов |
| --- | --- | --- | --- |
| `otel-telemetry` | 3 | SDK в API и worker (`src/infra/telemetry/`, секция `[telemetry]`), Collector contrib, Prometheus, Loki, Tempo и Grafana в compose (`infra/otel/`), сигналы уровня 3, dashboard из provisioning, исправлен первый старт брокера на пустом volume | схема та же; пять новых сервисов, сеть `telemetry` |
| `job-trace-propagation` | 4 | контекст W3C загрузки в задании, SDK в relay, span producer и consumer (parent и link), время до `ready`, очередь и возраст, пул БД, насыщение worker, CPU и память из cgroup | ревизия `e4b8c2d17f90`: `attachment_jobs.traceparent`, `tracestate` (`NULL`, CHECK `NOT VALID`) |
| `slo-alerts` | 4 | SLI / SLO, правила записи и семь оповещений Prometheus с тестами и runbooks, метрики HAProxy, очереди экспорта Collector по байтам, учёт потерь, внутренние метрики SDK | схема та же; `/metrics` на порту статистики LB |
| `track1-telemetry-cost` | 5 | выбор трасс в голове и наборы границ histogram (`trace_sample_ratio`, `metric_buckets`), счёт начатых span, профиль `make bench_telemetry`, выключатель `TELEMETRY=on` профилей загрузок и очереди, сбалансированная конфигурация `bench/otel/` | схема та же; значения по умолчанию — прежнее поведение |
Телеметрия не в пути запроса: приложение стартует и отвечает без Collector и хранилищ
(`evidence/telemetry/collector-outage.md`, `evidence/telemetry/backend-outage.md`), экспорт — фоновые
потоки SDK с ограниченными очередями. Сервис не импортирует SDK: span и метрики пишут точки входа,
middleware и клиенты инфраструктуры (`src/infra/telemetry/`), контекст задания передаёт в сервис
зависимость API (`TraceContextDep`). Устройство сигналов — раздел «Наблюдаемость».
### Сервисы стенда и лимиты
| Сервис | Роль | CPU | Память | Порт на хосте |
| --- | --- | --- | --- | --- |
| `haproxy` | LB, единственная публичная точка; `/metrics` только для Collector | 1 | 256 МБ | `127.0.0.1:8080` |
| `api` × 2 | приём, без состояния, SDK | 1 на реплику | 512 МБ на реплику | нет |
| `relay` | публикация намерений, снимок очереди, SDK | 0,25 | 256 МБ | нет |
| `worker` | обработка, SDK | 1 | 1 ГБ | нет |
| `cleaner` | незавершённые загрузки, staging, сверка; без SDK | 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 | 1 | 512 МБ | loopback 5673 |
| `otel-collector` | приём OTLP, scrape LB, маршрутизация | 0,5 | 256 МиБ | нет |
| `prometheus` | метрики, правила, volume | 0,5 | 384 МиБ | нет |
| `loki` | журналы, volume | 0,5 | 512 МиБ | нет |
| `tempo` | трассы, volume | 0,5 | 640 МиБ | нет |
| `grafana` | интерфейс, tmpfs | 0,5 | 512 МиБ | `127.0.0.1:3000` |
| `migrate`, `s3-bootstrap` (разовые) | миграции; bucket и пользователи | 0,5 / 0,5 | 256 / 128 МБ | нет |
Сумма постоянных лимитов — 11,5 CPU / 7296 МиБ, с разовыми 12,5 CPU / 7680 МиБ; ВМ Docker Desktop —
12 CPU / 11 902 МиБ (раздел «Наблюдаемость», «Бюджет»). Соединения PostgreSQL —
`API_REPLICAS × 10 + migrate 1 + cleaner 1 + worker 2 + relay 1` = 25 при двух репликах,
`max_connections` 100.
### Соответствие переменных `.env.example`
Имена лаб 1–5 — без изменений (таблицы — отчёты лабы 4, «Соответствие переменных», и лабы 5,
«Соответствие переменных `.env.example`»): `APP_HOST`, `APP_PORT`, `APP_ENV` → `[app]`,
`SESSION_TTL_SECONDS` → `[auth] session_ttl_seconds`, `DATABASE_URL_FILE` и `CACHE_URL_FILE` → мосты из
`POSTGRES_*` и `VALKEY_*`, `SESSION_STORE` — PostgreSQL, `API_REPLICAS` — compose и Makefile,
`IDEMPOTENCY_TTL_SECONDS` → `[idempotency] ttl_seconds`, `S3_*` → `S3__*` и `[s3]`, `MAX_UPLOAD_BYTES`
и `MAX_IMAGE_PIXELS` — константы контракта, `BROKER_URL_FILE` → мосты `RABBITMQ_*`,
`WORKER_CONCURRENCY`, `JOB_MAX_ATTEMPTS`, `JOB_TIMEOUT_SECONDS` → `[worker]`,
`STAGING_RETENTION_SECONDS` → `[cleaner] staging_retention_seconds`. Новые имена лабы 6 — `OTEL_*`:
таблица раздела «Наблюдаемость», «Ресурс и имена `OTEL_*`» (настройками не являются, источник —
`[telemetry]` и константы точек входа). Свои переменные compose: `GRAFANA_ADMIN_PASSWORD` (случайный
от `make env_setup`, только у сервиса `grafana`) и `GRAFANA_OUT_PORT` (3000).
### Согласования с преподавателем
| Дата | Договорённость | Где учтено |
| --- | --- | --- |
| 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 при запуске | `.claude/rules/settings.md`, `.claude/rules/docker.md` |
| 2026-10-20 | Лаба 4: «пустой текст» сообщения — и `""`, и текст только из пробельных символов; допустим только с вложением | спек `messages`, `.claude/rules/api-contract.md` |
Новых договорённостей в лабе 6 нет. Расхождения FastAPI, разрешённые согласованием: 422 переведён в
400; битый JSON — 400 раньше 401, остальная валидация — после зависимостей.
### Открытые вопросы преподавателю
Контракт допускает несколько трактовок, ответа пока нет; сделан названный вариант, подход от ответа
не зависит. Решения без пользователя и вопросы пользователю — `QUESTIONS.md`.
**Новые в лабе 6:**
1. **Класс статуса HTTP** («method, route template, status class»): выводится из кода статуса в
запросах (`http_response_status_code=~"5.."`), отдельной метки нет. Иначе — атрибут
`http.response.status_class` в middleware и в запросах dashboard.
2. **Restart hook и телеметрия.** `scripts/restart.sh` перезапускает API и хранилища бизнес-данных,
но не хранилища телеметрии; сохранность истории телеметрии после их рестарта показана отдельно
(`evidence/telemetry/check.md`). Иначе — строка в `scripts/restart.sh`.
3. **`service.version`** — версия контракта `1.6.0`, а не ревизия сборки. Иначе — аргумент сборки
образа.
4. **Необычный метод.** Сценарий «Необычный метод и неизвестный путь» проверен на `PROPFIND`: `BREW`
uvicorn отклоняет до приложения (400 текстом, `KNOWN_ISSUES.md`). Иначе — `http="h11"` у uvicorn или
правило HAProxy.
5. **Время до `ready`** считается от записи задания (та же транзакция, что `queued`, до ответа 202) до
фиксации `ready`; задания после replay не учитываются. Иначе — время replay из аудита
`attachment_job_replays`.
6. **CPU и память процессов** — только у процессов с SDK (реплики, worker вместе с процессами
обработки, relay) из их cgroup; PostgreSQL, S3, брокер, LB и уборщик не представлены: сокет Docker у
Collector — root на ВМ. Иначе — `docker_stats` или cAdvisor с названной ценой.
7. **Queue depth** — логическая очередь заданий по стадиям из PostgreSQL (outbox, отложенные повторы, в
брокере, в обработке), а не счётчик очереди RabbitMQ. Иначе — плагин `rabbitmq_prometheus` и доступ
к брокеру из сети телеметрии.
8. **SLI доступности** считается по ответам клиентам на LB (вместе с 502, 503, 504 самого LB), а «доля
ошибок» контракта (5xx API / бизнес-запросы без health) — отдельная панель. Иначе — SLI по метрикам
API с отдельным счётом ответов LB.
9. **Трек 1: достаточно ли трёх настроек** (выбор в голове 10 %, типовой tail sampling, агрегация
метрик) и проверенной сбалансированной конфигурации на одной нагрузке ниже насыщения? Иначе — вторая
интенсивность (ещё одна метка ~1 ч 50 мин).
10. **Трек 1: управляемые воздействия.** «Известное число» редких ошибок и медленных запросов внесено
строкой вложения без объекта (500), недекодируемым JPEG (`failed`), регистрацией и короткой
блокировкой таблицы сообщений. Допустимо?
**Перенесены из лаб 4 и 5, ответа нет** (разбор — отчёт лабы 5, «Открытые вопросы преподавателю»):
занятые места загрузки и предел незавершённых заданий — 429, а не 503; потерянный по сверке оригинал —
метаданные 200, байты 404, ссылка 201; повтор сообщения, чьё вложение стало `failed` после отправки, —
201 с тем же `Message`; ориентация и альфа у `crop` и `optimized`; replay — команда `make replay`, а не
HTTP-ручка; изображение вне лимитов обработки — `invalid_image`; удаление объектов неудачной попытки по
сроку хранения; срок приёма при остановленном worker — до предела 250; изоляция `/proc/1/environ` от
процесса обработки (`PR_SET_DUMPABLE=0` не сделан).
### Ответы на вопросы защиты
**Чем лог, метрика и trace отвечают на разные вопросы об одном инциденте?** Метрика — «сколько и
насколько плохо и с какого момента»: доля 5xx, p99, возраст старейшего задания по времени; она дешёвая,
агрегированная и годится для оповещения, но не называет конкретный запрос. Трасса — «где ушло время и
что упало в этом запросе»: какой дочерний span (PostgreSQL, S3, процесс обработки) занял время или
вернул ошибку, и как связаны API, relay и worker одной загрузки. Лог — «что именно произошло и почему»:
запись с `request_id`, причиной отказа, кодом ошибки задания и traceback, которых нет в метрике и не
должно быть в атрибутах span. Переходы: оповещение по метрике → панель → трассы окна (TraceQL по
длительности или ошибке) → `trace_id` → записи журнала в Loki и обратно. Разбор двух инцидентов этим
путём — раздел «SLO, оповещения и инциденты».
**Почему `chat_id` в labels может исчерпать хранилище?** Каждое сочетание значений labels — отдельный
ряд Prometheus со своей памятью в head-блоке, индексом и чанками. У histogram длительности HTTP с 12
границами это 15 рядов на сочетание (13 buckets с `+Inf`, `_sum`, `_count`); `chat_id` умножает их на
число чатов, и оно растёт без предела вместе с данными: миллион чатов — 15 млн рядов только у одной метрики, память и индекс TSDB растут линейно, запросы `sum by` по
ним медленнеют. Поэтому идентификаторы (`user_id`, `chat_id`, `message_id`, `attachment_id`,
`request_id`) — только атрибуты span и поля записей журнала, а labels метрик — маршрут-шаблон, метод,
код статуса, исход задания (проверка — `telemetry-check`, запрет атрибутов — правило `telemetry.md`).
**Как очередь переносит причинную связь между процессами?** Контекст W3C (`traceparent`, `tracestate`)
— данные рядом с сообщением. Здесь между API и брокером ещё outbox: реплика сохраняет контекст своего
server span в строке задания той же транзакцией, что `queued`; relay при каждой публикации создаёт span
producer дочерним к сохранённому контексту и кладёт его контекст в заголовки AMQP; worker извлекает
контекст из заголовков и делает consumer span дочерним к нему и с link на него. Получается одна трасса
на загрузку, включая повторы и replay — новые пары producer / consumer в той же трассе. Выбор parent и
link и его цена — раздел «Сквозная трасса загрузки».
**Почему среднее latency не заменяет p99 и почему нельзя усреднять p99 реплик?** Распределение задержек
с длинным хвостом: среднее почти не двигается, когда 1 % запросов становится в десять раз медленнее, а
p99 показывает именно этот хвост, который видит каждый сотый клиент. Квантиль нелинеен: p99 двух реплик
по отдельности не складывается в p99 их суммы — реплика с 10 запросами и p99 2 с и реплика с 10 000
запросами и p99 50 мс дают среднее p99 ~1 с при настоящем p99 около 50 мс, и наоборот, хвост реплики с
большим трафиком прячется. Поэтому dashboard считает `histogram_quantile(q, sum by (le) (rate(…_bucket[5m])))`
— сначала сумма buckets всех реплик, потом квантиль; точность ограничена границами buckets (раздел
«Сигналы уровня 4»; у набора `coarse` трека 1 квантили вдвое грубее).
### Сценарий защиты
1. **С нуля, provisioning, smoke и нагрузка.** `make run_docker` на пустых volumes (проверено командой
`driver.py stand-from-scratch --runs 2`, `evidence/stand/from-scratch.md`, и из чистого clone,
`evidence/tests/clean-clone.md`), Grafana `http://127.0.0.1:3000` — источники и dashboard «Messenger
overview» уже на месте, `make test`, `make load`.
2. **Свежие метрики, трасса и лог своего приложения.** `driver.py --port 8080 telemetry-check`
(`evidence/telemetry/check.md`): запрос со своим `X-Request-Id` → запись в Loki → `trace_id` → трасса
в Tempo; загрузка → трасса и запись worker.
3. **Для 4.** `driver.py --port 8080 trace-chain` (`evidence/telemetry/trace-chain.md`): одна трасса
загрузки с повтором и replay; `driver.py --port 8080 alerts-check` (`evidence/alerts/check.md`):
остановленный worker → `MessengerQueueLagHigh` firing → снятие; медленная и недоступная БД.
4. **Отказ хранилища телеметрии.** `driver.py --port 8080 telemetry-outage` и `backend-outage`
(`evidence/telemetry/collector-outage.md`, `evidence/telemetry/backend-outage.md`): `make test` PASS,
память Collector и реплик ограничена, потери посчитаны. **Для 5:** `make bench_telemetry_quick
VARIANTS=off,full,tail` (~10 мин, рабочий стенд — `make stop`) и разбор
`evidence/telemetry-cost/baseline2/summary.md`.
## Наблюдаемость
Change `otel-telemetry` (design — `openspec/changes/archive/2026-11-11-otel-telemetry/design.md`,
номера решений в скобках). Числа и проверки сняты на закоммиченном коде при чистом рабочем дереве:
`telemetry-check` и `telemetry-outage` сначала на `68f1e97` (правки verify), затем пересняты на
`72cfa9a` (код change `job-trace-propagation`: relay с SDK, шаги задания по consumer span), там
же план снимка очереди, проба ревизии `e4b8c2d17f90` и раздел change бюджета; `trace-chain` и
`telemetry-outage` — ещё раз на `72e2598` (правки verify: сигналы relay без перезапуска, тихая
очередь в предусловии, рост CPU каждого процесса); `telemetry-check`, `trace-chain` и
`telemetry-outage` — в третий раз на `15ea156` (код change `slo-alerts`: новые панели, метрики LB,
внутренние метрики SDK), там же раздел change `slo-alerts` бюджета; `make alerts_test`,
`alerts-check` и `backend-outage` — на `ef60b47` (правки verify change
`slo-alerts`: ноль ряда потерь процесса SDK, панель потерь в проверках, pending на каждом шаге);
`telemetry-check` — в четвёртый раз на `4a2f9c9` (тот же код приложения и правила, что на `ef60b47`;
драйвер ждёт в Loki все записи прохода relay, а не первую — две попытки на `ef60b47` упали на этой
гонке проверки; панель потерь на тихом стенде — 0); бюджет сервисов телеметрии — на `4178b3d` (лимиты Tempo и Grafana по замеру), шапки файлов
`evidence/telemetry/` и `evidence/migrations/`. `evidence/stand/from-
scratch.md` ещё снят на рабочем дереве поверх `9b35c25`: пересъёмка ждёт разрешения пользователя
(`QUESTIONS.md`, `## otel-telemetry`, вопрос 8).
### Назначение компонентов
| Компонент | Версия (тег, digest индекса — `docker-compose.yml`) | На какой вопрос об инциденте отвечает |
| --- | --- | --- |
| SDK OpenTelemetry Python (`opentelemetry-api`, `-sdk`, `-exporter-otlp-proto-http`) | 1.45.2 (`>=1.45.2,<1.46`), semantic conventions 0.66b2 | производит три сигнала в API и worker; экспорт OTLP/HTTP protobuf в фоне, очереди ограничены |
| OTel Collector, дистрибутив **contrib** | 0.164.0 | получатель и маршрутизатор, а не хранилище: `memory_limiter`, `batch`, три pipeline до трёх хранилищ; contrib — ради `tail_sampling` трека 1 (1) |
| Prometheus | v3.15.1 | **метрика**: «сколько и как быстро» — RPS, доля ошибок, квантили длительности, исходы заданий по времени; scrape экспортёра Collector (3) |
| Loki | 3.7.9 | **лог**: «что именно произошло в этом запросе / задании» — те же записи, что в stdout, поиск по `request_id`, `attachment_id`, `trace_id` |
| Tempo | 3.1.1 | **трасса**: «где ушло время и что упало» — server / consumer span с дочерними PostgreSQL, Valkey, S3 и процессом обработки |
| Grafana | 13.3.1 | интерфейс без своего состояния: источники и dashboard из git, переход лог ↔ трасса (16) |
### Сигналы уровня 3
| Логический сигнал контракта | Инструмент SDK | Prometheus / Loki / Tempo | Единица |
| --- | --- | --- | --- |
| HTTP requests | счёт наблюдений histogram `http.server.request.duration` | `http_server_request_duration_seconds_count{job="messenger-api", http_request_method, http_route, http_response_status_code}` | запросы |
| HTTP duration | histogram `http.server.request.duration`, границы 0,005…30 с (10) | `http_server_request_duration_seconds_bucket` / `_sum` | с |
| jobs (успешные / ошибочные) | счёт наблюдений histogram `messenger.job.duration` | `messenger_job_duration_seconds_count{job="messenger-worker", messenger_job_type, messenger_job_outcome}` | задания |
| job duration | histogram `messenger.job.duration`, границы 0,05…60 с (11) | `messenger_job_duration_seconds_bucket` / `_sum` | с |
| логи с `trace_id` / `span_id` | логгер SDK из процессора structlog (2) | Loki: поток `service_name`, `service_instance_id`, `deployment_environment_name`; поля записи, `trace_id`, `span_id` — structured metadata; строка — `event` | запись |
| трассы API | span `SERVER` `«метод» «шаблон»` (корень), дочерние `SELECT`/`INSERT`/…, `COMMIT`, `GET`/`SET` Valkey, `S3.<Операция>` | Tempo: `messenger.request_id`, `http.*`, `db.*`, `rpc.*`, `error.type` | span |
| трассы worker | span `CONSUMER` `process <очередь>` (корень), дочерние PostgreSQL, S3, `render attachment variants` | Tempo: `messaging.*`, `messenger.job.type`, `messenger.job.outcome` | span |
Запросы панелей dashboard (`infra/otel/grafana/dashboards/messenger-overview.json`, uid
`messenger-overview`, папка Messenger):
- RPS по маршруту и классу статуса: `sum by (http_route, status_class)
(label_replace(rate(http_server_request_duration_seconds_count{job="messenger-api"}[5m]),
"status_class", "${1}xx", "http_response_status_code", "([0-9])..")))`;
- **доля ошибок HTTP** — числитель 5xx API, знаменатель — все учтённые запросы (health не
учитывается, 4xx — отдельная панель того же вида):
`sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[5m]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[5m]))`;
- p50 и p95: `histogram_quantile(q, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m])))`
— из суммы buckets всех реплик, а не средние; p95 по маршрутам — `sum by (le, http_route)`;
- задания по исходу: `sum by (messenger_job_outcome) (rate(messenger_job_duration_seconds_count{job="messenger-worker"}[5m]))`;
**успешные** — `ready`, **ошибочные** — `failed`, `retry`, `requeued`, `dropped`, `error`,
`skipped` — ни то, ни другое (подтверждено без попытки);
- p50 и p95 длительности `ready`: `histogram_quantile(q, sum by (le) (rate(messenger_job_duration_seconds_bucket{job="messenger-worker",messenger_job_outcome="ready"}[5m])))`;
- журналы `{service_name=~"messenger-.*"}` (Loki), поиск трасс `{ resource.service.name =~ "messenger-.*" }` (Tempo).
### Ресурс и имена `OTEL_*`
| Атрибут ресурса | Значение | Prometheus | Loki |
| --- | --- | --- | --- |
| `service.name` | `messenger-api` / `messenger-worker` / `messenger-relay` (константы точки входа) | `job` | метка `service_name` |
| `service.instance.id` | `[app] instance_id` = `X-Instance-Id` (короткий id контейнера) | `instance` | метка `service_instance_id` |
| `service.version` | `1.6.0` — `info.version` контракта (9) | `target_info{service_version}` | `service_version` |
| `deployment.environment.name` | `[telemetry] environment` = `lab` | `target_info{deployment_environment_name}` | метка `deployment_environment_name` |
| Имя skeleton | У нас (8) |
| --- | --- |
| `OTEL_SERVICE_NAME` | константа точки входа: `messenger-api`, `messenger-worker`, `messenger-relay` |
| `OTEL_EXPORTER_OTLP_ENDPOINT` | `[telemetry] otlp_endpoint`; на стенде — `TELEMETRY__OTLP_ENDPOINT=http://otel-collector:4318` у `api`, `worker` и `relay` |
| `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` | постоянно: установлен только экспортёр OTLP/HTTP protobuf |
| `OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab` | `[telemetry] environment`; `service.*` вычисляет код |
| `OTEL_TRACES_SAMPLER` | постоянно `parentbased_traceidratio`, при доле 1 — тот же объект, что `parentbased_always_on` (change `track1-telemetry-cost`, решение 3) |
| `OTEL_TRACES_SAMPLER_ARG` | `[telemetry] trace_sample_ratio` (0…1, по умолчанию 1 — все трассы); набор границ histogram — `[telemetry] metric_buckets` (`default` / `coarse`) |
Переменные `OTEL_*` настройками не являются: процесс с включённой телеметрией удаляет их из
окружения и пишет `warning` с именами (проверка — разовый контейнер с `OTEL_SDK_DISABLED=true` и
чужим адресом в `evidence/telemetry/check.md`). Включает телеметрию `TELEMETRY__ENABLED` у `api`,
`worker` и (change `job-trace-propagation`) `relay` стенда; консоль, `make test_isolated` и стенд
отказов — без неё (20). `bench/` — без неё по умолчанию; с change `track1-telemetry-cost` её включают
варианты профиля цены телеметрии (`make bench_telemetry`) и выключатель `TELEMETRY=on` профилей
загрузок и очереди (раздел «Цена наблюдаемости (трек 1)»).
### Инфраструктура наблюдаемости
| Роль `infrastructure.json` | Сервис | Версия | Healthcheck | Volume | Порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| `otel_collector` | `otel-collector` | contrib 0.164.0 | нет (в образе нет оболочки): цель `otel-collector` в Prometheus | — | OTLP `:4318`, метрики `:8888`, `:8889` — только в сетях стенда | нет |
| `telemetry_storage` (метрики) | `prometheus` | v3.15.1 | `wget /-/ready` | `prometheus_data`, срок 7d, предел 1GB | `:9090` — только сеть `telemetry` | нет |
| `telemetry_storage` (логи) | `loki` | 3.7.9 | нет: цель `loki` и проверка источника | `loki_data`, срок 168h | `:3100` — только сеть `telemetry` | нет |
| `telemetry_storage` (трассы) | `tempo` | 3.1.1 | нет: цель `tempo` и проверка источника | `tempo_data`, срок 168h | `:3200`, OTLP `:4318` — только сеть `telemetry` | нет |
| `grafana` | `grafana` | 13.3.1 | `wget /api/health` | tmpfs (provisioning из git) | `127.0.0.1:${GRAFANA_OUT_PORT:-3000}` | `admin` / `GRAFANA_ADMIN_PASSWORD` из `.env` (случайный от `make env_setup`), только у Grafana |
Сети: хранилища и Grafana — `telemetry`, Collector — `default` и `telemetry`; из контейнеров
API и worker имена `prometheus`, `loki`, `tempo`, `grafana` не разрешаются (17). Приложение от
сервисов телеметрии не зависит: без них стартует и работает (`evidence/telemetry/collector-outage.md`).
### Бюджет
Лимиты телеметрии: Collector 0,5 CPU / 256 МиБ, Prometheus 0,5 / 384, Loki 0,5 / 512, Tempo
0,5 / 640, Grafana 0,5 / 512 — 2,5 CPU / 2304 МиБ. Постоянные лимиты стенда — 11,5 CPU /
7296 МиБ, с одноразовыми — 12,5 CPU / 7680 МиБ при ВМ 12 CPU / 7934 МиБ (с 2026-11-11 — 11 902
МиБ, раздел «SLO, оповещения и инциденты», «Бюджет»): лимиты — потолки, а не резерв. Два замера под `make test` + `make load` + `make student_test` с телеметрией и без
(`evidence/telemetry/budget.md`): на `68f1e97` (прежние лимиты) пики `memory.peak` Tempo 398 и
Grafana 294 МиБ — правило «лимит не меньше 1,5 × пика» не выполнялось при 512 и 384, лимиты
подняты до 640 и 512, `GOMEMLIMIT` Tempo прежний (400 МиБ — его пик упирается в него, поэтому
лимит — 1,6 × `GOMEMLIMIT`); на `4178b3d` (новые лимиты) — Collector 97, Prometheus 95, Loki 190,
Tempo 253, Grafana 248 МиБ, правило выполнено и для наибольших пиков обоих замеров. Реплика API —
до 453 МиБ с телеметрией и 482 без неё (лимит 512; пик даёт Argon2id входов `make student_test`,
а не SDK; запас ~6 % — ограничение, лимит реплики не менялся), worker — 502 МиБ из 1024. Грубая
цена SDK (один прогон `make load`): 489 против 568 запросов/с, p95 13,8 против 8,8 мс —
исследование трека 1.
### Ограничения наблюдаемости
- **Отказ Collector:** что не ушло, теряется: очереди SDK ограничены (2048 span и записей), при
остановке процесса закрытие ждёт не дольше 1 с (API) и 0,5 с (worker). Cumulative-метрики SDK
копит в себе: после возврата Collector счётчики не теряются, теряется разрешение; рестарт
Collector сбрасывает ряды экспортёра (`rate()` это переносит). Записи об отказе отправки — только
stdout, не чаще одной в минуту на модуль SDK (`evidence/telemetry/collector-outage.md`).
- **Ответы балансировщика** (502, 503, 504, 408 HAProxy) в метрики API не попадают: их считают
метрики LB (раздел «SLO, оповещения и инциденты»), в SLI задержки они не входят, а время в
очереди LB метрики API не видят. Нестандартный метод вне списка парсера uvicorn (`BREW`)
отклоняется до приложения 400 текстом — ни span, ни ряда (`KNOWN_ISSUES.md`).
- **OTLP без аутентификации и TLS** — до лабы 7: Collector принимает от любого контейнера сети
`default`; хранилища отделены сетью.
- Trace-id клиента не продолжается (публичная точка входа); контекст внутри стенда переносит
задание (раздел «Сквозная трасса загрузки» ниже).
- `service.version` не различает сборки одной версии контракта.
- Tempo 3.1 в простое пишет `level=error` «no jobs found» (backend-worker опрашивает
scheduler без заданий) — шум журнала, не отказ.
### Сквозная трасса загрузки (уровень 4)
Change `job-trace-propagation` (design — `openspec/changes/archive/2026-11-11-job-trace-propagation/design.md`,
номера решений «JTP-n»). Одна загрузка — одна трасса: server span `POST
/api/v1/chats/{chat_id}/attachments` (`messenger-api`) → на каждую публикацию её задания span
`PRODUCER` `publish <очередь>` (`messenger-relay`) → под ним span `CONSUMER` `process <очередь>`
этой доставки (`messenger-worker`) с дочерними PostgreSQL, S3 (`S3.GetObject` staging,
`S3.PutObject` оригинала и трёх вариантов), `render attachment variants` и `COMMIT`. Повторная
попытка, повторная доставка брокером и replay — новые пары producer / consumer в той же трассе
с `messenger.job.attempt`, `messenger.job.retry_reason`, `messenger.job.replayed`,
`messenger.job.reason`, `messenger.job.error_code` (значения enum, без `id` и текста ошибок).
| Где | Значение | Кто пишет | Кто читает |
| --- | --- | --- | --- |
| колонки `attachment_jobs.traceparent`, `tracestate` (`text NULL`, CHECK `NOT VALID`, ревизия `e4b8c2d17f90`) | контекст W3C server span загрузки (JTP-4) | реплика API той же транзакцией, что `queued` и задание | relay при каждой публикации |
| заголовки сообщения AMQP `traceparent`, `tracestate` (carrier, JTP-1) | контекст span producer этой публикации | relay (`JobPublisher._publish_one`) | worker (`JobDelivery.trace_context`) |
| поля `traceparent`, `tracestate` тела `contracts/jobs.schema.json` | не заполняются | — | — |
Отображение на схему задания: заголовок `traceparent` = поле `traceparent` = значение W3C
версии `00` (`^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$`, тот же шаблон у CHECK колонки и
разбора заголовка), `tracestate` — то же, до 512 символов. Carrier — native headers брокера
(`contracts/attachment-states.md` это допускает): тело проверяет `AttachmentJobMessage`
(`extra="forbid"`, `pattern`), неверное значение в теле сделало бы сообщение «не по схеме» и
задание `dropped`, а заголовок не по W3C просто игнорируется — новая трасса, исход тот же.
Переносится только W3C Trace Context (`TraceContextTextMapPropagator`), baggage — нет;
глобального propagator нет (JTP-5).
**Почему consumer span — дочерний и с link (JTP-2).** Semantic conventions messaging по умолчанию
связывают обработку с созданием сообщения link, но «exclusively for single messages» разрешают
сделать контекст создания родителем, и требуют link на него («SHOULD link») и описание выбора
(«SHOULD document» — этот раздел). Worker обрабатывает сообщения по одному, объемлющего span у
задачи доставки нет. Родитель даёт одну трассу на загрузку (цепочка до S3 и БД, включая повтор,
находится по одному trace-id) и цельную выборку цепочки при head sampling трека 1: sampler —
`ParentBased(ALWAYS_ON)`, флаг выборки загрузки доходит до worker. Цена — длинные трассы:
повторы растягивают трассу на минуты, replay — на часы.
**Без контекста и смесь версий (JTP-6).** Строка без контекста (прежняя реплика во время `make
rolling_update`, реплика с выключенной телеметрией): relay публикует без заголовков и без span
producer, consumer span — корень, как на уровне 3. Прежний relay колонок не знает, прежний worker
заголовки игнорирует, тело прежнее: ни одна комбинация версий не даёт ошибки, рвутся только
цепочки заданий, которых коснулся прежний код. Relay с выключенной телеметрией кладёт
сохранённый контекст как есть: цепочка API → worker не рвётся. Span relay — только span
producer под сохранённым контекстом: проходы relay и его обращения к PostgreSQL трасс не
начинают. Команда replay SDK не запускает: replay виден следующей парой producer / consumer.
### Сигналы уровня 4
| Логический сигнал контракта | Инструмент SDK | Prometheus | Единица |
| --- | --- | --- | --- |
| p50 / p95 / p99 HTTP и обработки | histogram прежние | `histogram_quantile(q, sum by (le) (rate(…_bucket[5m])))` | с |
| время до `ready` (end-to-end time to ready) | histogram `messenger.job.time_to_ready`, границы 0,25…600 с | `messenger_job_time_to_ready_seconds_{bucket,sum,count}{job="messenger-worker", messenger_job_type}` | с |
| глубина очереди | ObservableGauge `messenger.queue.depth` | `messenger_queue_depth{job="messenger-relay", messaging_destination_name, messenger_queue_stage}` (`scheduled`, `outbox`, `published`, `processing`) | задания |
| возраст старейшей job | ObservableGauge `messenger.queue.oldest_age` | `messenger_queue_oldest_age_seconds{job="messenger-relay"}` | с |
| пул БД: соединения | ObservableUpDownCounter `db.client.connection.count` | `db_client_connection_count{db_client_connection_pool_name, db_client_connection_state="used"\|"idle"}` | соединения |
| пул БД: предел | `db.client.connection.max` | `db_client_connection_max` | соединения |
| пул БД: ожидающие | `db.client.connection.pending_requests` | `db_client_connection_pending_requests` | запросы |
| пул БД: отказы по сроку | ObservableCounter `db.client.connection.timeouts` | `db_client_connection_timeouts_total` | отказы |
| насыщение worker | ObservableUpDownCounter `messenger.worker.busy`, `.capacity`, `.waiting` | `messenger_worker_busy`, `messenger_worker_capacity`, `messenger_worker_waiting` | доставки |
| CPU контейнера | ObservableCounter `container.cpu.time` | `container_cpu_time_seconds_total` | с CPU |
| память контейнера | ObservableUpDownCounter `container.memory.usage` | `container_memory_usage_bytes` | байты |
| пределы контейнера | `messenger.container.cpu.limit`, `messenger.container.memory.limit` | `messenger_container_cpu_limit`, `messenger_container_memory_limit_bytes` | ядра, байты |
| трассы upload → publish → consume | span `PRODUCER` relay, `CONSUMER` worker | Tempo: `messaging.*`, `messenger.job.*`; связь parent и link | span |
Ряды пула, CPU и памяти — у каждого процесса с SDK (`job` = `messenger-api`, `messenger-worker`,
`messenger-relay`, `instance` = `service.instance.id`); имя пула — `postgres:5432/messenger`.
Имена проверены на стенде запросами через Grafana (apply, `trace-chain`).
Запросы панелей уровня 4 (`messenger-overview.json`, строки «Pipeline» и «Saturation»; единицы
панелей — `s`, `percentunit`, `short`):
- квантили HTTP: `histogram_quantile(0.5|0.95|0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m])))`,
обработки — то же над `messenger_job_duration_seconds_bucket{job="messenger-worker",messenger_job_outcome="ready"}`
(с); доля 5xx и доля 4xx — панели уровня 3 (`percentunit`);
- время до `ready`: `histogram_quantile(q, sum by (le) (rate(messenger_job_time_to_ready_seconds_bucket{job="messenger-worker"}[5m])))` (с);
- глубина по стадиям: `max by (messenger_queue_stage) (messenger_queue_depth{job="messenger-relay"})` (`short`);
возраст: `max(messenger_queue_oldest_age_seconds{job="messenger-relay"})` (с) — `max`, а не сумма: два
relay дали бы два ряда одного числа;
- пул: `sum by (job, instance) (db_client_connection_count{db_client_connection_state="used"}) / sum by (job, instance) (db_client_connection_max)`
(`percentunit`), ожидающие — `sum by (job, instance) (db_client_connection_pending_requests)` (`short`,
запросы, левая ось), отказы — `sum by (job) (rate(db_client_connection_timeouts_total[5m]))` (`ops`, отказы
в секунду, правая ось той же панели: число и скорость под одной единицей не смешиваются);
- worker: `sum(messenger_worker_busy) / sum(messenger_worker_capacity)` и среднее за окно
`sum(rate(messenger_job_duration_seconds_sum{job="messenger-worker"}[5m])) / sum(messenger_worker_capacity)`
(`percentunit`; длительность пишется ровно за время на месте — закон Литтла), ожидающие места —
`sum(messenger_worker_waiting)` (`short`);
- контейнеры: `sum by (job, instance) (rate(container_cpu_time_seconds_total[5m])) / sum by (job, instance) (messenger_container_cpu_limit)`
и `sum by (job, instance) (container_memory_usage_bytes) / sum by (job, instance) (messenger_container_memory_limit_bytes)` (`percentunit`).
**Источник очереди (JTP-9)** — один процесс, relay: после успешного прохода, не чаще 5 с, снимок
по PostgreSQL одним выражением, каждый подзапрос — по условию своего частичного индекса
(`ix_attachment_jobs_outbox`, `_published`, `_lease`; состояния константой). Не реплики API (N
копий одного числа), не worker (его может быть два, outbox он не видит), не приёмник Collector
(пароль PostgreSQL у Collector без секретов и SQL вне кода приложения) и не метрики брокера (только
стадия `published`, без outbox, обработки и возраста). Возраст — от устойчивого приёма (задание
вместе с `queued`, до 202): «время до `ready` до сих пор» старейшего незавершённого.
**CPU и память — cgroup изнутри, без `docker.sock` (JTP-12).** Процессы с SDK читают свою
cgroup v2 (`cpu.stat`, `memory.current`, `cpu.max`, `memory.max`; файлы `r--r--r--` от UID
10001). Сокет Docker у Collector (`docker_stats`) отвергнут: доступ к API Docker — root на ВМ
(`:ro` у сокета API не ограничивает), а Collector принимает OTLP без аутентификации из сети
приложения; cAdvisor требует привилегированных монтирований `/`, `/sys`, `/var/lib/docker`;
`hostmetrics` видит ВМ целиком, а не контейнеры. В `docker compose config` монтирования сокета
Docker нет ни у одного сервиса (`trace-chain`).
**Ресурс relay:** `service.name` = `messenger-relay` (константа `TELEMETRY_SERVICE_RELAY`, в
таблице `OTEL_SERVICE_NAME` — третья точка входа), `service.instance.id` = `instance_id` журнала
relay (короткий id контейнера), остальное — как у API и worker; `TELEMETRY__ENABLED` и
`TELEMETRY__OTLP_ENDPOINT` — якорем `x-telemetry-env` и у `relay`. Модули SDK, экспортёра,
protobuf и `requests` загружаются только при включённой телеметрии (JTP-7): уборщик, команда
replay, консоль, `make test_isolated`, стенд отказов и `bench/` их не держат; исключение —
модули метрик SDK, которые сам загружает redis-py 8.1 при импорте.
**Бюджет (JTP-15).** Новых сервисов и портов нет, лимиты прежние, соединений PostgreSQL не
прибавляется; суммы прежние (11,5 CPU / 7296 МиБ, с одноразовыми 12,5 / 7680). Замер на `72cfa9a`
под `make test` + `make load` + `make student_test` + `trace-chain` (раздел change в
`evidence/telemetry/budget.md`): relay с SDK — `memory.peak` 103 МиБ (старт), CPU до 25 % ядра при
лимите 0,25 только при разборе накопленных заданий; уборщик после ленивого импорта — 108 МиБ
вместе с плановой сверкой при старте; правило «лимит ≥ 1,5 × пика» у обоих выполнено (256 МиБ).
У Grafana в этом замере `memory.peak` 343 МиБ, из них файловый кэш 95 МиБ, который ядро освобождает
до OOM; неосвобождаемая часть `anon` + `kernel` + `shmem` ≈ 197 МиБ, 1,5 × ≈ 296 ≤ 512 — правило
выполнено, лимит прежний. Пик — `memory.peak`, а если с кэшем он правило не проходит — `anon` +
`kernel` + `shmem` (`.claude/rules/telemetry.md`, «Что считать пиком»).
**Ограничения уровня 4:**
- пул и насыщение worker — мгновенные значения раз в интервал отправки (15 с): короткие всплески
пропускаются; отказы пула — счётчик, насыщение — ещё и среднее по сумме длительностей;
- снимок очереди, который relay не обновил дольше 30 с, не отдаётся, но экспортёр Collector держит
последнюю точку до `metric_expiration` (с change `slo-alerts` — 1 мин, было 5) — панель может
показать прежнее значение до ~75 с; у остановленного relay очереди на панели нет;
- PostgreSQL, S3, брокер, LB и уборщик в метриках CPU и памяти не представлены (нет SDK, сокета
Docker нет); у worker в его cgroup — и процессы обработки;
- время до `ready` не учитывает задания после replay (их приём — действие оператора) и повторную
доставку готового;
- трасса без корня, если Collector был недоступен при загрузке («root span not yet received»);
длинные трассы повторов и replay искажают длительность трассы в поиске Tempo — искать по
атрибутам span (`messenger.job.outcome`);
- при перезапуске процесса counter начинается с нуля под тем же `instance`; с change `slo-alerts`
Prometheus пишет ноль в момент начала ряда нового процесса (время начала по protobuf), если
процесс перезапущен не раньше чем через ~75 с после остановки; быстрее — новый процесс, догнавший
прежнее значение до первого сбора, по-прежнему занижает `increase()` (раздел «Счётчики после
перезапуска процесса» ниже);
- без `messaging.message.id` (решение 12 change `otel-telemetry`: `id` задания не в span) и без
span Create и Settle: подтверждение — внутри consumer span.
### SLO, оповещения и инциденты (уровень 4)
Change `slo-alerts` (design — `openspec/changes/archive/2026-11-14-slo-alerts/design.md`, номера решений «SA-n»).
Правила — `infra/otel/prometheus/rules.yml`, тесты — `rules.test.yml` (`make alerts_test`),
runbooks — `infra/otel/runbooks/`.
**SLI и SLO (SA-1, SA-2).** Окно — скользящие 7 суток (= срок хранения Prometheus). Правила записи
группы `messenger-slo` (раз в 5 мин) считают приращения событий за непересекающиеся 5 мин; SLI
окна W — отношение их сумм, остаток бюджета — (SLI − SLO) / (1 − SLO).
| SLI | Плохие / хорошие (числитель) | Все (знаменатель) | SLO |
| --- | --- | --- | --- |
| доступность | плохие — `haproxy_frontend_http_responses_total{job="haproxy",proxy="entry",code="5xx"}` | тот же счётчик по всем `code` | 99,5 % |
| задержка | хорошие — `http_server_request_duration_seconds_bucket{le="0.25"}` «лёгких» маршрутов без 5xx | `…_count` тех же | 99 % |
| время до `ready` | хорошие — `messenger_job_time_to_ready_seconds_bucket{le="30.0"}` | `…_count` | 99 % |
- Формулы окна W: доступность — `1 - sum_over_time(messenger:slo_availability_bad:increase5m[W]) /
sum_over_time(messenger:slo_availability_total:increase5m[W])`; задержка и время до `ready` —
`sum_over_time(messenger:slo_<sli>_good:increase5m[W]) / sum_over_time(messenger:slo_<sli>_total:increase5m[W])`.
Панели SLI (26 — за 7 суток, 28 — за интервал дашборда) считают по рядам правил. Те же SLI по
исходным счётчикам — `increase(…[W])` тех же селекторов; `alerts-check` сверяет пути за час:
ряды правил против суммы `increase(…[5m])` исходных счётчиков на время каждой точки правил (те же
окна, расхождение ≤ 1 п. п.), а у доступности и задержки — ещё против `increase(…[1h])` одним
окном (тоже ≤ 1 п. п.; у времени до `ready` одно окно — наблюдение, см. ограничения ниже).
- «Лёгкие» маршруты — `http_route!~"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content"`:
вне SLI — KDF регистрации и входа (и `DELETE /api/v1/users` того же шаблона), загрузка и
скачивание байтов; запросы без маршрута (404) входят. 5xx в SLI задержки не входят — это плохие
события доступности.
- **Почему доступность — на LB.** При недоступном PostgreSQL реплики выходят из LB (≤ 6,5 с), и
дальше клиент получает 503 от самого LB: метрики API запросов почти не видят, доля 5xx по ним
считалась бы по исчезающему знаменателю, а оповещение снялось бы посреди отказа. Метрики LB —
встроенный экспортёр HAProxy на порту статистики (`/metrics`, только сеть приложения), его
забирает приёмник `prometheus/haproxy` Collector, Prometheus — у Collector (`job="haproxy"`):
изоляция сети хранилищ прежняя. Доля ошибок контракта (5xx API / учтённые запросы) осталась
панелью уровня 3.
- **Пороги.** 0,25 с — граница bucket с запасом ×7 над p99 «лёгких» маршрутов (8–33 мс на стенде);
30 с — граница bucket, путь без повторов 0,5–2 с; 99,5 % у доступности — один PostgreSQL, LB и хост.
- **Ограничения SLI:** время в очереди LB и ответы самого LB в SLI задержки не входят (у HAProxy нет
histogram); ряды группы `messenger-slo` отстают на 5–10 мин (Prometheus пишет точку с временем
предыдущего слота, интервал 5 мин) — SLI по ним не видит последних минут, окно учений считается
по исходным счётчикам; непересекающиеся окна `increase(…[5m])` теряют приращение между
последним сбором окна и первым следующего (~5 % событий наугад: заметно при единицах событий,
как у времени до `ready`), а пока Prometheus остановлен, окна нет вовсе — `alerts-check` сверяет
ряды правил с исходными счётчиками в тех же окнах, у доступности и задержки — ещё и с `increase`
за час одним окном, а у времени до `ready` одно окно только печатает; SLI за 7 суток включают учения и проверки; при недоступном Prometheus правила не
вычисляются, приращение счётчиков после возврата прежнее (`evidence/telemetry/backend-outage.md`).
- Значения на момент отчёта (`evidence/alerts/check.md`, раздел `[SLI and panels]`, строки
139–155, 2026-11-14 01:27Z, commit `ef60b47`):
| SLI | 7 суток | час: по правилам / по исходным счётчикам в тех же окнах / `increase` одним окном | окно учений (~18 мин) | SLO | остаток бюджета за 7 суток |
| --- | --- | --- | --- | --- | --- |
| доступность | 0,93726 | 0,96010 / 0,96010 / 0,96590 (58 645 событий) | 0,88927 | 99,5 % | −11,5 (исчерпан) |
| задержка | 0,98652 | 0,98658 / 0,98658 / 0,98724 (55 462) | 0,98180 | 99 % | −0,35 |
| время до `ready` | 0,93162 | 0,93586 / 0,93501 / 0,88000 (49) | 0,86957 | 99 % | −5,84 |
SLO за 7 суток не соблюдены: в окно входят только учения и проверки рабочего стенда (остановки
PostgreSQL, worker, relay, блокировка таблицы сообщений, долгие отказы хранилищ, `make
test-failover`) — бюджет съели они, это и показывает строка «окно учений». За час пути в тех же
окнах совпадают (0, 0 и 0,085 п. п. при допуске 1), с `increase` одним окном у доступности и
задержки — 0,58 и 0,066 п. п. (допуск 1; у времени до `ready` при 49 событиях одно окно —
наблюдение). За час 10 окон правил из 12 — Prometheus перезапущен в 00:42Z; последние 5–10 мин
учений в записанные окна ещё не попали (точки `messenger-slo` отстают).
**Оповещения (SA-3, SA-4).** Правила Prometheus, без Alertmanager и без доставки наружу.
Состояние firing / resolved — `/api/v1/rules`, `/api/v1/alerts`, ряды `ALERTS` (история за срок
хранения), Grafana: правила источника Prometheus в Alerting только для чтения (`manageAlerts:
true`), панель «Alert states». Правила Grafana отвергнуты: живут в её базе (у нас tmpfs), без
модульных тестов `promtool`. Alertmanager отвергнут по функции, а не по бюджету: доставки нет,
история есть в Prometheus, подавление зависимых оповещений одно и выражено в условии (`unless`).
| Оповещение | Условие (окно) | Порог | `for` | `severity` | Runbook |
| --- | --- | --- | --- | --- | --- |
| `MessengerHighErrorRate` | доля 5xx ответов LB клиентам (2 мин) при трафике > 0,1 запроса/с | 5 % | 1 мин | critical | `infra/otel/runbooks/MessengerHighErrorRate.md` |
| `MessengerSlowRequests` | доля «лёгких» запросов дольше 0,25 с (2 мин) при трафике > 0,1 запроса/с | 10 % | 1 мин | warning | `…/MessengerSlowRequests.md` |
| `MessengerNoReadyReplicas` | готовых реплик в LB | < 1 | 30 с | critical | `…/MessengerNoReadyReplicas.md` |
| `MessengerQueueLagHigh` | возраст старейшего незавершённого задания | 60 с | 1 мин | warning | `…/MessengerQueueLagHigh.md` |
| `MessengerQueueMetricsMissing` | снимка очереди relay нет, экспортёр Collector доступен | — | 2 мин | warning | `…/MessengerQueueMetricsMissing.md` |
| `TelemetryTargetDown` | `up` = 0 у `otel-collector`, `loki`, `tempo`, `haproxy` | `up` = 0 | 1 мин | warning | `…/TelemetryTargetDown.md` |
| `TelemetryDataLoss` | рост `telemetry:lost_items:total` за 2 мин | > 0 | — | warning | `…/TelemetryDataLoss.md` |
Пороги ошибок и задержки — 10 × допустимой доли SLO; окна 2 мин (8 сборов) — снятие за 2–3 мин
после восстановления; одиночные 503 и 502 проверок короче `for`. Слепые места закрыты отдельными
оповещениями: нет снимка очереди — `MessengerQueueMetricsMissing`, нет метрик LB или Collector —
`TelemetryTargetDown`; отказ самого Prometheus оповещением не ловится (meta-monitoring вне стенда,
в Grafana — ошибка источника). У каждого оповещения — `summary`, `description` с текущим
значением, `runbook_url` (путь в репозитории). Тесты правил: на каждое оповещение — срабатывание
после `for`, нет срабатывания ниже порога и без трафика, снятие; значения правил записи;
`MessengerQueueMetricsMissing` молчит при недоступном экспортёре; `TelemetryDataLoss` — новый ряд,
рост, сброс (`evidence/alerts/rules-test.md`).
**Буферизация и потери (SA-7–SA-9).** SDK — прежние очереди `[telemetry]`: 2048 span и 2048 записей,
пакет 512, отправка ≤ 2 с, при полной очереди вытесняется самое старое. Collector: `memory_limiter`
200 / 40 МиБ, `GOMEMLIMIT` 160 МиБ; экспорт в Loki и Tempo — очередь в памяти по байтам (16 и 8
МиБ: ~40–90 с пика записей и ~10–15 с пика span), два отправителя, повторы 1 / 5 / 30 с, полная
очередь отклоняет новое без задержки приёма; пакет логов ≤ 256 записей, span ≤ 1024 — пакет
всегда меньше очереди. Метрики Prometheus забирает сам, очереди для них нет. Где считаются потери:
| Место | Счётчик |
| --- | --- |
| очередь SDK | `otel_sdk_processor_{span,log}_processed_total{error_type="queue_full"}` |
| отправка SDK | `otel_sdk_exporter_{span,log}_exported_total{error_type!=""}` |
| приём Collector | `otelcol_receiver_refused_{spans,log_records,metric_points}` |
| очередь экспорта полна | `otelcol_exporter_enqueue_failed_{spans,log_records}` |
| повторы истекли | `otelcol_exporter_send_failed_{spans,log_records}` |
Сумма по процессу — правило `telemetry:lost_items:total`; оповещение — рост суммы, а не
`increase()`: ряд отказов появляется с первой потерей, у собственных метрик Collector нет времени
начала. Ряд суммы начинается с нуля со старта процесса — у Collector по его рядам
`otelcol_receiver_refused_*` (есть с нуля), у процессов SDK по ряду ёмкости очереди span (`… or
sum by (job, instance) (otel_sdk_processor_span_queue_capacity) * 0`), поэтому `rate()` панели
потерь видит и первую потерю процесса (без нуля первое значение нового ряда `rate()` отбрасывал:
verify, W1). Остаётся: процесс SDK, запущенный при уже недоступном Collector, или отказ Collector
дольше окна панели (5 мин) — первая точка ряда после возврата снова без нуля в окне; оповещение
`TelemetryDataLoss` это видит (рост против `offset 2m` или нуля). Внутренние метрики SDK (`otel.sdk.*`) включает код: процессоры и экспортёры OTLP span и
журнала строятся после `MeterProvider` с ним и с переменной SDK только на время сборки; внешняя
`OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED` удаляется, как любая `OTEL_*`; гистограммы SDK не
отдаются. Результаты отказа каждого хранилища и Collector под нагрузкой драйвера (~25 запросов/с;
`evidence/telemetry/backend-outage.md`, commit `ef60b47`):
| Отказ | Ответы клиенту | Память | Потери (учтены) | Оповещения |
| --- | --- | --- | --- | --- |
| Loki 10 с | свой запрос найден в Loki после возврата | — | 0 | — |
| Loki 120 с | `make test` PASS, 2933 × 2xx, 5xx 0 | Collector `docker stats` ≤ 81 МиБ из 256; очередь Loki ≤ 0,122 ёмкости | 441 запись (`otlp_http/loki`), на панели потерь `otel-collector` до 1,497/с | `TelemetryTargetDown{job="loki"}` firing через 80 с, `TelemetryDataLoss` firing; сняты через 20 и 140 с |
| Tempo 10 с | своя трасса найдена после возврата | — | 0 | — |
| Tempo 120 с | `make test` PASS, 2931 × 2xx, 5xx 0 | Collector ≤ 91 МиБ (runtime sys ≤ 84); очередь Tempo ≤ 0,622 ёмкости | 1336 span (`otlp_http/tempo`), на панели до 4,688/с | `TelemetryTargetDown{job="tempo"}` через 75 с, `TelemetryDataLoss`; сняты через 15 и 135 с |
| Prometheus 60 с | 1467 × 2xx, 5xx 0 | — | счёт запросов API после возврата +2202 ≥ 1463 запросов нагрузки | правила не вычислялись (ограничение) |
| Collector 120 с | `make test` PASS | реплики: максимум последней трети окна 143 и 150 МиБ против 142 и 143 первой (лимит 512) | SDK реплик: +11 602 и +11 551, на панели потерь `messenger-api` до 81,239/с; записей API окна в Loki 0 из 5274 в stdout | `TelemetryTargetDown{job="otel-collector"}` через 80 с, снято через 20 с; `MessengerQueueMetricsMissing` не сработало |
Короткий отказ короче срока повторов (30 с) потерь не дал; долгий потерял конец окна (начало
отказа сохранила очередь), отказов приёма Collector (`memory_limiter`) не было. Без Collector
память реплик ограничена очередями SDK (2048), счёт потерь SDK копился в процессе и пришёл в
Prometheus после возврата Collector.
**Счётчики после перезапуска процесса (SA-6).** Prometheus принимает время начала cumulative-рядов
экспортёра Collector (`PrometheusProto` первым у цели `otel-collector-exporter`, флаг
`created-timestamp-zero-ingestion`; у остальных целей — прежний текстовый список) и пишет ноль в
момент начала ряда нового процесса; экспортёр убирает ряд, не обновлявшийся минуту. Проверка —
`alerts-check`, шаг 1: worker остановлен на 145 с, 3 загрузки, запуск — первая точка ряда нового
процесса — ноль (`(2.3, 0.0)`), приращение по точкам ровно 3 (`evidence/alerts/check.md`, строки
76–81, commit `ef60b47`). Остаётся: перезапуск того же контейнера
быстрее ~75 с, если новый процесс догнал прежнее значение до первого сбора; собственные метрики
Collector без времени начала (их закрывает правило потерь). Число рядов экспортёра до и после
перехода на protobuf на процесс то же (двойников нет).
**Инциденты.** Разбор — по runbook оповещения и только по сохранённым наблюдениям вывода
`alerts-check` и `backend-outage` (хронология и значения — в файлах evidence).
Учения — 2026-11-14, 01:09:30Z – 01:43:27Z, commit `ef60b47`, фоновая нагрузка драйвера ~25
запросов/с через LB; время — от начала шага (у `MessengerQueueLagHigh` — от первой загрузки, у
снятия — от восстановления), «строки N» — строки файла evidence.
1. **Остановлен worker** (`evidence/alerts/check.md`, строки 64–82). Хронология: `docker compose stop
worker` на 46-й секунде учений, 3 загрузки — 202 (строка 68); `MessengerQueueLagHigh` pending
через 84 с, firing через 144 с после первой загрузки (строки 69–70); worker запущен через 145 с
остановки (строка 77), снято через 29 с после запуска (строка 79). Диагностика по runbook
`MessengerQueueLagHigh`: «Pipeline» → глубина `published` 3, остальные стадии 0, возраст
старейшего 131,9 с (`max by (messenger_queue_stage) (messenger_queue_depth{job="messenger-relay"})`,
`max(messenger_queue_oldest_age_seconds{job="messenger-relay"})`; строка 71) — задания приняты и
опубликованы, но не взяты; рядов `messenger-worker` к запуску нет (строка 76) → Loki
`{service_name="messenger-worker"}`: последняя запись worker — «Attachment became ready» за 1 с до
остановки, «Stopped worker» — в stdout (строки 74–75) → Tempo `{ resource.service.name =
"messenger-worker" && kind = consumer }`: consumer span после остановки 0 (строка 73) ⇒ причина —
worker не работает (не брокер и не relay: сообщения в стадии `published`). Восстановление —
`docker start` worker: все 3 `ready` (строка 78), счёт времени до готовности +3 по точкам, первая
точка нового процесса — ноль (строки 80–81). SLI времени до `ready` за окно учений — 0,86957
(три загрузки ждали дольше 30 с — плохие события; строка 155).
2. **Медленная БД против медленного handler** (строки 91–118). Блокировка `LOCK TABLE messages IN
SHARE MODE` 2 с с паузой 0,2 с в сессии `application_name = mtusi-alerts-check`:
`MessengerSlowRequests` pending через 75 с, firing через 135 с (строки 93–94), доля медленных
«лёгких» 0,427 при пороге 0,1 (строка 95) → p95 по маршрутам: `POST
/api/v1/chats/{chat_id}/messages` 0,016 с до и 2,324 с во время (строки 96–97), чтение не медленно
→ Tempo, медленные трассы отправки: span PostgreSQL — 0,99–1,0 server span (строка 98) → пул:
занято до 6 соединений против 0 до шагов (строка 100) → CPU реплик не выше 0,09 предела (строка
102) ⇒ БД (держатель блокировки — в `pg_stat_activity` по `application_name`). Сессия завершена —
снято через 74 с (строка 104); `MessengerHighErrorRate` не срабатывал (строка 105). Для сравнения
вход по Basic (строки 106–118): 515 входов, медиана 0,25 с, p95 `/api/v1/auth/sessions` 0,598 с,
span PostgreSQL — 0,0–0,2 server span (медиана 0,01), пул занят не больше 0,20 без отказов по
сроку, CPU реплик до 0,81 предела ⇒ handler (KDF); вход вне SLI задержки — доля медленных
«лёгких» не выше 0,072, оповещения нет. **Недоступная БД** (строки 119–138): `docker compose stop
postgres` → `MessengerNoReadyReplicas` pending через 29 с, firing через 59 с,
`MessengerHighErrorRate` pending через 44 с, firing через 105 с (строки 121–124) → «Load
balancer»: готовых реплик 0 (строка 125), 5xx на LB +2605, у API +67 (строка 132) — клиент
получил 2556 ответов 5xx, из них 2497 — 503 самого LB без `X-Instance-Id` (строка 129): метрики
API отказ почти не видят, поэтому SLI — на LB → Loki: 67 записей «Database is unavailable»
реплик (строка 126) → Tempo: трассы с ошибкой server span 503 (50 — предел поиска; строка 127;
span PostgreSQL с ошибкой нет — отказ на выдаче соединения из пула, до запроса). Восстановление —
`docker compose start postgres`, LB готов; сняты через 30 и 135 с (строки 130–131). SLI
доступности за окно отказа — 0,5557 по LB при 0,5581 у клиента (строка 135).
3. **Недоступно хранилище телеметрии** (`evidence/telemetry/backend-outage.md`, строки 63–79).
`docker compose stop tempo` на 120 с под нагрузкой: `TelemetryTargetDown{job="tempo"}` firing
через 75 с (строка 65), `TelemetryDataLoss` firing (строка 72) → «Telemetry pipeline»: очередь
экспорта Tempo — до 0,622 ёмкости (строка 66), потери `otlp_http/tempo` — 1336 span (`enqueue_failed`
/ `send_failed`, строка 73), панель потерь — `otel-collector` до 4,688/с (строка 75), память
Collector — `docker stats` до 91 МиБ при лимите 256 (строка 68) → приложение не задето: `make
test` PASS, 2931 ответ 2xx, 5xx 0 (строки 64, 70–71) ⇒ теряется телеметрия, а не сообщения. После
`docker compose start tempo` — новые трассы приходят (строка 77), `TelemetryTargetDown` снят через
15 с, `TelemetryDataLoss` — через 135 с (строки 78–79); потери — 1336 span из счётчиков Collector.
**Бюджет (SA-13).** Новых сервисов и портов нет; лимиты — по замеру `backend-outage` и
`alerts-check` и правилу «лимит ≥ 1,5 × пика» (раздел change `slo-alerts` в
`evidence/telemetry/budget.md`, commit `15ea156`): Collector в долгом отказе Tempo — `docker stats`
до 93 МиБ, `memory.peak` за `alerts-check` 76 МиБ (лимит 256); Prometheus за `alerts-check` — 108
МиБ (384; в пробных прогонах apply — до 240, 1,5 × 240 = 360); реплики API без Collector — без роста
(142 → 156 и 145 → 154 МиБ), `memory.peak` со старта стенда 334 и 327 МиБ от входов по Basic (512).
Правило выполнено у всех, лимиты не менялись. Пересъёмка на `ef60b47` (`evidence/alerts/check.md`,
`evidence/telemetry/backend-outage.md`) — в тех же пределах: Collector до 91 МиБ (`docker stats`),
`memory.peak` 83 МиБ; Prometheus 128 МиБ (1,5 × 128 = 192 ≤ 384); реплики — `memory.peak` 342 и
339 МиБ от входов по Basic (1,5 × 342 = 513 — на 1 МиБ больше лимита 512), неосвобождаемая часть
129 и 130 МиБ — правило по ней выполнено, как в пробных прогонах apply (design, «Уточнения apply»,
п. 13: `memory.peak` 417–441, неосвобождаемая 137–138). ВМ Docker Desktop — 12 CPU (все ядра хоста) / 11 902 МиБ: память
пользователь увеличил до 12 ГБ 2026-11-11 (вопрос 1 `## slo-alerts` в `QUESTIONS.md`); постоянные
лимиты стенда — 11,5 CPU / 7296 МиБ, с одноразовыми 12,5 CPU / 7680 МиБ, вместе с контейнерами
`make test_isolated` (+2,25 CPU / 1792 МиБ) — 9472 МиБ: помещается с запасом ~2,4 ГиБ на накладные
ВМ. CPU больше не дать: сумма лимитов CPU больше 12 — конкуренция, а не отказ.
## Цена наблюдаемости (трек 1)
Change `track1-telemetry-cost` (design — `openspec/changes/archive/2026-11-15-track1-telemetry-cost/design.md`, номера решений в скобках).
Методика, гипотезы и критерии с порогами записаны **до метки** (commit `509afca`). Метка — `evidence/telemetry-cost/baseline2/`:
код `68e14b6`, каталог метки — commit `0f5dbfc`, 21 прогон из 21, `dirty: false`. Числа раздела «Результаты» взяты из её
`summary.md`. Арифметика поверх сводки: пересчёт приёма на сутки и неделю по её правилу (× 86 400 и × 604 800); надбавка к
`off` в процентах (`(x − off) / off` по медианам CPU реплик на запрос); доля надбавки `head` от надбавки `full` (42 %, «снимает
58 %»); сокращение рядов отбором (−80 %: у `balanced`, где из рычагов агрегации только отбор, рядов 19,2 % `full`); загрузка реплики в процентах лимита (`replica_cpu_cores` из
`runs.csv` / 2 реплики: 31,3 % у `full`, 28,4 % у full-r3) и спад CPU на запрос в третьем круге (~9 %, по `runs.csv`). Остальные
числа — из `summary.md` как есть.
Первая метка `baseline` (`509afca`) не снята: два сбоя профиля, правка и +15 % к лёгким классам —
design, «Уточнения apply», п. 16. Команда: `make stop`, затем `make bench_telemetry` (~1 ч 25 мин); защита —
`make bench_telemetry_quick VARIANTS=off,full,tail` (~10 мин).
### Методика
**Стенд** (1) — свой проект compose `mtusi-bench`, свежий на каждый прогон (`down -v`, хранилища телеметрии тоже начинают
пустыми): HAProxy, две реплики API 1 CPU / 512 МиБ, PostgreSQL 2 / 1 ГиБ, Valkey 0,5 / 128 МиБ, S3 1 / 512 МиБ, брокер
1 / 512 МиБ, relay 0,25 / 256 МиБ, worker 1 / 1 ГиБ, уборщик 0,25 / 256 МиБ — лимиты рабочего стенда, без swap; в вариантах с
телеметрией — Collector 0,5 / 256 МиБ, Prometheus 0,5 / 384 МиБ, Loki 0,5 / 512 МиБ, Tempo 0,5 / 640 МиБ с образами и
конфигурациями рабочего стенда (`infra/otel/`), Grafana не запускается (в пути данных её нет). Сумма лимитов на пике —
11,25 CPU / 6912 МиБ при ВМ 12 CPU / 11 902 МиБ. Генератор k6 — в сети стенда, без лимита, через LB.
**Варианты** (2) — различаются только телеметрией:
| Вариант | SDK реплик, worker, relay | Collector | Prometheus | Проверяет |
| --- | --- | --- | --- | --- |
| `off` | выключен, сервисов телеметрии нет | — | — | база |
| `full` | все трассы, границы `default`, метрики раз в 15 с | `infra/otel/collector.yaml` | `infra/otel/prometheus/prometheus.yml` | рабочий стенд |
| `full-aa` | = `full` | = `full` | = `full` | шум метода (A/A в той же метке) |
| `head` | доля корней 0,1 (`[telemetry] trace_sample_ratio`) | = `full` | = `full` | выбор в голове (H2) |
| `tail` | = `full` | + `bench/otel/tail-typical.yaml`: ошибки, трассы ≥ 0,25 с, 10 % остальных, ожидание 30 с | = `full` | типовой tail sampling (H3) |
| `metrics` | метрики раз в 30 с, границы `coarse` | = `full` | `bench/otel/prometheus-lean.yml` (собственные ряды хранилищ — только приём, отказы, объём) | агрегация (H4) |
| `balanced` | = `full` | + `bench/otel/tail-balanced.yaml` | `bench/otel/prometheus-lean.yml` | сбалансированная (H7) |
Слои Collector — второй `--config` (меняют только процессор `tail_sampling` и список процессоров pipeline трасс), копия
Prometheus совпадает с рабочей вне размеченных блоков: до первого прогона это проверяют `validate` и `print-config` Collector,
построчная сверка и `promtool` — иначе код 2. Каждый прогон проверяется применённым: записи «Started API / worker / relay»
называют долю, набор границ и интервал варианта, выборка видит ряды `tail_sampling` и отбор рядов ровно у своих вариантов —
иначе отказ команды. План — 7 вариантов × 3 повтора кругами с перестановкой от зерна, вариант подряд не повторяется.
**Нагрузка** (8) — открытая модель (`k6/telemetry.js`, `constant-arrival-rate`, VU заранее, ответ не повторяется), одинаковая
во всех вариантах, ниже насыщения (калибровка до гипотез: в `full` реплика занята 30–60 % CPU, Collector, Tempo и worker —
меньше 70 %, недосланных нет, p95 времени до `ready` < 5 с). Лёгкие классы подняты на 15 % после неснятой метки
`baseline`: на тихом хосте `full` занимал реплику на 28–29,5 %, ниже границы 30 % (design, «Уточнения apply», п. 16):
| Класс | Запрос | В секунду |
| --- | --- | --- |
| `read` | первая страница истории чата записи (50) | 126,5 |
| `write` | сообщение с новым `Idempotency-Key` | 23 |
| `me` | `GET /users/me` | 34,5 |
| `card` | карточка чата (кэш Valkey) | 34,5 |
| `download` | оригинал готового вложения | 10 |
| `upload` | JPEG 1600 × 1200, 0,48 МиБ → `ready` (API → relay → worker) | 1 |
| `upload_bad` | тот же JPEG с 12 битами точности в SOF: 202, затем `failed` `invalid_image` | 0,1 |
| `broken` | оригинал вложения без объекта в S3 — 500 API | 0,2 |
| `register` | регистрация (Argon2id) — редкий маршрут | 0,2 |
Окна — разогрев 30 с, **чистое окно 90 с (по нему считается цена)**, окно отказов 30 с: в нём трижды (на 5, 15 и 25 с) таблица
сообщений блокируется `LOCK TABLE messages IN SHARE MODE` на 0,6 с в своей сессии PostgreSQL — запись ждёт, чтение идёт.
**Редкие события с известным счётом:** строка вложения `ready` без объекта (`\copy` в базу свежего стенда) — 500; JPEG,
который проходит проверку структуры, но не декодируется, — неудачное задание без статуса ошибки span (исход, а не
исключение); медленные записи под блокировкой — медленные запросы быстрого маршрута; регистрация — редкий маршрут: на стенде
она быстрая (~85 мс, а не 0,3–1 с, как ожидалось), поэтому в критериях tail sampling она — справочный «редкий быстрый маршрут»,
а «медленные записи» считаются **по серверу** (длительность записи доступа — та же величина, что server span, ≥ 0,25 с): правила
выбора трасс видят span, а не ожидание клиента в LB (design, «Уточнения apply», п. 1).
**Источники измерений** (9): задержки и ошибки по классам — строки k6 чистого окна (истина клиента); CPU, троттлинг, память
(наибольшая, `memory.peak`, `anon`) каждого контейнера — сэмплер cgroup (режим `cost`); CPU реплик на запрос — CPU реплик за
чистое окно / ответов реплик в нём; время до `ready` — `updated_at` метаданных минус ответ 202; приём — метрики Collector
(`otelcol_receiver_accepted_*`, `otelcol_exporter_sent_*`), Tempo и Loki (`*_distributor_*_received_total`), Prometheus
(`prometheus_tsdb_head_series`, `…_samples_appended_total`) по краям чистого окна; рост на диске — `du` volume хранилищ в конце
(за минуты прогона — журнал предзаписи, без сжатых блоков); потери по звеньям — внутренние метрики SDK (`otel.sdk.span.started`
по решению выборки, `otel.sdk.processor.*.processed` и `otel.sdk.exporter.*.exported` с `error.type`) → Collector (отказ
приёма, ошибки и отказы очереди экспорта, решения tail sampling, `dropped_too_early`) → хранилище; редкие события — поиск
трассы по `span.messenger.request_id` (у загрузки — вся цепочка до consumer span итога), записи журнала по `request_id` и её
`trace_id` → трасса, счёт в метрике; нормальные запросы — выборка 200 `GET /users/me`; точность квантилей — `histogram_quantile`
по buckets маршрутов `read` и `write` за чистое окно против `quantile_over_time` той же длительности из журнала.
Отброшенное выборкой потерей не считается.
**Правило шума** (12): для величины m шум — |медиана `full` − медиана `full-aa`|; изменение варианта — эффект, только если
разбросы трёх повторов не пересекаются и |Δ медианы| больше шума; порог гипотезы проверяется только у эффекта, «в пределах
шума» — когда эффекта нет. Доли редких событий — по сумме повторов, интервал — точный биномиальный 95 %. Вердикты — «подтверждено»,
«нет», «нет данных».
### Гипотезы
| | Утверждение | «Подтверждено», если |
| --- | --- | --- |
| H1 | полная телеметрия дорога для реплик и хвоста | `full` против `off`: CPU реплик на запрос ≥ +10 % (эффект); p50 лёгких — не больше +1 мс; p99 лёгких ≥ +2 мс и его относительный рост больше роста p50 |
| H2 | выбор в голове снимает большую часть цены приложения, но не журнал | `head`: надбавка CPU реплик на запрос против `off` ≤ половины надбавки `full`; приём Tempo ≤ 15 % `full`; доля трасс 500, медленных записей, регистраций и неудачных загрузок — в биномиальном интервале около 0,1; записи журнала — 100 %, счёт в метрике — не меньше клиента |
| H3 | типовой tail экономит хранилище, но не приложение, и платит памятью Collector | `tail`: CPU реплик на запрос — в пределах шума от `full`; пик памяти Collector ≥ `full` + 15 МиБ, CPU Collector — не выше `full` больше чем на 20 %; приём Tempo ≤ 30 % `full`; трассы 500 и медленных по серверу записей и цепочки неудачных загрузок — 100 %; цепочки обычных загрузок ≥ 90 %; отказов `memory_limiter` и `dropped_too_early` нет |
| H4 | агрегация почти не меняет CPU, но сокращает ряды; грубые границы теряют точность квантилей | `metrics`: рядов Prometheus ≤ 40 % `full`, отсчётов в секунду ≤ 40 %; CPU реплик и Collector — в пределах шума; ошибка p95 или p99 из buckets против журнала у `coarse` ≥ 2 × ошибки `default` хотя бы на одном из маршрутов `read`, `write` |
| H5 | переход от журнала к трассе ломается вместе с выборкой | доля записей редких классов, чей `trace_id` ведёт на трассу: `full` — 100 %; `head` — в биномиальном интервале около 0,1; `tail` и `balanced` — 100 % у сохраняемых классов (500, медленные по серверу записи, неудачные загрузки) |
| H6 | непреднамеренных потерь при этой нагрузке нет | во всех вариантах потери SDK и Collector — 0, `dropped_too_early` — 0; span SDK → Collector и Collector → Tempo сходятся с точностью 1 % (решения выбора — отдельно) |
| H7 | сбалансированная конфигурация проходит B1–B5 | все пять критериев ниже |
| H8 | самое дорогое хранилище — Tempo | у `full` CPU Tempo больше, чем Loki и Prometheus вместе, и его рост на диске больше их суммы; у `head`, `tail`, `balanced` CPU Tempo — не больше половины `full` |
### Сбалансированная конфигурация и критерии
`bench/otel/tail-balanced.yaml` + `bench/otel/prometheus-lean.yml` (5): SDK отправляет все трассы, Collector держит трассу до
решения 10 с (цепочка загрузки ниже насыщения — до ~3 с), карта трасс 20 000 при ~300 новых в секунду, кэш решений — только
сохранённых трасс (поздние span сохранённой трассы остаются с ней). Сохраняются: трассы со span `ERROR` (5xx, исключения,
отказ хранилища); consumer span с неуспешным исходом задания (`failed`, `retry`, `error`, `requeued`, `dropped` — у `failed`
статуса ошибки нет); server span ≥ 0,25 с (порог SLO на запрос, а не длительность трассы: у каждой асинхронной загрузки трасса
длиннее 0,25 с) или consumer span ≥ 5 с; 10 % остальных. Prometheus забирает у Loki, Tempo и у себя только ряды приёма,
отказов и объёма, `up` — всегда; ряды приложения и Collector — все. Журнал и метрики приложения не выбираются.
| | Критерий |
| --- | --- |
| B1 | сохранены трассы всех внесённых 500 API и всех медленных по серверу записей и цепочки всех неудачных загрузок (регистрации — доля справочно) |
| B2 | приём Tempo не больше 25 % `full` и меньше, чем у `tail`; рядов Prometheus не больше 40 % `full` |
| B3 | потерь нет, трассы не отброшены до решения, пик памяти Collector не больше двух третей лимита (170 из 256 МиБ) |
| B4 | надбавка против `off`: CPU реплик на запрос не больше +25 %, p95 лёгких — не больше +3 мс, p99 — не больше +10 мс |
| B5 | у сохраняемых классов каждая запись журнала с идентификатором трассы ведёт на трассу в Tempo |
**Если `balanced` не прошёл критерии** — правка задана заранее, по одному параметру на нарушение: B1 — `decision_wait` 20 с;
B2 — `probabilistic` 5 %; B3 — `decision_wait` 5 с и `num_traces` 10 000; правка — новый commit и новая метка того же профиля
целиком (`baseline-balanced2`), первая остаётся записью. B4 правилами Collector не лечится: тогда отчёт называет цену
`balanced` в приложении равной `full` и рекомендует выбор в голове с долей из данных `head` для большей нагрузки — без
пересъёмки. B5 следует из B1.
**Рабочий стенд остаётся со 100 % трасс** и полным набором рядов: проверки уровней 3–4 (`telemetry-check`, `trace-chain`,
`alerts-check`) ищут свой запрос и задание по сохранённым наблюдениям; сбалансированная конфигурация — проверяемая
рекомендация (вопрос пользователю — `QUESTIONS.md`, `## track1-telemetry-cost`, вопрос 1).
### Результаты (метка `baseline2`)
Медиана трёх повторов, в скобках — min–max; шум — |`full` − `full-aa`|, у CPU реплик на запрос он 0,0465 мс. Хост во время метки
выгрузил в swap 23 125 страниц (пометка `host_swap` у full-r1). По решению пользователя от 2026-11-15 это не повод переснимать:
свободной памяти на хосте хватает, память ВМ в swap не уходит (`QUESTIONS.md`).
**Задержки лёгких запросов (чистое окно, мс) и CPU:**
| Вариант | p50 | p95 | p99 | CPU реплик на запрос, мс | надбавка к `off` | конвейер телеметрии, ядра | пик Collector, МиБ |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `off` | 2,69 (2,68–2,71) | 4,35 (4,28–4,37) | 6,64 (6,03–7,00) | 2,154 (2,151–2,175) | — | 0 | — |
| `full` | 3,18 (2,84–3,83) | 5,93 (5,17–8,12) | 38,11 (22,99–46,45) | 2,718 (2,473–3,228) | +26 % | 0,037 | 74,3 |
| `full-aa` | 3,23 (3,16–3,47) | 6,08 (5,99–7,16) | 43,01 (34,26–48,29) | 2,764 (2,699–2,953) | +28 % | 0,040 | 72,4 |
| `head` | 2,91 (2,89–2,94) | 4,89 (4,85–5,40) | 9,28 (8,23–41,34) | 2,389 (2,386–2,498) | +11 % | 0,021 | 72,4 |
| `tail` | 3,16 (2,85–3,31) | 5,92 (5,25–6,15) | 31,36 (23,66–35,61) | 2,708 (2,475–2,813) | +26 % | 0,025 | 136,1 |
| `metrics` | 3,20 (2,83–3,25) | 5,94 (5,16–6,10) | 28,20 (20,01–37,52) | 2,723 (2,463–2,788) | +26 % | 0,037 | 73,9 |
| `balanced` | 3,21 (2,83–3,25) | 5,88 (5,22–6,11) | 37,36 (32,68–44,26) | 2,737 (2,472–2,761) | +27 % | 0,024 | 101,0 |
Ошибок у лёгких запросов нет ни в одном варианте, недосланных итераций нет. Конвейер (Collector и три хранилища) стоит
0,02–0,04 ядра: цена телеметрии — в процессах приложения, а не в сервисах телеметрии. CPU Tempo у `full` — 0,016 ядра, пик
памяти до выборки — 342 МиБ; у `head`, `tail` и `balanced` — 0,004 ядра и 108–121 МиБ. Время до `ready` во всех вариантах
одинаково: p50 0,48–0,49 с, p95 0,62–0,66 с. Готовы все принятые вложения — 452 из 452 (у `metrics` 453 из 453), все `bad`
дошли до `failed`.
**Остальные классы (чистое окно), p95, мс** — таблица `summary.md`, «Остальные классы»:
| Вариант | read | write | me | card | download | upload | upload_bad | broken | register |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `off` | 4,1 (4,0–4,1) | 5,5 (5,4–5,5) | 2,5 (2,5–2,6) | 3,1 (3,1–3,2) | 7,9 (7,8–8,2) | 28,6 (27,4–36,4) | 76,4 (33,7–97,8) | 16,1 (13,6–24,7) | 126,7 (64,0–141,2) |
| `full` | 5,6 (5,0–8,2) | 7,5 (6,7–11,0) | 3,5 (3,0–5,5) | 4,7 (3,9–6,1) | 10,5 (9,3–14,2) | 49,1 (32,4–63,2) | 56,1 (33,1–84,3) | 17,7 (16,7–21,0) | 173,6 (165,7–188,9) |
| `full-aa` | 5,8 (5,7–7,2) | 8,4 (8,2–9,8) | 3,6 (3,3–4,4) | 4,7 (4,7–5,3) | 10,8 (10,4–12,8) | 41,7 (32,8–77,3) | 72,2 (39,6–77,8) | 22,9 (20,1–28,0) | 125,5 (107,5–315,5) |
| `head` | 4,6 (4,5–5,2) | 6,5 (6,2–7,2) | 2,9 (2,8–3,2) | 3,7 (3,5–4,1) | 8,7 (8,3–9,3) | 31,1 (29,3–31,4) | 51,0 (44,3–65,2) | 19,4 (18,3–20,6) | 108,1 (54,4–123,4) |
| `tail` | 5,7 (5,0–6,0) | 7,8 (6,8–8,3) | 3,5 (3,1–3,6) | 4,2 (4,0–4,7) | 9,9 (8,6–10,8) | 35,6 (31,7–63,5) | 45,0 (34,4–52,3) | 33,2 (24,8–64,8) | 126,9 (97,9–185,7) |
| `metrics` | 5,7 (4,9–6,1) | 7,5 (6,4–8,0) | 3,5 (2,9–3,7) | 4,4 (3,9–4,4) | 10,6 (8,8–10,7) | 31,3 (31,2–36,3) | 35,9 (34,9–42,9) | 24,5 (15,5–66,5) | 129,4 (83,5–148,3) |
| `balanced` | 5,7 (4,9–5,8) | 7,3 (6,7–7,9) | 3,2 (2,9–3,5) | 4,6 (4,2–4,8) | 10,4 (9,6–10,6) | 35,2 (32,4–47,2) | 112,4 (103,0–127,7) | 18,3 (17,4–20,6) | 193,6 (110,3–210,1) |
Лёгкие классы по отдельности повторяют сводную строку: у `full` p95 выше `off` на 1–2 мс, у `head` — не больше половины этой
надбавки (у `write` — ровно половина).
У редких классов (`upload_bad`, `broken`, `register` — 0,1–0,2 в секунду, 9–18 запросов в чистом окне) p95 — почти наибольшее
значение окна, разброс повторов перекрывает различия вариантов: выводов по ним нет.
**CPU и память по компонентам** — таблицы `summary.md`, «CPU и память» (ядра, медиана и разброс) и «По компонентам» (CPU — ядра,
медиана; пик памяти — `memory.peak` за нагрузку, МиБ):
| Вариант | реплики, ядра | приложение, ядра | конвейер телеметрии, ядра | прочее, ядра |
| --- | --- | --- | --- | --- |
| `off` | 0,495 (0,495–0,500) | 0,859 (0,856–0,866) | 0,000 | 0,188 (0,185–0,189) |
| `full` | 0,626 (0,569–0,743) | 0,999 (0,932–1,140) | 0,037 (0,036–0,043) | 0,191 (0,183–0,228) |
| `full-aa` | 0,636 (0,621–0,679) | 1,013 (0,994–1,062) | 0,040 (0,038–0,040) | 0,197 (0,190–0,209) |
| `head` | 0,549 (0,549–0,575) | 0,918 (0,916–0,951) | 0,021 (0,021–0,024) | 0,192 (0,191–0,198) |
| `tail` | 0,623 (0,569–0,647) | 0,995 (0,933–1,026) | 0,025 (0,024–0,026) | 0,190 (0,181–0,199) |
| `metrics` | 0,627 (0,566–0,641) | 1,001 (0,930–1,019) | 0,037 (0,036–0,037) | 0,193 (0,182–0,198) |
| `balanced` | 0,630 (0,569–0,635) | 1,003 (0,932–1,010) | 0,024 (0,023–0,025) | 0,193 (0,181–0,195) |
| Вариант | Collector CPU / пик | Prometheus CPU / пик | Loki CPU / пик | Tempo CPU / пик |
| --- | --- | --- | --- | --- |
| `full` | 0,009 / 74,3 | 0,003 / 72,4 | 0,009 / 140,0 | 0,016 / 342,2 |
| `full-aa` | 0,009 / 72,4 | 0,003 / 63,0 | 0,009 / 150,1 | 0,017 / 317,3 |
| `head` | 0,006 / 72,4 | 0,003 / 62,8 | 0,009 / 139,1 | 0,004 / 108,3 |
| `tail` | 0,009 / 136,1 | 0,003 / 66,8 | 0,009 / 141,1 | 0,004 / 107,7 |
| `metrics` | 0,009 / 73,9 | 0,002 / 60,7 | 0,009 / 144,1 | 0,017 / 289,5 |
| `balanced` | 0,009 / 101,0 | 0,002 / 60,4 | 0,009 / 139,2 | 0,004 / 120,5 |
«Приложение» — реплики, worker и relay; «прочее» — LB, PostgreSQL, Valkey, S3, брокер, уборщик (k6 и сэмплер не входят). У
`off` сервисов телеметрии нет. CPU и память реплик, worker и прочих контейнеров по прогонам — `components.csv` метки (в сводку
по компонентам выносятся только сервисы телеметрии).
**Приём (чистое окно) и пересчёт.** Байты — то, что приняли distributor Tempo и Loki, а не сжатые блоки на диске: за 150 с
прогона на диске только журнал предзаписи (Prometheus / Loki / Tempo у `full` — 0,4 / 21,8 / 41,2 МиБ).
| Вариант | span Tempo, /с | Tempo, ГиБ за сутки / 7 суток | строк Loki, /с | Loki, ГиБ за сутки / 7 суток | отсчётов Prometheus, /с | рядов | отсчётов за сутки / 7 суток, млн |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `full` | 911 | 27,1 / 190 | 256 | 8,5 / 59 | 235 | 3 521 | 20,3 / 142 |
| `head` | 87 | 2,6 / 18 | 259 | 8,6 / 60 | 235 | 3 564 | 20,3 / 142 |
| `tail` | 110 | 3,8 / 26 | 258 | 8,5 / 60 | 238 | 3 602 | 20,6 / 144 |
| `metrics` | 911 | 27,1 / 190 | 256 | 8,5 / 59 | 36 | 502 | 3,1 / 22 |
| `balanced` | 96 | 3,2 / 22 | 259 | 8,6 / 60 | 45 | 675 | 3,9 / 27 |
**Потери по звеньям** — 0 во всех вариантах: SDK (span и записи), Collector (отказ приёма, очередь экспорта),
`dropped_too_early`. Span SDK → Collector → Tempo сходятся без расхождения: у `full` 137 868 = 137 868 = 137 868. У `tail`
Collector отправил 18 819 span из 137 868, у `balanced` — 14 442 из 137 890 по решениям выбора (сохранено 3 689 и 3 562 трассы
из ~34 690); это отброшенное выборкой, а не потеря.
**Что сохраняет каждый вариант** (сумма трёх повторов; `write_slow` — медленные по серверу записи и их трассы):
| Вариант | 500 (`broken`): трасс | `write_slow`: трасс | неудачные загрузки: цепочек | регистрации: трасс | обычные загрузки: цепочек | журнал и метрика |
| --- | --- | --- | --- | --- | --- | --- |
| `full` | 93 / 93 | 78 / 78 | 47 / 47 | 93 / 93 | 452 / 452 | 100 % |
| `head` | 10 / 92 | 10 / 75 | 5 / 48 | 9 / 93 | 58 / 452 | 100 % |
| `tail` | 93 / 93 | **74 / 75** | 46 / 46 | 12 / 93 | 452 / 452 | 100 % |
| `balanced` | 91 / 91 | 79 / 79 | 48 / 48 | 15 / 92 | 40 / 452 | 100 % |
`head` теряет около 90 % трасс любого класса, в том числе ошибок: решение принимается до того, как известен исход. Журнал и
счётчики сохраняют всё: у записи остаётся `trace_id` без бита выборки, переход журнал → трасса пустой. `tail` и `balanced`
теряют то, что их правила не называют. Это редкий быстрый маршрут (регистрация — около 10–15 %) и обычные загрузки у
`balanced`: правило по длительности server span, а не трассы, поэтому у асинхронной цепочки остаётся 10 % (40 из 452).
`tail` сохраняет все цепочки загрузок: трасса загрузки всегда длиннее 0,25 с.
**Точность квантилей** (квантиль из buckets против квантиля журнала за чистое окно). Ошибка — |buckets − журнал| / журнал,
посчитанная **в каждом прогоне**; в сводке и здесь — медиана трёх таких ошибок, а не ошибка медиан квантилей. Поэтому она не
равна отношению медиан из таблицы `summary.md`, «Точность квантилей» (например, у `default` write p95 медианы 0,0093 против
0,0064 с — это 45 %, а медиана ошибок по прогонам — 27 %).
| Ошибка, медиана по прогонам | read p95 | read p99 | write p95 | write p99 |
| --- | --- | --- | --- | --- |
| `coarse` (`metrics`) | 4,4 % | 84,8 % | 149,1 % | 82,5 % |
| `default` (`full`) | 16,9 % | 42,0 % | 26,8 % | 30,3 % |
Медианы квантилей у `coarse`: write p95 — 0,0168 с из buckets против 0,0067 с по журналу, read p99 — 0,0219 против 0,0119 с.
Грубые границы хуже вдвое и больше на трёх оценках из четырёх (H4); у read p95 квантиль из buckets в обоих наборах — 0,0050 с,
у границы 0,005 с, общей для `default` и `coarse`, поэтому набор границ на эту оценку не влияет.
**Свежесть метрик при отправке раз в 30 с** (`metrics`; следует из конфигурации, отдельной величиной метка её не мерит).
Значение доходит до Prometheus через отправку SDK и scrape экспортёра Collector раз в 15 с: возраст последней точки — до
30 + 15 = 45 с против 15 + 15 = 30 с у `full`. Счётчики cumulative, поэтому события не теряются, теряется разрешение: окно
`rate()` / `increase()` в 2 мин у правил оповещений видит ~4 разных значения вместо ~8, а оповещение срабатывает позже на время
до одного лишнего интервала (+15 с к `for`). Ряд между отправками не пропадает: срок рядов экспортёра — 1 мин, вдвое больше
интервала (решение 4, поэтому интервал больше 30 с настройки не принимают). Профиль это учитывает ожиданием после нагрузки:
50 с у `metrics` против 35 с у `full` (design, «Уточнения apply», п. 12). Панели с окном 5 мин и правила SLO (приращения за 5
мин) разницу почти не видят; при разборе инцидента по минутам последние полминуты у `metrics` не видны.
**Режим телеметрии меток загрузок и очереди.**
> **Будет заполнено на последнем шаге лабы.** Метки `make bench_uploads TELEMETRY=on` и `make bench_queue TELEMETRY=on`
> (решение пользователя: обе — с включённой телеметрией) ещё не сняты. Здесь будут: метки и commit, режим из паспорта
> (`stand.telemetry.mode` = `on`), строка режима сводок, предупреждение о сумме лимитов CPU очереди (12,25 при 12 у ВМ) и
> смешанное сравнение варианта «до» профиля загрузок (код `9cc6c0c` без SDK).
**Вердикты** (`summary.md`, «Гипотезы и критерии»):
| | Итог | Главное |
| --- | --- | --- |
| H1 | подтверждено | CPU реплик на запрос +26 % (2,718 против 2,154 мс); p50 +0,49 мс; p99 +31,5 мс, рост p99 ×5,7 против ×1,2 у p50 |
| H2 | подтверждено | надбавка `head` — 0,235 мс, 42 % надбавки `full`; приём Tempo 9,5 %; доли трасс 10/92, 10/75, 9/93, 5/48 — в интервалах около 0,1; журнал и метрика — 100 % |
| H3 | **нет** | у `tail` 74 из 75 трасс медленных по серверу записей (tail-r1: 25 из 26); остальное выполнено: CPU как у `full`, Collector 136,1 против 74,3 МиБ, его CPU тот же, приём Tempo 12,1 %, 500 — 93/93, цепочки — 46/46 и 452/452, отказов нет |
| H4 | подтверждено | рядов 14,3 %, отсчётов 15,2 % `full`; CPU реплик и Collector — в пределах шума; квантили `coarse` хуже вдвое (выше) |
| H5 | **нет** | та же трасса: `tail`, журнал → трасса у `write_slow` 74/75; у `full`, `balanced` — 100 %, у `head` — в интервалах около 0,1 |
| H6 | подтверждено | потерь 0, расхождение 0,00 % |
| H7 | **нет** | B4 не прошёл, B1, B2, B3, B5 — прошли |
| H8 | подтверждено | Tempo у `full`: 0,016 ядра против 0,009 + 0,003 у Loki и Prometheus, на диске 43,2 против 22,9 + 0,4 МБ; у `head`, `tail`, `balanced` — 0,004 ядра |
| B1 | подтверждено | 500 — 91/91, медленные по серверу записи — 79/79, цепочки `bad` — 48/48 (регистрации справочно 15/92) |
| B2 | подтверждено | приём Tempo 10,6 % `full`, меньше `tail` (96,3 против 110,3 span/с); рядов 19,2 % |
| B3 | подтверждено | потерь и отброшенных до решения нет; пик Collector 101,0 из 256 МиБ (предел 170) |
| B4 | **нет** | CPU реплик на запрос +27 % (2,737 против 2,154 мс) при пределе +25 %; p99 +30,7 мс при пределе +10; p95 +1,53 мс — в пределе |
| B5 | подтверждено | журнал → трасса: 91/91, 79/79, 48/48 |
- **B4 и H7.** Правила Collector цену в приложении не снижают: SDK создаёт и отправляет все span, и `balanced` стоит
столько же, сколько `full` и `tail` (+26–27 %). Так и было заложено правилом «если `balanced` не прошёл критерии»: B4 не
лечится настройкой Collector, пересъёмки нет. Цену в приложении снижает только выбор в голове (`head`: +11 %, p99 9,3 мс).
- **H3 и H5.** Одна трасса медленной по серверу записи из 75 при типовом tail sampling не дошла до Tempo. Её нет ни в поиске,
ни по id, а счётчики потерь SDK, Collector и `dropped_too_early` — 0. Причину установить нельзя: выборка хранит только id
недостающих трасс, длительности записей и span ушли со стендом. Порог «100 %» по правилу вывода не ослабляется, поэтому
обе гипотезы — «нет». У `balanced` правило по server span сохранило 79 из 79.
- **Пометка `saturated` у full-r3:** CPU реплики 28,4 % при нижней границе калибровки 30 %. С balanced-r3 до конца метки CPU
на запрос у вариантов с телеметрией упал примерно на 9 % (около 2,47 мс у `balanced`, `full`, `tail`, `metrics`). Это сдвиг
хоста внутри третьего круга, а не свойство варианта: круги содержат все варианты, медиана `full` — 31,3 % (в границах).
Пометка — недогрузка, а не насыщение. По правилу профиля `saturated` — повод переснять, и решение пользователя о swap
(2026-11-15) её не покрывает. Метку приняли с пометкой решением основной сессии по указанию пользователя от 2026-10-31:
предупреждения о хосте, которые явно не влияют на результат замера, прогон не останавливают (`QUESTIONS.md`,
`## track1-telemetry-cost`, «Решения основной сессии»; пересъёмка ~1 ч 25 мин — вопрос 8 там же, по умолчанию нет). Цена
решения — более широкий разброс повторов (у `full` 2,473–3,228 мс). Поэтому разница `balanced` и `full` — в пределах шума, а
не эффект.
- **Tempo на границе лимита (наблюдение).** После выборки `memory.peak` Tempo у вариантов со всеми трассами — 595–640 МиБ
из 640 (`raw/<прогон>-peaks.json`, у full-r1 — ровно 640). Пик включает page cache, контейнер жив, потерь нет. Но в первой
метке Tempo завершился посреди выборки, вероятно, по этому лимиту (design, «Уточнения apply», п. 16). Значит, при 911 span/с
и запросах поиска лимит рабочего стенда держится на краю.
**Рекомендация с условиями.**
- Рабочий стенд остаётся со всеми трассами. Его нагрузка много меньше 230 запросов/с метки, а проверки уровней 3–4 ищут
конкретный запрос. Цена при этой интенсивности — +26 % CPU реплик на запрос и +31 мс к p99 лёгких запросов. Tempo
принимает ~27 ГиБ в сутки (до сжатия), его память — у лимита.
- Если важна цена в приложении (CPU реплик, хвост задержки), нужен выбор в голове с долей 0,1. Он снимает 58 % надбавки,
p99 9,3 мс, но теряет ~90 % трасс ошибок; ошибки остаются в журнале и метриках (H2). Доля подбирается по данным `head`.
- Если важно хранилище трасс, а не CPU приложения, — `balanced`. Приём Tempo 10,6 %, рядов 19 %, все внесённые ошибки,
медленные запросы и неудачные задания сохранены, Collector — 101 из 256 МиБ при ~300 новых трассах/с. При большей
интенсивности `num_traces` и память Collector растут пропорционально. Цена в приложении — как у `full`.
- `coarse` не брать: квантили хуже вдвое. Интервал 30 с и отбор собственных рядов хранилищ — брать: ряды −80 %, CPU тот же.
- Лимит Tempo 640 МиБ поднять, если нагрузка рабочего стенда приблизится к нагрузке метки.
**Ограничения.**
- Один хост: ВМ Docker Desktop (12 CPU, 11 902 МиБ) на ноутбуке, генератор k6 — на той же ВМ и в той же сети стенда, без
лимита; его CPU делит ядра со стендом. Посторонних контейнеров во время метки не было (паспорт, `other_containers` пуст), но
остальные процессы хоста не контролируются. Сетевых задержек между машинами нет: цена экспорта по сети между хостами не
измерена.
- Лимиты контейнеров — доли CPU (квоты CFS), а не выделенные ядра: при сумме лимитов 11,25 из 12 CPU процессы конкурируют за
ядра, и шум хоста доходит до результата (сдвиг третьего круга выше).
- Данные синтетические: пользователи, чаты, сообщения и изображения стенда от зерна; длина записей журнала и число span на
запрос — как у этого API, у другого приложения цена записи и span будет иной.
- Один Collector: tail sampling видит все span трассы только потому, что экземпляр один; при нескольких нужен
`load_balancing` по `trace_id` (решение 5, отвергнуто для этого масштаба), его цена не измерена.
- Grafana не мерилась: в пути данных её нет, на стенде профиля она не запускается; на рабочем стенде её пик — ~250 МиБ
(`evidence/telemetry/budget.md`), это постоянная величина, а не результат варианта. Цена запросов панелей к хранилищам тоже
не измерена.
- Одна интенсивность ниже насыщения (~230 запросов/с на две реплики), открытая модель. Цена при насыщении и вторая точка
нагрузки не измерены (вопрос 1 ниже).
- Прогон длится 150 с: рост на диске — журнал предзаписи. Сутки и неделя — пересчёт принятых байт без сжатия блоков и без
компакции.
- Шум A/A — одна пара `full` / `full-aa` в той же метке; сдвиг хоста в третьем круге расширяет разброс, мелкие различия
вариантов с SDK (`full`, `tail`, `metrics`, `balanced`) — в пределах шума.
- Медленные записи внесены блокировкой таблицы, ошибки — строкой без объекта: это управляемые события с известным счётом,
а не естественный поток (вопрос 2 ниже).
- Причина недостающей трассы у `tail` не установлена (выше). Квантили сравниваются с квантилем журнала за то же окно, а не с
истиной клиента.
### Открытые вопросы преподавателю (трек 1)
1. Достаточно ли трёх настроек (выбор в голове 10 %, типовой tail sampling, агрегация метрик) и проверенной сбалансированной
конфигурации на одной нагрузке ниже насыщения? Иначе — вторая интенсивность (ещё одна метка ~1 ч 50 мин).
2. «Известное число» редких ошибок и медленных запросов внесено строкой вложения без объекта (500), недекодируемым JPEG
(`failed`), регистрацией и короткой блокировкой таблицы сообщений — допустимы ли такие управляемые воздействия?
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Уровень 3: Collector, хранилища, provisioning, свой запрос и задание найдены, приватность | `driver.py --port 8080 telemetry-check` | код 0: Loki → Tempo по `X-Request-Id`, трасса worker, рост счётчиков, история после рестарта хранилищ, метрики LB без доступа к сети хранилищ, панель потерь на тихом стенде — 0 | `evidence/telemetry/check.md` (commit `4a2f9c9`) |
| Телеметрия не меняет ответы и остановку | `driver.py --port 8080 telemetry-outage` | код 0: `make test` PASS и остановка < 10 с при остановленном и замороженном Collector, сигналы после его возврата без перезапуска процессов | `evidence/telemetry/collector-outage.md` (commit `15ea156`) |
| Стенд с нуля одной командой | `driver.py stand-from-scratch --runs 2` | код 0 оба раза, `RestartCount` брокера и телеметрии 0 | `evidence/stand/from-scratch.md` |
| Лимиты и бюджет телеметрии | замер `docker stats`, `memory.peak` и `memory.stat` | лимит ≥ 1,5 × пика у всех сервисов телеметрии (у Grafana пик — `anon` + `kernel` + `shmem` без файлового кэша) | `evidence/telemetry/budget.md` |
| Уровень 4: контекст W3C API → relay → worker, producer и consumer span (parent и link), цепочка одной загрузки до S3 и БД с повтором и replay | `driver.py --port 8080 trace-chain` | код 0: одна трасса, две пары producer / consumer, span S3 с ошибкой и запись оригинала и вариантов, replay в той же трассе, задание без контекста — корень worker | `evidence/telemetry/trace-chain.md` (commit `15ea156`) |
| Уровень 4: dashboard — p50 / p95 / p99, доля ошибок, глубина и возраст очереди, пул БД, насыщение worker, контейнеры | `driver.py --port 8080 trace-chain`, `telemetry-check` | запросы панелей уровня 4 без ошибок и с данными; ряды очереди только у relay; пределы = `docker inspect`; нет сокета Docker | `evidence/telemetry/trace-chain.md`, `evidence/telemetry/check.md` |
| Уровень 4: relay с SDK не меняет остановку | `driver.py --port 8080 telemetry-outage` | `docker stop` relay < 10 с, код 0, «Stopped relay» при остановленном и замороженном Collector | `evidence/telemetry/collector-outage.md` |
| Уровень 4: схема контекста задания | миграция с нуля, повтор, откат, `--sql`, `make rolling_update`; план снимка очереди | `lock_timeout`, `NOT VALID`; без Seq Scan | `evidence/migrations/job-trace-context.md`, `evidence/telemetry/queue-snapshot.md` (commit `72cfa9a`) |
| Уровень 4: alert rules с runbooks в git, модульные тесты правил | `make alerts_test` | код 0: `promtool check config`, `check rules`, `test rules` (22 блока синтетических рядов: 43 проверки оповещений, 17 проверок выражений правил записи в 7 блоках); у каждого из 7 оповещений есть runbook; контроли — изменённый порог и правило потерь без нуля процесса SDK дают красный прогон | `evidence/alerts/rules-test.md` (commit `ef60b47`) |
| Уровень 4: SLI/SLO и окно, firing / resolved искусственным отказом, разбор двух инцидентов | `driver.py --port 8080 alerts-check` | код 0 (~18 мин): pending / firing / снятие — остановленный worker 84 / 144 / 29 с; relay — 69 / 190 / 45 с; медленная БД — 75 / 135 / 74 с; медленный handler — оповещения нет; недоступная БД — 29 и 44 / 59 и 105 / 30 и 135 с; лишних нет; SLI в тех же окнах — 0–0,085 п. п., одним окном часа — 0,58 и 0,066 п. п. | `evidence/alerts/check.md` (commit `ef60b47`) |
| Уровень 4: memory limiter, batch, ограниченная буферизация, недоступный backend, учёт потерь | `driver.py --port 8080 backend-outage` | код 0 (~16 мин): `make test` PASS и 5xx 0 при остановленных Loki, Tempo, Prometheus и Collector; Collector ≤ 91 МиБ из 256, реплики без роста; потери учтены (441 запись, 1336 span, SDK +11 602 и +11 551) и видны на панели потерь; `TelemetryTargetDown` и `TelemetryDataLoss` — firing и снятие | `evidence/telemetry/backend-outage.md` (commit `ef60b47`) |
| Выбранный трек 5: трек 1 «Цена наблюдаемости» | `make bench_telemetry` (защита — `make bench_telemetry_quick VARIANTS=off,full,tail`, ~10 мин) | метка `baseline2`, 21 прогон из 21, код 0: `full` против `off` +26 % CPU реплик на запрос, +31 мс к p99; `head` +11 %; `tail` и `balanced` — приём Tempo 12,1 % и 10,6 %, Collector 136 и 101 МиБ, цена в приложении как у `full`; потерь 0; H1, H2, H4, H6, H8 подтверждены, H3, H5, H7 — нет (одна трасса из 75 у `tail`, B4); B1–B3, B5 прошли | `evidence/telemetry-cost/baseline2/summary.md` (код `68e14b6`, метка — commit `0f5dbfc`) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
**Наблюдаемость** — подробно в разделах «Ограничения наблюдаемости», «Ограничения уровня 4» и
«Ограничения» трека 1; главное:
- **Отказ Collector дольше очередей SDK теряет данные.** Очереди SDK ограничены (2048 span и 2048
записей), Collector копит в очередях экспорта не больше 16 МиБ журналов и 8 МиБ трасс и повторяет 30 с;
дальше — потеря, она посчитана (`telemetry:lost_items:total`, панель потерь, `TelemetryDataLoss`), но
не восполняется. Метрики cumulative: теряется разрешение, а не события.
- **OTLP без аутентификации и TLS** — до лабы 7: Collector принимает от любого контейнера сети `default`.
- **Ответы LB и процессы без SDK.** CPU и память — только у процессов с SDK, из их cgroup; ответы
HAProxy видны его метриками, но не в трассах; входящий `traceparent` клиента не продолжается.
- **Счётчики после быстрого перезапуска процесса.** Время начала рядов по protobuf закрывает
недосчёт `increase()` после рестарта, кроме перезапуска того же процесса быстрее ~75 с (срок рядов
экспортёра 1 мин).
- **Рабочий стенд хранит все трассы.** Сбалансированная конфигурация трека 1 (`bench/otel/`) проверена,
но рабочий стенд на неё не переведён: проверки уровней 3–4 ищут свой запрос (вопрос 1
`## track1-telemetry-cost` в `QUESTIONS.md`). У типового tail sampling одна трасса медленной записи из 75
не найдена, причина не установлена.
- **Пороговые оповещения, без burn-rate и доставки.** Трек 2 не выбран: оповещения — пороговые с окнами
2 мин, Alertmanager не ставится, состояние firing / resolved — в Prometheus и Grafana.
- **Бюджет ВМ.** Сумма лимитов CPU с разовыми сервисами (12,5) больше CPU ВМ (12): это конкуренция, а
не отказ; у профиля очереди с телеметрией — 12,25 при 12 (предупреждение в паспорте метки).
**Дефекты, найденные попутно и не исправленные** (`KNOWN_ISSUES.md`, 11 записей, у каждой —
предложение правки): смесь версий при замене реплик на первый релиз с обработкой; bootstrap после
удаления bucket на маленьком диске; уборщик удаляет объект зависшей загрузки по ключу вне своего
префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`; ложный
FAIL `reconcile-cycle` на наполненном стенде; 504 LB вместо 503 на метаданных и скачивании при зависшем
PostgreSQL; память S3 на долго живущем стенде; граница живой загрузки уборщика без закрытия соединения;
400 текстом uvicorn на нестандартный метод; остановка API при замороженном PostgreSQL дольше срока
контейнера.
**Ограничения прежних уровней** (лаба 5, раздел «Ограничения и следующие шаги» её отчёта) действуют:
отказ S3 дольше бюджета повторов переводит задания в `failed` (возврат — `make replay`), восстановление
после KILL worker — по аренде до 70 с, at least once с дублями без второго эффекта, изоляция секретов
процесса обработки неполная, предел незавершённых заданий считает задания, а не байты.
**Что подтверждено замером, а что нет.** Подтверждено: цена полной телеметрии и вариантов выбора трасс и
агрегации на одной нагрузке (метка `baseline2`), поведение при отказе каждого хранилища и Collector,
оповещения на искусственных отказах, свойства лаб 4 и 5 с включённой телеметрией (метки последнего шага,
раздел «Эксперименты и отказы»). Не измерено: телеметрия под насыщением и на второй интенсивности,
многочасовые и многодневные прогоны (рост хранилищ — только по журналу предзаписи), сбалансированная
конфигурация на рабочем стенде.
**Следующие шаги.** Лаба 7 — TLS / mTLS и секреты из OpenBao, в том числе OTLP с аутентификацией;
вне курса — учёт отказов Tempo после distributor в выборке трека 1, OTLP-приёмник Prometheus вместо
scrape, `PR_SET_DUMPABLE=0` у worker.
## Источники, библиотеки и использование ИИ
**Документация:** из `README.md` задания — [OTel Collector configuration](https://opentelemetry.io/docs/collector/configuration/),
[OTel propagation](https://opentelemetry.io/docs/concepts/context-propagation/),
[W3C Trace Context](https://www.w3.org/TR/trace-context/), [Prometheus histograms](https://prometheus.io/docs/practices/histograms/),
[Grafana provisioning](https://grafana.com/docs/grafana/latest/administration/provisioning/); ещё OpenTelemetry semantic conventions
(HTTP, database, messaging — span producer / consumer, parent и link; `db.client.connection.*`), документация
OpenTelemetry Python SDK, `tail_sampling` processor Collector contrib, Prometheus — recording и alerting rules,
`promtool test rules`, `created-timestamp-zero-ingestion`; Loki — OTLP ingestion и structured metadata; Tempo —
TraceQL. Источники лаб 2–5 — в их отчётах. Поведение SDK, Collector
и хранилищ проверено пробами: таблицы «Пробы» и «Уточнения apply» в `design.md` четырёх change
(`openspec/changes/archive/`).
**Библиотеки:** новые — `opentelemetry-api`, `opentelemetry-sdk`, `opentelemetry-exporter-otlp-proto-http`
1.45.2 (semantic conventions 0.66b2); библиотек автоинструментирования нет (инструментирование вручную в
единственных точках вызова: `instrumentation-sqlalchemy` требует `sqlalchemy<2.1`, а в lock 2.1.1). Образы
— OTel Collector contrib 0.164.0, Prometheus v3.15.1, Loki 3.7.9, Tempo 3.1.1, Grafana 13.3.1, тег и digest
индекса в `docker-compose.yml`. Остальное — `uv.lock`.
**ИИ.** Код, тесты, конфигурации, инструменты, спеки, снятие доказательств и этот отчёт сделаны с помощью
Claude Code (Anthropic) по циклу OpenSpec: предложение, реализация, проверка, правки по проверке, архивация;
каждую стадию вёл отдельный агент, основная сессия принимала результат и коммитила. Последний шаг (evidence
исключений, полные проверки, проверка из чистого clone, CI, этот отчёт) — тоже агентом, с контрольными
точками для коммитов. Выбор оценки, трека, хранилищ, числа change уровня 4 и режима телеметрии меток
последнего шага — решения автора (`QUESTIONS.md`, «Ответы пользователя перед прогоном»); решения и
отвергнутые варианты — `design.md`, принятые без пользователя — `QUESTIONS.md`. Каждый файл `evidence/`
снят командой из его шапки на стенде этой лабы, а не сгенерирован; числа в отчёте перенесены из выводов
команд на названном commit.