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

141 KiB
Raw Blame History

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

  • Автор, группа: TODO
  • Целевая оценка; выбранный трек 5, если нужен: TODO
  • Commit/PR: TODO после публикации
  • Использованные источники, библиотеки и помощь ИИ: TODO

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

TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.

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

клиент → 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, OTel propagation, W3C Trace Context, Prometheus histograms, Grafana 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.