diff --git a/.claude/rules/balancer.md b/.claude/rules/balancer.md index 7fcd885..193406a 100644 --- a/.claude/rules/balancer.md +++ b/.claude/rules/balancer.md @@ -117,6 +117,16 @@ paths: /lb/ready` (503, если готовых реплик нет). Только внутри сети compose, наружу не публикуется; оператору — `make lb_stats` (CSV читается изнутри контейнера LB). +- С design change `slo-alerts` (решение 2) там же `/metrics` — встроенный + экспортёр Prometheus (`http-request use-service prometheus-exporter`). + Забирает его **только Collector** (приёмник `prometheus/haproxy`, + `scope=frontend&scope=backend`, отбор имён в `collector.yaml`), Prometheus + получает ряды с `job="haproxy"` у экспортёра Collector: LB не входит в + сеть `telemetry`, Prometheus — в сеть приложения. Порт не публиковать, + уровень `server` (адреса реплик в метках) не забирать. Ответы самого LB + (502, 503, 504) есть только здесь — на них стоит SLI доступности; новое + имя прокси (`entry`, `api`) — правка правил `infra/otel/prometheus/rules.yml` + и панелей вместе с конфигом. - Журнал — `log stdout`, `option httplog` + `option dontlog-normal`: успешные запросы не пишутся, ошибки, повторы (`+N` в поле retries), перенаправления и смена состояния реплик — пишутся. `nbthread` равен diff --git a/.claude/rules/docker.md b/.claude/rules/docker.md index 84e5d84..e61764e 100644 --- a/.claude/rules/docker.md +++ b/.claude/rules/docker.md @@ -427,9 +427,19 @@ Design change `otel-telemetry`, решения 1, 7, 14–20; правила к (`telemetry.md`, «Что считать пиком»). У Tempo пик упирается в `GOMEMLIMIT` (398 из 400 МиБ): его лимит — не меньше 1,5 × `GOMEMLIMIT`, а не «`GOMEMLIMIT` — 80 % лимита» (design change `otel-telemetry`, «Уточнения - apply», п. 19). До ВМ остаётся 254 МиБ: новый сервис или поднятый лимит — с пересчётом. Соединений PostgreSQL телеметрия не добавляет. -- **CI** — `configs` для семи файлов, у Prometheus, Loki и Tempo `volumes: !override` с одним - именованным volume, у Collector и Grafana `volumes: !reset []`, порт Grafana `!reset []`. + apply», п. 19). До ВМ 7934 МиБ оставалось 254 МиБ; с 2026-11-11 ВМ — 11 902 МиБ (ниже, change + `slo-alerts`). Новый сервис или поднятый лимит — с пересчётом. Соединений PostgreSQL телеметрия не добавляет. +- **CI** — `configs` для восьми файлов (с design change `slo-alerts` — ещё `prometheus_rules`, + `CI_PROMETHEUS_RULES`), у Prometheus, Loki и Tempo `volumes: !override` с одним + именованным volume, у Collector и Grafana `volumes: !reset []`, порт Grafana `!reset []`. Шаг + `make alerts_test` — файлы правил через `tar` в одноразовый контейнер, без bind mount. +- **С design change `slo-alerts`** (решения 1, 3, 6, 13): у Prometheus — флаг + `--enable-feature=created-timestamp-zero-ingestion` и второй bind mount + `infra/otel/prometheus/rules.yml` (длинной записью, `read_only`); runbooks и `rules.test.yml` в + контейнер не монтируются. Новых сервисов и портов нет: Alertmanager отвергнут по функции. + Суммы лимитов и ВМ — пункт «Суммы» выше с пересчётом в `evidence/telemetry/budget.md` (раздел + change `slo-alerts`); ВМ с 2026-11-11 — 12 CPU / 11 902 МиБ (пользователь увеличил память + Docker Desktop до 12 ГБ): с одноразовыми и стендом `make test_isolated` рядом запас есть. ## Обновление кода на стенде diff --git a/.claude/rules/telemetry.md b/.claude/rules/telemetry.md index ba62e3e..d1596f2 100644 --- a/.claude/rules/telemetry.md +++ b/.claude/rules/telemetry.md @@ -9,7 +9,8 @@ paths: Спеки `observability`, `service-logging` («Связь записей с трассой», «Журнал в хранилище логов»), `service-configuration` («Параметры телеметрии»), `graceful-shutdown` («Остановка при недоступном Collector»); решения — design change `otel-telemetry` (номера ниже без пометки) и -`job-trace-propagation` («JTP-n»). Здесь то, что легко нарушить. +`job-trace-propagation` («JTP-n»), `slo-alerts` («SA-n»: SLI и SLO, правила и runbooks, +буферизация Collector, учёт потерь). Здесь то, что легко нарушить. ## SDK в процессе (`src/infra/telemetry/`) @@ -81,6 +82,15 @@ paths: - **Исход доставки** (решение 11) называет сервис (`JobDeliveryOutcome`), действие с сообщением выводится из него; span и histogram пишет точка входа после места конкуренции, `error` — у непредвиденного исключения. +- **Внутренние метрики SDK** (design change `slo-alerts`, «SA-n» ниже, SA-8, SA-9): `sdk.build()` + сначала собирает `MeterProvider`, затем процессоры span и журнала и экспортёры OTLP span и журнала + с `meter_provider=` этого провайдера — внутри `_internal_metrics()`, который ставит + `OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED` (`TELEMETRY_SDK_INTERNAL_METRICS_ENV`) только на время + их конструирования: другого выключателя в SDK 1.45 нет, внешнее значение уже удалено + `remove_otel_environment`. Читатель метрик и провайдеры строятся вне окна — своих метрик у них + нет. Гистограммы SDK (`TELEMETRY_SDK_DROPPED_HISTOGRAMS`) — `DropAggregation`. Новый процессор + или экспортёр — тоже в окне и с провайдером, иначе его потери не считаются. Быстрый тест SDK + OTLP — `Exporters(spans=None, logs=None, …)` и подставная `requests.Session.send`. ## Конфигурации (`infra/otel/`) @@ -105,6 +115,28 @@ paths: «Saturation», JTP-14); после правки файла — `docker compose restart grafana`: bind mount файла после замены редактором может показывать прежний inode. Встроенные источники с backend, кроме трёх, выключены (`GF_PLUGINS_DISABLE_PLUGINS`), установка плагинов из сети — тоже. +- **Collector с change `slo-alerts`** (SA-2, SA-6, SA-7): приёмник `prometheus/haproxy` (цель + `haproxy:8404`, `scope` frontend и backend, отбор имён `metric_relabel_configs`) в pipeline + `metrics` — единственное исключение из «только OTLP»; экспорт в Loki и Tempo — `sending_queue` + `sizer: bytes` (16 и 8 МиБ), `block_on_overflow: false`, `retry_on_failure` 1 / 5 / 30 с; + пакет обязан помещаться в очередь (больший отклоняется целиком): у логов свой `batch/logs` + 256 / 256, у трасс и метрик `send_batch_max_size: 1024`. Экспортёр `prometheus` — + `metric_expiration: 1m`. Собственные метрики Collector — без `_total` и без времени начала. +- **Prometheus с change `slo-alerts`** (SA-1, SA-3, SA-4, SA-6, SA-9): правила записи и оповещения + — `infra/otel/prometheus/rules.yml` (bind mount и `configs` CI), тесты — `rules.test.yml` (`make + alerts_test`: `promtool` в одноразовом контейнере через `tar`, затем проверка `runbook_url`), в + контейнер не монтируются. Новое оповещение — правило с `for`, `severity`, `summary`, + `description` с `$value`, `runbook_url` на `infra/otel/runbooks/<имя>.md`, тест срабатывания, + порога, «без трафика» и снятия (в `exp_annotations` — все аннотации дословно). Блока `alerting` + нет: доставки нет, Alertmanager отвергнут по функции (SA-3). Флаг + `created-timestamp-zero-ingestion`, у цели `otel-collector-exporter` — protobuf первым, глобально + — прежний текстовый список Prometheus 3: время начала нужно только экспортёру Collector. + Потери — правило `telemetry:lost_items:total` (сумма по процессу, не `increase()`); новое + место потерь — его составляющая. `le` в запросах — как в хранилище (`"0.25"`, `"30.0"`). +- **Панели с change `slo-alerts`** (SA-10): строки «SLO and alerts», «Load balancer», «Telemetry + pipeline», id с 25. Ряд, которого может не быть (оповещения, потери, 5xx API), — `… or on() + vector(0)`: обход панелей драйвером требует данных. Макрос `$__range` драйвер подменяет на + `1h` (`panel_expr`); другие макросы Grafana в запросах не использовать. - **Сети и порты** (решение 17): хранилища и Grafana — только в сети `telemetry`, Collector — в обеих; наружу — только Grafana на `127.0.0.1`. Сервисы приложения не ждут сервисов телеметрии (`depends_on` нет). @@ -124,6 +156,7 @@ paths: ## Проверки `driver.py --port telemetry-check`, `telemetry-outage`, `trace-chain` (JTP-16), +`alerts-check`, `backend-outage` (SA-11), `make alerts_test`, `stand-from-scratch` (решение 21; `SKILL.md` скилла `run-mtusi-messenger`), быстрые тесты `service-tests/unit/test_telemetry.py`, `service-tests/db/test_telemetry_db.py`, `service-tests/db/test_pool_counts.py`. Консоль, `make test_isolated`, стенд отказов и `bench/` — diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index 16e51ac..6a4f662 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -477,8 +477,62 @@ python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 telemetry-check python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 telemetry-outage # ~3 мин python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 trace-chain # ~5 мин python3 .claude/skills/run-mtusi-messenger/driver.py stand-from-scratch --runs 2 # ~1 мин на прогон +make alerts_test # секунды, без стенда +python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 alerts-check # ~25 мин +python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 backend-outage # ~18 мин ``` +- **`make alerts_test`** (design change `slo-alerts`, решение 11) — правила Prometheus без стенда + и сети: `tar` файлов `infra/otel/prometheus/` в одноразовый контейнер образа Prometheus из + `docker-compose.yml` (`--network none`), `promtool check config`, `check rules`, `test rules + rules.test.yml`; затем у каждого оповещения есть `runbook_url`, и файл runbook есть в git. +- **`alerts-check`** — учения на рабочем стенде, всё через HTTP API Grafana (источник-прокси + Prometheus: `/api/v1/rules` раз в 5 с — моменты pending, firing и снятия). Предусловия: группы + `messenger-sli`, `messenger-slo`, `messenger-alerts`, `telemetry-alerts` загружены без ошибок, + правила видны в Grafana (`/api/prometheus/prometheus/api/v1/rules`), правка через ruler Grafana + отклонена, адресов доставки нет; оповещений в pending и firing нет 5 мин — иначе код 2 «stand is + not quiet». Фоновая нагрузка драйвера (`DriverLoad`: 6 потоков отправки сообщения с новым ключом + раз в 0,25 с и 1 чтения истории раз в 1 с, ответы по классам и `X-Instance-Id` на стороне + клиента). + Шаги: 1) `docker compose stop worker`, 3 загрузки — `MessengerQueueLagHigh` ≤ 4 мин, глубина + `outbox` + `published` +3, consumer span после остановки нет, последняя запись worker в Loki; + worker стоит не меньше 130 с (ряды процесса ушли), `docker start` — все `ready`, снято ≤ 2 мин, + счёт `messenger_job_time_to_ready_seconds_count` по точкам (без экстраполяции, первая точка — + ноль времени начала нового процесса) +3; 2) `docker compose stop relay` — ряды глубины уходят + ≤ 2 мин, `MessengerQueueMetricsMissing` ≤ 5 мин, `docker start` — снято ≤ 2 мин; 3) сессия psql + `application_name = mtusi-alerts-check` циклами держит `LOCK TABLE messages IN SHARE MODE` 2 с с + паузой 0,2 с — `MessengerSlowRequests` ≤ 3 мин, медиана доли span PostgreSQL в медленных трассах + отправки > 0,5, пул занят больше, чем до шагов, CPU реплик < 0,5 предела; сессия завершена + (`pg_terminate_backend`) — снято ≤ 4 мин; 4) 3 потока входят по Basic 45 с — медиана доли span + PostgreSQL в трассах входа < 0,2, свободное место в пуле ждать не пришлось (доля занятых < 1, + отказов по сроку 0; `pending` — наблюдение), p95 входа > 0,25 с, + `MessengerSlowRequests` не стало pending; 5) `docker compose stop postgres` — + `MessengerNoReadyReplicas` и `MessengerHighErrorRate` ≤ 3 мин, готовых реплик 0, 5xx LB больше + 5xx API и не меньше 503 самого LB у клиента, доля 5xx LB = доля клиента ± 5 п. п.; `docker + compose start postgres` — сняты ≤ 4 мин (`MessengerQueueMetricsMissing` в pending допустим); + 6) SLI за 7 суток в [0, 1], за час — по рядам правил и по исходным счётчикам: сумма + `increase(…[5m])` на время каждой точки `messenger-slo` (≤ 1 п. п.; рядом — `increase` за час + одним окном и число окон за час: пока Prometheus стоял, окон нет), перед шагами — 20 загрузок + при работающем worker (хорошие события времени до `ready`), SLI за окно учений, запросы панелей с id от 25 с данными, + панель истории состояний показывает firing всех шагов; пики памяти Prometheus и Collector. На + каждом шаге — «other alerts firing» (лишних нет). В `finally` — нагрузка остановлена, сессия + блокировки завершена, PostgreSQL запущен, worker и relay — `docker start` тех же контейнеров, LB + готов. Код 0 / 1 / 2. +- **`backend-outage`** — та же нагрузка и опрос правил; память раз в 2 с (`memory.current` реплик + через `docker exec … cat`, Collector — `docker stats`: в образе нет оболочки). Loki и Tempo по + очереди: 10 с (свой запрос находится в хранилище после возврата, счётчики `send_failed` / + `enqueue_failed` экспортёра не выросли) и 120 с (`make test` PASS, 5xx у клиента 0, очередь + экспорта ≤ ёмкости, память Collector ниже лимита, `TelemetryTargetDown{job=…}` ≤ 110 с, + `TelemetryDataLoss` firing, потери Collector > 0, новые сигналы после возврата, оба сняты ≤ 4 + мин); Prometheus 60 с (5xx 0, приращение счёта запросов API между точками до и после не меньше + запросов нагрузки); Collector 120 с (`make test` PASS, `TelemetryTargetDown` firing, память + каждой реплики: максимум последней трети окна не выше первой больше чем на 16 МиБ и ниже + лимита, `MessengerQueueMetricsMissing` не pending; после возврата — снято, счётчики потерь SDK + реплик выросли, ёмкость очередей SDK 2048, записей Loki в окне меньше stdout). В конце — пики + памяти Collector, Prometheus и реплик по cgroup (`memory.peak`, `anon` + `kernel` + `shmem`, + `file`, лимит — для бюджета). В `finally` — сервисы телеметрии запущены, worker и relay. Код 0 / + 1 / 2. + - **`trace-chain`** — сквозная трасса загрузки и сигналы уровня 4, всё через HTTP API Grafana: 1) предусловие — глубина очереди 0 в Prometheus за 120 с (не дождались — код 2 «stand is not quiet»: незавершённые задания других прогонов), `docker compose stop worker`, три загрузки — diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index 953a8f9..c4a81cb 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -267,6 +267,28 @@ контейнеров = docker inspect, нет сокета Docker, один источник очереди, панели уровня 4 с данными; в finally — unpause s3, start worker relay; код 1 при расхождении, 2 — нет стенда + alerts-check только стенд с LB и телеметрией (design change slo-alerts, + решение 11, ~25 мин), всё через HTTP API Grafana: правила + загружены, доставки нет; тихий стенд (иначе код 2); фоновая + нагрузка драйвера (6 потоков отправки с ключом, 1 чтения); 1) + worker остановлен, 3 загрузки — MessengerQueueLagHigh, запуск — + снято, ready, счёт времени до готовности по точкам +3; 2) relay + остановлен — ряды очереди уходят, MessengerQueueMetricsMissing, + запуск — снято; 3) медленная БД (LOCK TABLE messages IN SHARE + MODE циклами 2 с) — MessengerSlowRequests, доля span PostgreSQL, + пул, CPU; 4) входы по Basic — span PostgreSQL короткие, пул + свободен, оповещения нет; 5) PostgreSQL остановлен — + MessengerNoReadyReplicas и MessengerHighErrorRate, 5xx LB против + API; 6) SLI двумя путями, панели с id от 25; в finally — нагрузка, + сессия блокировки, PostgreSQL, worker, relay, LB; коды 0 / 1 / 2 + backend-outage только стенд с LB и телеметрией (~18 мин): под той же + нагрузкой Loki и Tempo — 10 с (запрос находится, потерь нет) и + 120 с (make test, очередь ≤ ёмкости, память Collector, потери, + TelemetryTargetDown и TelemetryDataLoss firing и снятие), + Prometheus 60 с (счёт запросов не меньше нагрузки), Collector + 120 с (make test, память реплик без роста, потери SDK, записей + Loki меньше stdout); пики памяти по cgroup; в finally — сервисы + телеметрии, worker, relay; коды 0 / 1 / 2 stand-from-scratch [--project P] [--runs 2] свой проект compose (по умолчанию mtusi-lab6-scratch; имя не по шаблону ^mtusi-lab6-scratch(-[a-z0-9]+)?$ — код 2 до вызовов docker: @@ -9500,6 +9522,8 @@ PROMETHEUS_JOBS = ( "loki", "tempo", "prometheus", + # метрики LB через приёмник Collector (design change slo-alerts, решение 2) + "haproxy", ) API_SERVICE_NAME = "messenger-api" WORKER_SERVICE_NAME = "messenger-worker" @@ -9959,6 +9983,101 @@ def targets_up(grafana: Grafana) -> dict[str, str]: return {job: str(up.get(job, "absent")) for job in PROMETHEUS_JOBS} +# окно макроса Grafana `$__range` в запросах панелей, которые драйвер выполняет +# мгновенным запросом (design change slo-alerts, решение 10) +PANEL_RANGE = "1h" +# метрики LB: публичный frontend, порт статистики, сколько запросов проверки +LB_FRONTEND = '{job="haproxy",proxy="entry"}' +LB_STATS_PORT = 8404 +LB_PROBE_REQUESTS = 20 + + +def panel_expr(expr: str) -> str: + """Запрос панели без макросов Grafana: `$__range` — `PANEL_RANGE`.""" + return expr.replace("$__range", PANEL_RANGE) + + +def lb_metrics_rows(port: int, grafana: Grafana) -> list[tuple[str, str, str]]: + """Сценарии `observability` «Метрики балансировщика без доступа к сети + хранилищ» и `load-balancing` «Метрики балансировщика»: LB только в сети + приложения, порт статистики не опубликован, у Prometheus нет цели LB, ряды + `haproxy_*` с `job="haproxy"` есть, N запросов через LB — счёт ответов + frontend вырос не меньше чем на N.""" + rows: list[tuple[str, str, str]] = [] + config = json.loads(compose("config", "--format", "json")) + lb = config["services"]["haproxy"] + rows.append( + ( + "LB networks", + "['default']", + str(sorted(lb.get("networks") or {})), + ), + ) + published = sorted( + int(item.get("target", 0)) + for item in lb.get("ports") or [] + if item.get("published") + ) + rows.append( + ( + "LB stats port published on host", + "no", + yes(LB_STATS_PORT in published), + ), + ) + status, targets = grafana.proxy("prometheus", "/api/v1/targets") + urls = [ + str(item.get("scrapeUrl", "")) + for item in ( + targets.get("data", {}).get("activeTargets", []) + if isinstance(targets, dict) + else [] + ) + ] + rows.append( + ( + "prometheus has an LB target", + "no", + yes(status != 200 or any("haproxy" in url for url in urls)), + ), + ) + names = { + str(item["metric"].get("__name__")) + for item in grafana.prom('{job="haproxy",__name__=~"haproxy_.*"}') + } + rows.append( + ( + "LB series with job haproxy (frontend, backend, ready)", + "yes", + yes( + { + "haproxy_frontend_http_responses_total", + "haproxy_backend_http_responses_total", + "haproxy_backend_active_servers", + } + <= names, + ), + ), + ) + expr = f"sum(haproxy_frontend_http_responses_total{LB_FRONTEND})" + before = grafana.prom_sum(expr) + for _ in range(LB_PROBE_REQUESTS): + call(port, "GET", "/health/live") + grew = poll( + lambda: grafana.prom_sum(expr) - before >= LB_PROBE_REQUESTS, + timeout=METRIC_WAIT_S, + interval=5, + ) + rows.append( + ( + f"LB frontend responses grew by {LB_PROBE_REQUESTS} or more", + "yes", + yes(bool(grew)), + ), + ) + return rows + + def loki_request( grafana: Grafana, request_id: str, @@ -10234,7 +10353,7 @@ def telemetry_check(port: int, grafana: Grafana, paused: list[str]) -> int: yes(isinstance(again, dict) and again["dashboard"]["title"] == title), ) expressions = [ - target["expr"] + panel_expr(target["expr"]) for panel in model.get("panels", []) for target in panel.get("targets", []) if (target.get("datasource") or {}).get("uid") == "prometheus" @@ -10242,6 +10361,9 @@ def telemetry_check(port: int, grafana: Grafana, paused: list[str]) -> int: up = targets_up(grafana) for job, value in up.items(): step(f"prometheus target {job} up", "1", value) + # метрики LB (design change slo-alerts, решение 2) + for name, expected, got in lb_metrics_rows(port, grafana): + step(name, expected, got) # --- база метрик до своего трафика ----------------------------------- chat_route = '"/api/v1/chats/{chat_id}"' @@ -12348,7 +12470,7 @@ def level4_rows( dashboard.get("dashboard", {}) if isinstance(dashboard, dict) else {} ) expressions = [ - str(target["expr"]) + panel_expr(str(target["expr"])) for panel in model.get("panels", []) if panel.get("id", 0) >= LEVEL4_FIRST_PANEL or "0.99" in json.dumps(panel) @@ -12609,6 +12731,2072 @@ def scratch_run( return rows +# --- SLO, оповещения и отказ хранилищ телеметрии (design change slo-alerts, +# решение 11) ----------------------------------------------------------------- + +AC_RULE_GROUPS = ( + "messenger-sli", + "messenger-slo", + "messenger-alerts", + "telemetry-alerts", +) +AC_ALERTS = ( + "MessengerHighErrorRate", + "MessengerSlowRequests", + "MessengerNoReadyReplicas", + "MessengerQueueLagHigh", + "MessengerQueueMetricsMissing", + "TelemetryTargetDown", + "TelemetryDataLoss", +) +AC_STATE_RANK = {"inactive": 0, "pending": 1, "firing": 2} +# состояния оповещений — раз в 5 с по API правил Prometheus через Grafana +AC_POLL_S = 5 +# тихий стенд перед учениями и между шагами +AC_QUIET_WAIT_S = 300 +# application_name сессии блокировки: по нему она завершается в finally +AC_SESSION = "mtusi-alerts-check" +AC_LOCK_HOLD_S = 2 +# пауза короче 0,5 с design: в ней каждый поток записи успевает ~1 быстрый +# запрос, доля медленных ~0,4, порог 10 % пересекается раньше (firing было +# 165 с из 180 при паузе 0,5 с, «Уточнения apply») +AC_LOCK_PAUSE_S = 0.2 +AC_LOCK_CYCLES = 400 +AC_LOCK_SQL = f"""\ +SET application_name = '{AC_SESSION}'; +DO $$ +BEGIN + FOR i IN 1..{AC_LOCK_CYCLES} LOOP + LOCK TABLE messages IN SHARE MODE; + PERFORM pg_sleep({AC_LOCK_HOLD_S}); + COMMIT; + PERFORM pg_sleep({AC_LOCK_PAUSE_S}); + END LOOP; +END +$$; +""" +AC_UNLOCK_SQL = f"""\ +SELECT count(pg_terminate_backend(pid)) FROM pg_stat_activity +WHERE application_name = '{AC_SESSION}' AND pid <> pg_backend_pid(); +""" +# сроки спека «Проверка оповещений отказами» +AC_UPLOADS = 3 +AC_GOOD_UPLOADS = 20 +AC_WORKER_DOWN_MIN_S = 130 +AC_LAG_FIRING_S = 240 +AC_LAG_CLEAR_S = 120 +AC_RELAY_FIRING_S = 300 +AC_RELAY_SERIES_GONE_S = 120 +AC_RELAY_CLEAR_S = 120 +AC_SLOW_FIRING_S = 180 +AC_SLOW_CLEAR_S = 240 +AC_DB_FIRING_S = 180 +AC_DB_CLEAR_S = 240 +# медленный handler: N потоков входят по Basic столько секунд, затем ещё +# окно наблюдения за MessengerSlowRequests +AC_LOGIN_THREADS = 3 +AC_LOGIN_S = 45 +AC_LOGIN_WATCH_S = 75 +# метрика доходит до Prometheus: экспорт SDK 15 с + сбор 15 с +AC_SCRAPE_LAG_S = 35 +AC_SLI_TOLERANCE = 0.01 +AC_SHARE_TOLERANCE = 0.05 +AC_TRACES = 5 +# фоновая нагрузка драйвера: запись преобладает — блокировка таблицы сообщений +# делает медленной заметную долю «лёгких» запросов (~29 % при блокировке: порог +# 10 % окна 2 мин пересекается раньше, firing — с запасом до 3 мин) +LOAD_WRITERS = 6 +LOAD_READERS = 1 +LOAD_PERIOD_S = 0.25 +LOAD_READ_PERIOD_S = 1.0 +LOAD_TIMEOUT_S = 15 +# отказ хранилищ: короткий — короче 30 с повторов Collector вместе со стартом +# хранилища, долгий — больше них; Prometheus и Collector +BO_SHORT_S = 10 +BO_LONG_S = 120 +BO_PROMETHEUS_S = 60 +BO_COLLECTOR_S = 120 +BO_SAMPLE_S = 2 +BO_GROWTH_LIMIT = 16 * MIB +# TelemetryTargetDown — пока хранилище ещё остановлено: up = 0 виден за ≤ 15 с +# сбора, for 1 мин, вычисление и слот точки по 15 с, опрос 5 с (пробный прогон +# — 90–100 с) +BO_TARGET_FIRING_S = 118 +BO_CLEAR_S = 240 +BO_LOSS_EXPORTERS = {"loki": "otlp_http/loki", "tempo": "otlp_http/tempo"} +BO_SIGNAL = {"loki": "log_records", "tempo": "spans"} +CGROUP_READ_PY = r""" +import json, sys +out = {} +for cid in sys.argv[1:]: + base = f"/sys/fs/cgroup/docker/{cid}/" + item = {} + try: + item["peak"] = int(open(base + "memory.peak").read()) + item["current"] = int(open(base + "memory.current").read()) + stat = dict(line.split() for line in open(base + "memory.stat")) + item.update({k: int(stat.get(k, 0)) for k in ("anon", "kernel", "shmem", "file")}) + except OSError as error: + item["error"] = type(error).__name__ + out[cid] = item +print(json.dumps(out)) +""" + + +class DriverLoad: + """Фоновая нагрузка драйвера через LB: потоки отправки сообщения с ключом и + чтения истории одного чата, счёт ответов по классам и времени на стороне + клиента. Токен в вывод не попадает.""" + + def __init__(self, port: int, token: str, chat_id: str) -> None: + self.port = port + self._token = token + self.chat_id = chat_id + # (время отправки, вид, класс ответа, ответ реплики, секунды) + self.events: list[tuple[float, str, str, bool, float]] = [] + self._lock = threading.Lock() + self._stop = threading.Event() + self._threads = [ + threading.Thread(target=self._run, args=(kind,), daemon=True) + for kind in ("write",) * LOAD_WRITERS + ("read",) * LOAD_READERS + ] + + def start(self) -> None: + for thread in self._threads: + thread.start() + + def stop(self) -> None: + self._stop.set() + for thread in self._threads: + thread.join(LOAD_TIMEOUT_S + 5) + + def _run(self, kind: str) -> None: + messages = f"{CHATS}/{self.chat_id}/messages" + while not self._stop.is_set(): + at, started = time.time(), time.monotonic() + try: + if kind == "write": + status, hdrs, _ = call( + self.port, + "POST", + messages, + token=self._token, + body={"text": "driver load"}, + extra=key_header(), + timeout=LOAD_TIMEOUT_S, + ) + else: + status, hdrs, _ = call( + self.port, + "GET", + f"{messages}?limit=20", + token=self._token, + timeout=LOAD_TIMEOUT_S, + ) + result, api = f"{status // 100}xx", "x-instance-id" in hdrs + except (OSError, http.client.HTTPException): + result, api = "error", False + took = time.monotonic() - started + with self._lock: + self.events.append((at, kind, result, api, took)) + period = LOAD_PERIOD_S if kind == "write" else LOAD_READ_PERIOD_S + self._stop.wait(max(0.0, period - took)) + + def window( + self, + start: float, + end: float | None = None, + ) -> list[tuple[float, str, str, bool, float]]: + end = time.time() if end is None else end + with self._lock: + return [e for e in self.events if start <= e[0] < end] + + def counts(self, start: float, end: float | None = None) -> dict[str, int]: + return dict(Counter(e[2] for e in self.window(start, end))) + + def lb_errors(self, start: float, end: float | None = None) -> int: + """5xx без `X-Instance-Id` — ответы самого LB.""" + return sum( + 1 for e in self.window(start, end) if e[2] == "5xx" and not e[3] + ) + + +def rule_states(grafana: Grafana) -> dict[str, str]: + """Состояние каждого оповещения (`inactive`, `pending`, `firing`) по API + правил Prometheus через Grafana; у `Telemetry*` — ещё по `job`.""" + status, payload = grafana.proxy( + "prometheus", + "/api/v1/rules", + {"type": "alert"}, + ) + if status != 200 or not isinstance(payload, dict): + raise RuntimeError(f"prometheus rules: {status}") + out: dict[str, str] = {} + for group in payload["data"]["groups"]: + for rule in group["rules"]: + name = str(rule["name"]) + out[name] = str(rule.get("state", "inactive")) + if not name.startswith("Telemetry"): + continue + for alert in rule.get("alerts") or []: + key = f"{name}{{job={alert['labels'].get('job', '')}}}" + state = str(alert.get("state", "inactive")) + if AC_STATE_RANK.get(state, 0) > AC_STATE_RANK.get( + out.get(key, "inactive"), + 0, + ): + out[key] = state + return out + + +class AlertWatch: + """Моменты pending, firing и снятия оповещений: опрос API правил раз в + 5 с в своём потоке, история смен состояний по ключу оповещения.""" + + def __init__(self, grafana: Grafana) -> None: + self.grafana = grafana + self.history: dict[str, list[tuple[float, str]]] = {} + self.errors = 0 + self._lock = threading.Lock() + self._stop = threading.Event() + self._thread = threading.Thread(target=self._run, daemon=True) + + def start(self) -> None: + self.poll_once() + self._thread.start() + + def stop(self) -> None: + self._stop.set() + self._thread.join(AC_POLL_S * 3) + + def _run(self) -> None: + while not self._stop.wait(AC_POLL_S): + self.poll_once() + + def poll_once(self) -> None: + try: + states = rule_states(self.grafana) + except (RuntimeError, OSError, http.client.HTTPException, KeyError): + self.errors += 1 + return + now = time.time() + with self._lock: + for key in set(self.history) | set(states): + state = states.get(key, "inactive") + entries = self.history.setdefault(key, []) + if not entries or entries[-1][1] != state: + entries.append((now, state)) + + def state(self, key: str) -> str: + with self._lock: + entries = self.history.get(key) or [(0.0, "inactive")] + return entries[-1][1] + + def first(self, key: str, state: str, since: float) -> float | None: + """Первый момент с `since`, когда у ключа было это состояние.""" + with self._lock: + entries = list(self.history.get(key) or []) + current = "inactive" + for at, value in entries: + if at <= since: + current = value + continue + if current == state: + return since + if value == state: + return at + current = value + return since if current == state else None + + def wait( + self, + key: str, + state: str, + since: float, + timeout: float, + ) -> float | None: + deadline = time.time() + timeout + while True: + found = self.first(key, state, since) + if found is not None or time.time() >= deadline: + return found + time.sleep(1) + + def fired(self, since: float, until: float | None = None) -> set[str]: + """Оповещения (без ключей по `job`), бывшие в firing в окне.""" + until = time.time() if until is None else until + with self._lock: + items = {k: list(v) for k, v in self.history.items()} + out = set() + for key, entries in items.items(): + if "{" in key: + continue + current = "inactive" + for at, value in entries: + if at <= since: + current = value + continue + if at > until: + break + if value == "firing": + out.add(key) + current = value + if current == "firing": + out.add(key) + return out + + def active(self) -> set[str]: + with self._lock: + return { + key + for key, entries in self.history.items() + if "{" not in key and entries and entries[-1][1] != "inactive" + } + + def wait_quiet(self, timeout: float) -> bool: + """Ни одно оповещение не в pending и не в firing.""" + deadline = time.time() + timeout + while True: + if not self.active(): + return True + if time.time() >= deadline: + return False + time.sleep(AC_POLL_S) + + +def rules_rows(grafana: Grafana) -> list[tuple[str, str, str]]: + """Сценарий «Правила загружены»: группы и оповещения из git загружены без + ошибок, правила источника Prometheus видны в Grafana и не правятся через + неё, адресов доставки оповещений нет.""" + rows: list[tuple[str, str, str]] = [] + status, payload = grafana.proxy("prometheus", "/api/v1/rules") + groups = ( + payload.get("data", {}).get("groups", []) + if isinstance(payload, dict) + else [] + ) + names = sorted(str(group["name"]) for group in groups) + rows.append( + ("rule groups loaded", str(sorted(AC_RULE_GROUPS)), str(names)), + ) + bad = [ + str(rule["name"]) + for group in groups + for rule in group["rules"] + if rule.get("health") not in ("ok", "unknown") or rule.get("lastError") + ] + rows.append(("rules with evaluation errors", "[]", str(bad))) + alerts = sorted( + str(rule["name"]) + for group in groups + for rule in group["rules"] + if rule.get("type") == "alerting" + ) + rows.append(("alerts loaded", str(sorted(AC_ALERTS)), str(alerts))) + status, payload = grafana.request( + "GET", + "/api/prometheus/prometheus/api/v1/rules", + ) + seen = sorted( + { + str(group.get("name")) + for group in ( + payload.get("data", {}).get("groups", []) + if isinstance(payload, dict) + else [] + ) + }, + ) + rows.append( + ( + "Grafana shows rules of the Prometheus datasource", + f"200 {sorted(AC_RULE_GROUPS)}", + f"{status} {seen}", + ), + ) + status, _ = grafana.request( + "POST", + "/api/ruler/prometheus/api/v1/rules/messenger", + body={"name": "driver-probe", "rules": []}, + ) + rows.append( + ("rule change through Grafana rejected", "yes", yes(status >= 400)), + ) + status, payload = grafana.proxy("prometheus", "/api/v1/alertmanagers") + active = ( + payload.get("data", {}).get("activeAlertmanagers") + if isinstance(payload, dict) + else None + ) + rows.append(("alert delivery addresses", "[]", str(active or []))) + return rows + + +def alert_row( + name: str, + started: float | None, + since: float, + limit: float, +) -> tuple[str, str, str]: + took = None if started is None else started - since + print( + f" {name}: " + + ("not reached" if took is None else f"after {took:.0f} s"), + flush=True, + ) + return ( + f"{name} within {limit:.0f} s", + "yes", + yes(took is not None and took <= limit), + ) + + +def prom_points( + grafana: Grafana, + selector: str, + start: float, + end: float, +) -> list[list[tuple[float, float]]]: + """Сырые точки рядов в окне: по ряду — (время, значение).""" + seconds = max(1, int(end - start)) + status, payload = grafana.proxy( + "prometheus", + "/api/v1/query", + {"query": f"{selector}[{seconds}s]", "time": f"{end:.3f}"}, + ) + if status != 200 or not isinstance(payload, dict): + raise RuntimeError(f"prometheus query: {status}") + return [ + [(float(t), float(v)) for t, v in item["values"]] + for item in payload["data"]["result"] + ] + + +def points_increase(series: list[list[tuple[float, float]]]) -> float: + """Приращение по точкам без экстраполяции: падение значения — сброс, после + него считается новое значение целиком.""" + total = 0.0 + for points in series: + for index in range(1, len(points)): + before, after = points[index - 1][1], points[index][1] + total += after - before if after >= before else after + return total + + +def window_max(grafana: Grafana, expr: str, start: float, end: float) -> float: + """Наибольшее значение выражения в окне (подзапрос с шагом 15 с).""" + seconds = max(15, int(end - start)) + return grafana.prom_sum(f"max_over_time(({expr})[{seconds}s:15s])", end) + + +def pg_shares( + grafana: Grafana, + query: str, + start: float, + end: float, +) -> list[float]: + """Доля времени span PostgreSQL под server span API в найденных трассах.""" + shares = [] + for item in grafana.search(query, start, end, limit=AC_TRACES): + status, payload = grafana.trace(str(item["traceID"])) + spans = trace_spans(payload) if status == 200 else [] + servers = [ + s + for s in spans + if s["kind"] == "SPAN_KIND_SERVER" + and (s["resource"] or {}).get("service.name") == API_SERVICE_NAME + ] + if not servers: + continue + server = max(servers, key=lambda s: float(s["duration"])) + database = sum( + float(s["duration"]) + for s in descendants(spans, str(server["id"])) + if s["attrs"].get("db.system.name") == "postgresql" + ) + if float(server["duration"]) > 0: + shares.append(database / float(server["duration"])) + return shares + + +def median(values: list[float]) -> float | None: + if not values: + return None + ordered = sorted(values) + middle = len(ordered) // 2 + if len(ordered) % 2: + return ordered[middle] + return (ordered[middle - 1] + ordered[middle]) / 2 + + +def route_p95(grafana: Grafana, at: float) -> dict[str, float]: + expr = ( + "histogram_quantile(0.95, sum by (le, http_route) " + f'(rate(http_server_request_duration_seconds_bucket{{job="{API_SERVICE_NAME}"}}[2m])))' + ) + return { + route: round(value, 3) + for route, value in grafana.prom_by(expr, "http_route", at).items() + if value == value + } + + +def queue_snapshot(grafana: Grafana) -> dict[str, float]: + depth = grafana.prom_by( + f'max by (messenger_queue_stage) (messenger_queue_depth{{job="{RELAY_SERVICE_NAME}"}})', + "messenger_queue_stage", + ) + age = grafana.prom_sum( + f'max(messenger_queue_oldest_age_seconds{{job="{RELAY_SERVICE_NAME}"}})', + ) + return {**depth, "oldest_age_s": round(age, 1)} + + +def api_cpu_expr() -> str: + job = f'job="{API_SERVICE_NAME}"' + return ( + f"max(sum by (instance) (rate(container_cpu_time_seconds_total{{{job}}}[1m]))" + f" / sum by (instance) (messenger_container_cpu_limit{{{job}}}))" + ) + + +def pool_used_expr() -> str: + return ( + f'sum(db_client_connection_count{{job="{API_SERVICE_NAME}",' + 'db_client_connection_state="used"})' + ) + + +def pool_waiting_expr() -> str: + return ( + "sum(db_client_connection_pending_requests" + f'{{job="{API_SERVICE_NAME}"}})' + ) + + +def lb_5xx_expr() -> str: + return ( + "sum(haproxy_frontend_http_responses_total" + '{job="haproxy",proxy="entry",code="5xx"})' + ) + + +def lb_total_expr() -> str: + return f"sum(haproxy_frontend_http_responses_total{LB_FRONTEND})" + + +def api_5xx_expr() -> str: + return ( + "sum(http_server_request_duration_seconds_count" + f'{{job="{API_SERVICE_NAME}",http_response_status_code=~"5.."}})' + " or vector(0)" + ) + + +def cgroup_memory(ids: list[str]) -> dict[str, dict[str, int]]: + """memory.peak, memory.current и части memory.stat контейнеров по cgroup + ВМ (одноразовый контейнер образа API, `--cgroupns host`, без сети).""" + if not ids: + return {} + proc = subprocess.run( + [ + "docker", + "run", + "--rm", + "--network", + "none", + "--cgroupns", + "host", + "--entrypoint", + "python", + "mtusi-messenger:lab6", + "-I", + "-c", + CGROUP_READ_PY, + *ids, + ], + capture_output=True, + text=True, + check=False, + timeout=60, + ) + try: + return json.loads(proc.stdout.strip().splitlines()[-1]) + except (IndexError, json.JSONDecodeError): + return {} + + +def container_limit(container: str) -> int: + out = subprocess.run( + ["docker", "inspect", "-f", "{{.HostConfig.Memory}}", container], + capture_output=True, + text=True, + check=False, + ).stdout.strip() + return int(out) if out.isdigit() else 0 + + +def print_peaks(services: tuple[str, ...]) -> None: + """Пики памяти сервисов для бюджета (`telemetry.md`, «Что считать + пиком»): memory.peak, неосвобождаемая часть и файловый кэш, лимит.""" + ids = { + container: service + for service in services + for container in service_ids(service) + } + memory = cgroup_memory(list(ids)) + for container, service in ids.items(): + item = memory.get(container, {}) + if "peak" not in item: + print(f"memory {service} {container[:12]}: {item}", flush=True) + continue + unfreeable = item["anon"] + item["kernel"] + item["shmem"] + limit = container_limit(container) + print( + f"memory {service} {container[:12]}: peak " + f"{item['peak'] / MIB:.0f} MiB, anon+kernel+shmem " + f"{unfreeable / MIB:.0f} MiB, file {item['file'] / MIB:.0f} MiB, " + f"limit {limit / MIB:.0f} MiB", + flush=True, + ) + + +def lock_session() -> subprocess.Popen: + """Сессия psql в контейнере PostgreSQL: циклы `LOCK TABLE messages IN + SHARE MODE` по 2 с с паузой 0,2 с — запись сообщений ждёт, чтение нет.""" + proc = subprocess.Popen( + ["docker", "compose", "exec", "-T", "postgres", "sh", "-c", PSQL], + cwd=ROOT, + stdin=subprocess.PIPE, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + text=True, + start_new_session=True, + ) + assert proc.stdin is not None + proc.stdin.write(AC_LOCK_SQL) + proc.stdin.close() + return proc + + +def unlock(proc: subprocess.Popen | None) -> None: + with contextlib.suppress(RuntimeError, subprocess.TimeoutExpired): + stand_psql(AC_UNLOCK_SQL) + if proc is not None and proc.poll() is None: + proc.kill() + with contextlib.suppress(subprocess.TimeoutExpired): + proc.wait(10) + + +def login_burst( + port: int, + username: str, + password: str, + seconds: float, +) -> list[float]: + """N потоков входят по Basic `seconds` секунд: длительности входов.""" + took: list[float] = [] + lock = threading.Lock() + deadline = time.monotonic() + seconds + + def run() -> None: + while time.monotonic() < deadline: + started = time.monotonic() + with contextlib.suppress(OSError, http.client.HTTPException): + call( + port, + "POST", + SESSIONS, + authorization=basic(username, password), + timeout=LOAD_TIMEOUT_S, + ) + with lock: + took.append(time.monotonic() - started) + + threads = [ + threading.Thread(target=run, daemon=True) + for _ in range(AC_LOGIN_THREADS) + ] + for thread in threads: + thread.start() + for thread in threads: + thread.join(seconds + LOAD_TIMEOUT_S + 5) + return took + + +def cmd_alerts_check(port: int) -> int: + """Спеки `observability` «Проверка оповещений отказами», «SLI и SLO», + «Правила оповещений», «Счётчики после перезапуска процесса», «Ответы + балансировщика в метриках», «Панели SLO, оповещений и конвейера» (design + change `slo-alerts`, решение 11): под своей нагрузкой — остановленный + worker, остановленный relay, медленная БД, медленный handler, недоступная + БД; firing и снятие по API правил через Grafana, наблюдения для разбора + инцидентов. Стенд возвращается в `finally`.""" + if not stand_answers(port, "alerts-check"): + return 2 + grafana = Grafana() + if not grafana_ready(grafana): + print(f"alerts-check: no Grafana on 127.0.0.1:{grafana.port}") + return 2 + state: dict[str, object] = {} + + def body() -> int: + try: + return alerts_check(port, grafana, state) + finally: + with signals_ignored(): + load = state.get("load") + if isinstance(load, DriverLoad): + load.stop() + watch = state.get("watch") + if isinstance(watch, AlertWatch): + watch.stop() + detached("docker", "compose", "start", "postgres", timeout=120) + unlock(state.get("lock")) # type: ignore[arg-type] + running = ensure_running("worker", "relay") + ready = wait_lb_ready(port) + print( + "restored: load stopped, lock session ended, PostgreSQL " + f"started, worker and relay running: {yes(running)}, " + f"LB ready: {yes(ready)}", + flush=True, + ) + + return rc_signals(body) + + +def alerts_check(port: int, grafana: Grafana, state: dict[str, object]) -> int: + rows: list[tuple[str, str, str]] = [] + drill_start = time.time() + + def add(name: str, expected: object, got: object) -> None: + rows.append((name, str(expected), str(got))) + mark = "" if str(expected) == str(got) else " <- differs" + print(f"{name}: {got}{mark}", flush=True) + + def note(text: str) -> None: + print(f" observed: {text}", flush=True) + + print( + f"alerts-check {datetime.now(UTC):%Y-%m-%dT%H:%M:%SZ}: rules, " + "quiet stand", + flush=True, + ) + for row in rules_rows(grafana): + add(*row) + status, config = grafana.proxy("prometheus", "/api/v1/status/config") + yaml_text = ( + str(config.get("data", {}).get("yaml", "")) + if isinstance(config, dict) + else "" + ) + add( + "prometheus config has alertmanagers", + "no", + yes(status != 200 or "alertmanagers" in yaml_text), + ) + watch = AlertWatch(grafana) + state["watch"] = watch + watch.start() + if not watch.wait_quiet(AC_QUIET_WAIT_S): + print(f"stand is not quiet: active alerts {sorted(watch.active())}") + return 2 + people = attachment_people(port, "ac") + if people is None: + return 1 + _, tokens, chat_id = people + token = tokens["alice"] + password = f"Pw-{uuid.uuid4().hex}" + login_user = register_user(port, "aclogin", password) + if login_user is None: + return 1 + load = DriverLoad(port, token, chat_id) + state["load"] = load + load.start() + load_start = time.time() + print( + f"load: {LOAD_WRITERS} writers every {LOAD_PERIOD_S} s and " + f"{LOAD_READERS} reader every {LOAD_READ_PERIOD_S} s", + flush=True, + ) + time.sleep(AC_SCRAPE_LAG_S) + baseline_end = time.time() + pool_before = window_max( + grafana, + pool_used_expr(), + load_start + 15, + baseline_end, + ) + note(f"pool used before the steps (max): {pool_before:.0f}") + # загрузки при работающем worker: хорошие события SLI времени до ready + # (иначе за час их единицы, и сверка двух путей — шум экстраполяции) + good = 0 + for number in range(AC_GOOD_UPLOADS): + _, _, ready_item = upload_ready( + port, + token, + chat_id, + FIXTURE_PNG.read_bytes(), + content_type="image/png", + filename=f"alerts-good-{number}.png", + ) + good += isinstance(ready_item, dict) + add("uploads ready before the steps", AC_GOOD_UPLOADS, good) + + def quiet(step: str) -> None: + ok = watch.wait_quiet(AC_QUIET_WAIT_S) + add(f"[{step}] stand quiet before the step", "yes", yes(ok)) + + def extra(step: str, since: float, allowed: set[str]) -> None: + fired = watch.fired(since) + add( + f"[{step}] other alerts firing", + "[]", + str(sorted(fired - allowed)), + ) + + # --- 1. worker остановлен --------------------------------------------- + step = "worker stopped" + quiet(step) + print(f"[{step}]", flush=True) + since = time.time() + depth_before = queue_snapshot(grafana) + note(f"queue by stage and age before: {depth_before}") + worker_ids = service_ids("worker") + detached("docker", "compose", "stop", "worker", timeout=60) + stopped_at = time.time() + note(f"worker stopped at {stopped_at - drill_start:.0f} s of the drill") + attachment_ids = [] + first_upload = time.time() + for number in range(AC_UPLOADS): + status, _, accepted = upload_bytes( + port, + token, + chat_id, + FIXTURE_PNG.read_bytes(), + content_type="image/png", + filename=f"alerts-{number}.png", + ) + if status == ATTACHMENT_ACCEPTED and isinstance(accepted, dict): + attachment_ids.append(str(accepted["id"])) + add(f"[{step}] uploads accepted (202)", AC_UPLOADS, len(attachment_ids)) + firing = watch.wait( + "MessengerQueueLagHigh", + "firing", + first_upload, + AC_LAG_FIRING_S, + ) + pending = watch.first("MessengerQueueLagHigh", "pending", first_upload) + if pending is not None: + note( + f"MessengerQueueLagHigh pending after {pending - first_upload:.0f} s", + ) + rows.append( + alert_row( + f"[{step}] MessengerQueueLagHigh firing after the first upload", + firing, + first_upload, + AC_LAG_FIRING_S, + ), + ) + snapshot = queue_snapshot(grafana) + note(f"queue by stage and age: {snapshot}") + grew = ( + snapshot.get("outbox", 0.0) + + snapshot.get("published", 0.0) + - depth_before.get("outbox", 0.0) + - depth_before.get("published", 0.0) + ) + add( + f"[{step}] outbox + published grew by the uploads", + float(AC_UPLOADS), + grew, + ) + consumers = grafana.search( + f'{{ resource.service.name = "{WORKER_SERVICE_NAME}" && kind = consumer }}', + stopped_at + 5, + time.time(), + ) + add(f"[{step}] consumer spans after the stop", 0, len(consumers)) + last_worker = grafana.loki( + f'{{service_name="{WORKER_SERVICE_NAME}"}}', + stopped_at - 600, + time.time(), + ) + note( + "last worker record in Loki: " + + ( + f"{last_worker[-1][1]!r} {stopped_at - last_worker[-1][0] / 1e9:.0f} s " + "before the stop" + if last_worker + else "none" + ), + ) + stdout_stop = [ + r + for r in service_records("worker", stopped_at - 30) + if r.get("event") == "Stopped worker" + ] + note(f"'Stopped worker' in stdout: {yes(bool(stdout_stop))}") + wait_more = AC_WORKER_DOWN_MIN_S - (time.time() - stopped_at) + if wait_more > 0: + time.sleep(wait_more) + ttr_series = grafana.prom( + f'messenger_job_time_to_ready_seconds_count{{job="{WORKER_SERVICE_NAME}"}}', + ) + add(f"[{step}] worker series gone before the start", 0, len(ttr_series)) + started_at = time.time() + for container in worker_ids: + detached("docker", "start", container) + ensure_running("worker") + note(f"worker down for {started_at - stopped_at:.0f} s") + ready = [ + wait_attachment(port, token, attachment_id, timeout=120) + for attachment_id in attachment_ids + ] + add( + f"[{step}] uploads ready after the start", + AC_UPLOADS, + sum(1 for item in ready if item.get("status") == "ready"), + ) + cleared = watch.wait( + "MessengerQueueLagHigh", + "inactive", + started_at, + AC_LAG_CLEAR_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerQueueLagHigh resolved after the start", + cleared, + started_at, + AC_LAG_CLEAR_S, + ), + ) + time.sleep(AC_SCRAPE_LAG_S) + points = prom_points( + grafana, + f'messenger_job_time_to_ready_seconds_count{{job="{WORKER_SERVICE_NAME}"}}', + started_at - 5, + time.time(), + ) + first_points = [series[0] for series in points if series] + note( + "time to ready count, first points of the new process: " + + str([(round(t - started_at, 1), v) for t, v in first_points]), + ) + add( + f"[{step}] time to ready count grew by the uploads (by points)", + float(AC_UPLOADS), + points_increase(points), + ) + extra(step, since, {"MessengerQueueLagHigh"}) + + # --- 2. relay остановлен ---------------------------------------------- + step = "relay stopped" + quiet(step) + print(f"[{step}]", flush=True) + since = time.time() + relay_ids = service_ids("relay") + detached("docker", "compose", "stop", "relay", timeout=60) + stopped_at = time.time() + gone = poll( + lambda: ( + not grafana.prom( + f'messenger_queue_depth{{job="{RELAY_SERVICE_NAME}"}}', + ) + ), + timeout=AC_RELAY_SERIES_GONE_S + 30, + interval=5, + ) + gone_after = time.time() - stopped_at + add( + f"[{step}] queue series gone within {AC_RELAY_SERIES_GONE_S} s", + "yes", + yes(bool(gone) and gone_after <= AC_RELAY_SERIES_GONE_S), + ) + note(f"queue series gone after {gone_after:.0f} s") + firing = watch.wait( + "MessengerQueueMetricsMissing", + "firing", + stopped_at, + AC_RELAY_FIRING_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerQueueMetricsMissing firing", + firing, + stopped_at, + AC_RELAY_FIRING_S, + ), + ) + started_at = time.time() + for container in relay_ids: + detached("docker", "start", container) + ensure_running("relay") + cleared = watch.wait( + "MessengerQueueMetricsMissing", + "inactive", + started_at, + AC_RELAY_CLEAR_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerQueueMetricsMissing resolved after the start", + cleared, + started_at, + AC_RELAY_CLEAR_S, + ), + ) + extra(step, since, {"MessengerQueueMetricsMissing"}) + + # --- 3. медленная БД --------------------------------------------------- + step = "slow database" + quiet(step) + print(f"[{step}]", flush=True) + since = time.time() + p95_before = route_p95(grafana, since) + state["lock"] = lock_session() + locked_at = time.time() + firing = watch.wait( + "MessengerSlowRequests", + "firing", + locked_at, + AC_SLOW_FIRING_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerSlowRequests firing", + firing, + locked_at, + AC_SLOW_FIRING_S, + ), + ) + observed_at = time.time() + ratio = grafana.prom_sum("messenger:http_light_slow:ratio_rate2m") + note(f"slow light requests share: {ratio:.3f}") + note(f"p95 by route before: {p95_before}") + note(f"p95 by route during: {route_p95(grafana, observed_at)}") + shares = pg_shares( + grafana, + '{ kind = server && span.http.route = "/api/v1/chats/{chat_id}/messages"' + ' && span.http.request.method = "POST" && duration > 500ms }', + locked_at, + observed_at, + ) + note( + f"PostgreSQL share of slow send traces: {[round(s, 2) for s in shares]}", + ) + share = median(shares) + add( + f"[{step}] PostgreSQL spans over half of slow send traces (median)", + "yes", + yes(share is not None and share > 0.5), + ) + pool_during = window_max(grafana, pool_used_expr(), locked_at, observed_at) + note( + f"pool used during (max): {pool_during:.0f}, before {pool_before:.0f}", + ) + add( + f"[{step}] pool busier than before", + "yes", + yes(pool_during > pool_before), + ) + cpu = window_max(grafana, api_cpu_expr(), locked_at, observed_at) + note(f"CPU of replicas to limit (max): {cpu:.2f}") + add( + f"[{step}] CPU of replicas below half of the limit", + "yes", + yes(cpu < 0.5), + ) + unlock(state.pop("lock", None)) # type: ignore[arg-type] + unlocked_at = time.time() + cleared = watch.wait( + "MessengerSlowRequests", + "inactive", + unlocked_at, + AC_SLOW_CLEAR_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerSlowRequests resolved after the unlock", + cleared, + unlocked_at, + AC_SLOW_CLEAR_S, + ), + ) + extra(step, since, {"MessengerSlowRequests"}) + + # --- 4. медленный handler для сравнения --------------------------------- + step = "slow handler" + quiet(step) + print(f"[{step}]", flush=True) + since = time.time() + took = login_burst( + port, + str(login_user["username"]), + password, + AC_LOGIN_S, + ) + burst_end = time.time() + if took: + note( + f"logins: {len(took)}, median {median(took):.2f} s, max " + f"{max(took):.2f} s", + ) + shares = pg_shares( + grafana, + '{ kind = server && span.http.route = "/api/v1/auth/sessions"' + ' && span.http.request.method = "POST" && duration > 250ms }', + since, + burst_end, + ) + note( + f"PostgreSQL share of slow login traces: {[round(s, 2) for s in shares]}", + ) + share = median(shares) + add( + f"[{step}] PostgreSQL spans under a fifth of slow login traces (median)", + "yes", + yes(share is not None and share < 0.2), + ) + time.sleep(AC_SCRAPE_LAG_S) + # «ожидающих соединения пула нет»: соединение не ждёт свободного места — + # пул не занят целиком и отказов по сроку нет. Мгновенный счёт pending + # включает и проверку `;` при выдаче, и открытие соединения: под CPU входов + # выборка раз в 15 с изредка застаёт 1 (печатается как наблюдение) + waiting = window_max(grafana, pool_waiting_expr(), since, time.time()) + full = window_max( + grafana, + f'max(sum by (instance) (db_client_connection_count{{job="{API_SERVICE_NAME}",' + 'db_client_connection_state="used"}) / sum by (instance) ' + f'(db_client_connection_max{{job="{API_SERVICE_NAME}"}}))', + since, + time.time(), + ) + timeouts = grafana.prom_sum( + "sum(increase(db_client_connection_timeouts_total" + f'{{job="{API_SERVICE_NAME}"}}[{int(time.time() - since)}s]))', + ) + note( + f"pool: max share used {full:.2f}, requests in checkout (max) " + f"{waiting:.0f}, timeouts {timeouts:.0f}", + ) + add( + f"[{step}] no request waits for a free pool connection", + "yes", + yes(full < 1 and timeouts == 0), + ) + cpu = window_max(grafana, api_cpu_expr(), since, time.time()) + note(f"CPU of replicas to limit (max): {cpu:.2f}") + p95 = route_p95(grafana, time.time()) + note(f"p95 by route: {p95}") + add( + f"[{step}] login p95 on the route panel slower than 0.25 s", + "yes", + yes(p95.get(SESSIONS, 0) > 0.25), + ) + slow_ratio = window_max( + grafana, + "messenger:http_light_slow:ratio_rate2m", + since, + time.time(), + ) + note(f"slow light requests share (max): {slow_ratio:.3f}") + time.sleep(max(0.0, AC_LOGIN_WATCH_S - (time.time() - burst_end))) + slow_active = watch.first("MessengerSlowRequests", "pending", since) + slow_firing = watch.first("MessengerSlowRequests", "firing", since) + add( + f"[{step}] MessengerSlowRequests stayed inactive", + "yes", + yes(slow_active is None and slow_firing is None), + ) + extra(step, since, set()) + + # --- 5. недоступная БД --------------------------------------------------- + step = "database down" + quiet(step) + print(f"[{step}]", flush=True) + since = time.time() + lb_before = grafana.prom_sum(lb_5xx_expr()) + lb_total_before = grafana.prom_sum(lb_total_expr()) + api_before = grafana.prom_sum(api_5xx_expr()) + detached("docker", "compose", "stop", "postgres", timeout=60) + stopped_at = time.time() + replicas_firing = watch.wait( + "MessengerNoReadyReplicas", + "firing", + stopped_at, + AC_DB_FIRING_S, + ) + errors_firing = watch.wait( + "MessengerHighErrorRate", + "firing", + stopped_at, + AC_DB_FIRING_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerNoReadyReplicas firing", + replicas_firing, + stopped_at, + AC_DB_FIRING_S, + ), + ) + rows.append( + alert_row( + f"[{step}] MessengerHighErrorRate firing", + errors_firing, + stopped_at, + AC_DB_FIRING_S, + ), + ) + ready_replicas = grafana.prom_sum( + 'max(haproxy_backend_active_servers{job="haproxy",proxy="api"})', + ) + add(f"[{step}] ready replicas in LB", "0", f"{ready_replicas:.0f}") + records = grafana.loki( + f'{{service_name="{API_SERVICE_NAME}"}} |= "Database is unavailable"', + stopped_at - 5, + time.time(), + ) + note( + f"'Database is unavailable' records of replicas in Loki: {len(records)}", + ) + errors = grafana.search( + f'{{ resource.service.name = "{API_SERVICE_NAME}" && kind = server' + " && status = error }", + stopped_at - 5, + time.time(), + limit=50, + ) + pg_errors = grafana.search( + f'{{ resource.service.name = "{API_SERVICE_NAME}"' + ' && span.db.system.name = "postgresql" && status = error }', + stopped_at - 5, + time.time(), + limit=50, + ) + note( + f"API traces with an error server span: {len(errors)}, with a " + f"PostgreSQL span in error: {len(pg_errors)}", + ) + restored_at = time.time() + detached("docker", "compose", "start", "postgres", timeout=120) + add(f"[{step}] LB ready after the start", "yes", yes(wait_lb_ready(port))) + client = load.counts(stopped_at, restored_at) + client_lb = load.lb_errors(stopped_at, restored_at) + note(f"client responses during the outage: {client}, from LB: {client_lb}") + replicas_cleared = watch.wait( + "MessengerNoReadyReplicas", + "inactive", + restored_at, + AC_DB_CLEAR_S, + ) + errors_cleared = watch.wait( + "MessengerHighErrorRate", + "inactive", + restored_at, + AC_DB_CLEAR_S, + ) + rows.append( + alert_row( + f"[{step}] MessengerNoReadyReplicas resolved", + replicas_cleared, + restored_at, + AC_DB_CLEAR_S, + ), + ) + rows.append( + alert_row( + f"[{step}] MessengerHighErrorRate resolved", + errors_cleared, + restored_at, + AC_DB_CLEAR_S, + ), + ) + lb_grew = grafana.prom_sum(lb_5xx_expr()) - lb_before + lb_total = grafana.prom_sum(lb_total_expr()) - lb_total_before + api_grew = grafana.prom_sum(api_5xx_expr()) - api_before + note( + f"5xx grew: LB {lb_grew:.0f}, API {api_grew:.0f}; LB responses {lb_total:.0f}", + ) + add( + f"[{step}] 5xx on LB more than 5xx of API", + "yes", + yes(lb_grew > api_grew), + ) + add( + f"[{step}] LB 5xx grew by the LB's own 503 to the client or more", + "yes", + yes(client_lb > 0 and lb_grew >= client_lb), + ) + client_total = sum(load.counts(since).values()) + client_bad = load.counts(since).get("5xx", 0) + lb_share = lb_grew / lb_total if lb_total else 0.0 + client_share = client_bad / client_total if client_total else 0.0 + note( + f"availability SLI over the outage window: LB {1 - lb_share:.4f}, " + f"client {1 - client_share:.4f}", + ) + add( + f"[{step}] LB 5xx share equals the client's within " + f"{AC_SHARE_TOLERANCE:.0%}", + "yes", + yes(abs(lb_share - client_share) <= AC_SHARE_TOLERANCE), + ) + pending_missing = watch.first( + "MessengerQueueMetricsMissing", + "pending", + since, + ) + if pending_missing is not None: + note("MessengerQueueMetricsMissing was pending (allowed)") + extra( + step, + since, + {"MessengerNoReadyReplicas", "MessengerHighErrorRate"}, + ) + + # --- 6. SLI и панели ----------------------------------------------------- + print("[SLI and panels]", flush=True) + load.stop() + state.pop("load", None) + drill_end = time.time() + counts = load.counts(load_start, drill_end) + note(f"client responses over the drill: {counts}") + sli_rows(grafana, drill_start, drill_end, add, note) + panel_rows(grafana, drill_start, drill_end, add) + print_peaks(("prometheus", "otel-collector")) + watch.stop() + return report_reconcile( + rows, + passed="each alert went firing on its fault and resolved after the " + "recovery, no other alert fired; SLI agree by both paths", + ) + + +AC_LIGHT = ( + 'http_response_status_code!~"5..",http_route!~"/api/v1/users|' + "/api/v1/auth/sessions|/api/v1/chats/.+/attachments|" + '/api/v1/attachments/.+/content"' +) +# SLI: (по рядам правил с окном {w}, числитель и знаменатель по исходным +# счётчикам, числитель — плохие события) +AC_SLI = { + "availability": ( + "1 - sum_over_time(messenger:slo_availability_bad:increase5m[{w}])" + " / sum_over_time(messenger:slo_availability_total:increase5m[{w}])", + 'haproxy_frontend_http_responses_total{job="haproxy",proxy="entry",' + 'code="5xx"}', + 'haproxy_frontend_http_responses_total{job="haproxy",proxy="entry"}', + True, + ), + "latency": ( + "sum_over_time(messenger:slo_latency_good:increase5m[{w}])" + " / sum_over_time(messenger:slo_latency_total:increase5m[{w}])", + "http_server_request_duration_seconds_bucket" + f'{{job="messenger-api",le="0.25",{AC_LIGHT}}}', + f'http_server_request_duration_seconds_count{{job="messenger-api",{AC_LIGHT}}}', + False, + ), + "time to ready": ( + "sum_over_time(messenger:slo_time_to_ready_good:increase5m[{w}])" + " / sum_over_time(messenger:slo_time_to_ready_total:increase5m[{w}])", + 'messenger_job_time_to_ready_seconds_bucket{job="messenger-worker",' + 'le="30.0"}', + 'messenger_job_time_to_ready_seconds_count{job="messenger-worker"}', + False, + ), +} + + +def ratio(numerator: float, total: float, bad: bool) -> float: + if not total: + return float("nan") + return 1 - numerator / total if bad else numerator / total + + +def sli_rows( + grafana: Grafana, + drill_start: float, + drill_end: float, + add: Callable[[str, object, object], None], + note: Callable[[str], None], +) -> None: + """Сценарий «SLO считается»: SLI за 7 суток по рядам правил — от 0 до 1; + за час — по рядам правил и по исходным счётчикам: сумма `increase(…[5m])` + исходных счётчиков на время каждой точки правила (те же окна), расхождение + не больше 1 п. п.; для сравнения — `increase` за час одним окном и SLI за + окно учений (design, «Уточнения apply»).""" + # последнее вычисление группы раз в 5 мин: мгновенный запрос его не видит, + # когда точка старше lookback (5 мин) — время берётся из сырых точек + now = time.time() + points = sorted( + { + t + for series in prom_points( + grafana, + "messenger:slo_availability_total:increase5m", + now - 3600 - 900, + now, + ) + for t, _ in series + }, + ) + last = points[-1] if points else now + hour = [t for t in points if last - t < 3600 - 1] + note(f"messenger-slo windows in the last hour: {len(hour)} of 12") + for name, (rules, bad_expr, total_expr, bad) in AC_SLI.items(): + week = grafana.prom(rules.format(w="7d")) + value = float(week[0]["value"][1]) if week else float("nan") + add( + f"SLI {name} over 7 days within [0, 1]", + "yes", + yes(0 <= value <= 1), + ) + by_rules = grafana.prom(rules.format(w="1h"), last) + a = float(by_rules[0]["value"][1]) if by_rules else float("nan") + numerator = sum( + grafana.prom_sum(f"sum(increase({bad_expr}[5m]))", at) + for at in hour + ) + total = sum( + grafana.prom_sum(f"sum(increase({total_expr}[5m]))", at) + for at in hour + ) + b = ratio(numerator, total, bad) + whole = ratio( + grafana.prom_sum(f"sum(increase({bad_expr}[1h]))", last), + grafana.prom_sum(f"sum(increase({total_expr}[1h]))", last), + bad, + ) + note( + f"SLI {name}: 7 days {value:.5f}, hour by rules {a:.5f}, by raw " + f"counters in the same windows {b:.5f} ({total:.0f} events), " + f"raw increase over the hour {whole:.5f}", + ) + add( + f"SLI {name} over the hour, rules vs raw counters within 1 pp", + "yes", + yes(abs(a - b) <= AC_SLI_TOLERANCE), + ) + span = f"{int(drill_end - drill_start)}s" + drill = ratio( + grafana.prom_sum(f"sum(increase({bad_expr}[{span}]))", drill_end), + grafana.prom_sum( + f"sum(increase({total_expr}[{span}]))", + drill_end, + ), + bad, + ) + note(f"SLI {name} over the drill: {drill:.5f}") + + +def panel_rows( + grafana: Grafana, + start: float, + end: float, + add: Callable[[str, object, object], None], +) -> None: + """Сценарии «Новые панели после трафика» и «История оповещения на панели»: + запросы панелей с id от 25 выполняются и дают данные; панель истории + состояний за окно учений показывает firing оповещений шагов.""" + status, dashboard = grafana.request( + "GET", + f"/api/dashboards/uid/{DASHBOARD_UID}", + ) + model = ( + dashboard.get("dashboard", {}) if isinstance(dashboard, dict) else {} + ) + targets = [ + (panel, target) + for panel in model.get("panels", []) + if panel.get("id", 0) >= SLO_FIRST_PANEL + for target in panel.get("targets", []) + if (target.get("datasource") or {}).get("uid") == "prometheus" + ] + empty = [] + for _, target in targets: + expr = panel_expr(str(target["expr"])) + try: + if not grafana.prom(expr): + empty.append(expr[:60]) + except RuntimeError: + empty.append(f"error: {expr[:60]}") + add(f"new panel queries ({len(targets)}) with data", "[]", str(empty)) + history = next( + ( + target + for panel, target in targets + if panel.get("type") == "state-timeline" + ), + None, + ) + fired: set[str] = set() + if history is not None: + status, payload = grafana.proxy( + "prometheus", + "/api/v1/query_range", + { + "query": history["expr"], + "start": f"{start:.0f}", + "end": f"{end:.0f}", + "step": "15", + }, + ) + if status == 200 and isinstance(payload, dict): + fired = { + str(item["metric"].get("alertname")) + for item in payload["data"]["result"] + if any(float(v) == 2 for _, v in item["values"]) + } + wanted = { + "MessengerQueueLagHigh", + "MessengerQueueMetricsMissing", + "MessengerSlowRequests", + "MessengerNoReadyReplicas", + "MessengerHighErrorRate", + } + add( + "alert history panel shows firing of the steps", + str(sorted(wanted)), + str(sorted(fired & wanted)), + ) + + +# первая панель SLO, оповещений, LB и конвейера в messenger-overview.json +SLO_FIRST_PANEL = 25 + + +class MemorySampler: + """Память раз в 2 с: реплики API — memory.current их cgroup (`docker exec + … cat`), Collector — `docker stats` (в образе нет оболочки).""" + + def __init__(self) -> None: + self.samples: list[tuple[float, str, int]] = [] + self._stop = threading.Event() + self._thread = threading.Thread(target=self._run, daemon=True) + + def start(self) -> None: + self._thread.start() + + def stop(self) -> None: + self._stop.set() + self._thread.join(30) + + def _run(self) -> None: + while not self._stop.is_set(): + now = time.time() + for container in service_ids("api"): + out = subprocess.run( + [ + "docker", + "exec", + container, + "cat", + "/sys/fs/cgroup/memory.current", + ], + capture_output=True, + text=True, + check=False, + ).stdout.strip() + if out.isdigit(): + self.samples.append( + (now, f"api {container[:12]}", int(out)), + ) + for container in service_ids("otel-collector"): + out = subprocess.run( + [ + "docker", + "stats", + "--no-stream", + "--format", + "{{.MemUsage}}", + container, + ], + capture_output=True, + text=True, + check=False, + ).stdout.strip() + value = parse_mem_usage(out) + if value is not None: + self.samples.append((now, "otel-collector", value)) + self._stop.wait(BO_SAMPLE_S) + + def of( + self, + name: str, + start: float, + end: float, + ) -> list[tuple[float, int]]: + return [ + (t, v) + for t, n, v in self.samples + if n == name and start <= t <= end + ] + + def names(self) -> list[str]: + return sorted({n for _, n, _ in self.samples}) + + +MEM_UNITS = { + "B": 1, + "KiB": 1024, + "MiB": MIB, + "GiB": 1024 * MIB, + "kB": 1000, + "MB": 10**6, + "GB": 10**9, +} + + +def parse_mem_usage(text: str) -> int | None: + """«54.3MiB / 256MiB» → байты использованного.""" + match = re.match(r"^\s*([0-9.]+)\s*([A-Za-z]+)", text) + if not match or match.group(2) not in MEM_UNITS: + return None + return int(float(match.group(1)) * MEM_UNITS[match.group(2)]) + + +def loss_expr(exporter: str, signal_name: str) -> str: + return ( + "sum({__name__=~" + f'"otelcol_exporter_(send_failed|enqueue_failed)_{signal_name}",' + f'exporter="{exporter}"}}) or vector(0)' + ) + + +def sdk_loss_by_instance(grafana: Grafana) -> dict[str, float]: + return grafana.prom_by( + "sum by (instance) ({__name__=~" + '"otel_sdk_(processor|exporter)_(span|log)_(processed|exported)_total",' + f'error_type!="",job="{API_SERVICE_NAME}"}})', + "instance", + ) + + +def cmd_backend_outage(port: int) -> int: + """Спеки `observability` «Буферизация Collector и отказ хранилищ + телеметрии», «Учёт потерь телеметрии» (design change `slo-alerts`, решение + 11): под своей нагрузкой — Loki и Tempo коротко и долго, Prometheus, + Collector; работа API, память Collector и реплик, учёт потерь, оповещения. + Сервисы телеметрии запускаются в `finally`.""" + if not stand_answers(port, "backend-outage"): + return 2 + grafana = Grafana() + if not grafana_ready(grafana): + print(f"backend-outage: no Grafana on 127.0.0.1:{grafana.port}") + return 2 + state: dict[str, object] = {} + + def body() -> int: + try: + return backend_outage(port, grafana, state) + finally: + with signals_ignored(): + for name in ("load", "sampler", "watch"): + item = state.get(name) + if item is not None: + item.stop() # type: ignore[attr-defined] + detached( + "docker", + "compose", + "start", + *TELEMETRY_SERVICES, + timeout=180, + ) + running = ensure_running("worker", "relay") + print( + "restored: load stopped, telemetry services started, " + f"worker and relay running: {yes(running)}", + flush=True, + ) + + return rc_signals(body) + + +def backend_outage( + port: int, + grafana: Grafana, + state: dict[str, object], +) -> int: + rows: list[tuple[str, str, str]] = [] + + def add(name: str, expected: object, got: object) -> None: + rows.append((name, str(expected), str(got))) + mark = "" if str(expected) == str(got) else " <- differs" + print(f"{name}: {got}{mark}", flush=True) + + def note(text: str) -> None: + print(f" observed: {text}", flush=True) + + print( + f"backend-outage {datetime.now(UTC):%Y-%m-%dT%H:%M:%SZ}", + flush=True, + ) + watch = AlertWatch(grafana) + state["watch"] = watch + watch.start() + if not watch.wait_quiet(AC_QUIET_WAIT_S): + print(f"stand is not quiet: active alerts {sorted(watch.active())}") + return 2 + people = attachment_people(port, "bo") + if people is None: + return 1 + _, tokens, chat_id = people + token = tokens["alice"] + collector = service_ids("otel-collector") + collector_limit = container_limit(collector[0]) if collector else 0 + replica_limits = { + f"api {c[:12]}": container_limit(c) for c in service_ids("api") + } + sampler = MemorySampler() + state["sampler"] = sampler + sampler.start() + load = DriverLoad(port, token, chat_id) + state["load"] = load + load.start() + time.sleep(AC_SCRAPE_LAG_S) + + def own_request() -> tuple[str, str]: + """GET через LB: `X-Request-Id` и `trace_id` записи stdout реплики.""" + since = time.time() + _, hdrs, _ = call(port, "GET", f"{USERS}/me", token=token) + request_id = hdrs.get("x-request-id", "") + trace_id = "" + for _ in range(10): + for record in service_records("api", since): + if record.get("request_id") == request_id and record.get( + "trace_id", + ): + trace_id = str(record["trace_id"]) + if trace_id: + break + time.sleep(1) + return request_id, trace_id + + def arrived( + store: str, + request_id: str, + trace_id: str, + since: float, + ) -> bool: + if store == "loki": + return bool(loki_request(grafana, request_id, since)) + return bool(trace_id) and bool(tempo_trace(grafana, trace_id)) + + # --- 1. Loki и Tempo: коротко и долго ----------------------------------- + for store in ("loki", "tempo"): + exporter = BO_LOSS_EXPORTERS[store] + signal_name = BO_SIGNAL[store] + prefix = f"[{store} short] " + quiet = watch.wait_quiet(AC_QUIET_WAIT_S) + add(prefix + "stand quiet before the step", "yes", yes(quiet)) + lost_before = grafana.prom_sum(loss_expr(exporter, signal_name)) + since = time.time() + compose("stop", store, timeout=60) + request_id, trace_id = own_request() + time.sleep(max(0.0, BO_SHORT_S - (time.time() - since))) + compose("start", store, timeout=60) + add( + prefix + "own request found after the return", + "yes", + yes(arrived(store, request_id, trace_id, since)), + ) + time.sleep(max(0.0, 45 - (time.time() - since))) + lost_after = grafana.prom_sum(loss_expr(exporter, signal_name)) + add( + prefix + f"Collector losses of {exporter}", + "0", + f"{lost_after - lost_before:.0f}", + ) + + prefix = f"[{store} long] " + quiet = watch.wait_quiet(AC_QUIET_WAIT_S) + add(prefix + "stand quiet before the step", "yes", yes(quiet)) + lost_before = grafana.prom_sum(loss_expr(exporter, signal_name)) + since = time.time() + compose("stop", store, timeout=60) + code, last = make_test(port) + add(prefix + "make test", "0 PASS", f"{code} {last.split(':')[0]}") + firing = watch.wait( + f"TelemetryTargetDown{{job={store}}}", + "firing", + since, + BO_TARGET_FIRING_S, + ) + rows.append( + alert_row( + prefix + f"TelemetryTargetDown{{job={store}}} firing", + firing, + since, + BO_TARGET_FIRING_S, + ), + ) + time.sleep(max(0.0, BO_LONG_S - (time.time() - since))) + down_end = time.time() + queue = window_max( + grafana, + f'max(otelcol_exporter_queue_size{{exporter="{exporter}"}}) ' + f'/ max(otelcol_exporter_queue_capacity{{exporter="{exporter}"}})', + since, + down_end, + ) + note(f"export queue of {exporter}, max share of capacity: {queue:.3f}") + add( + prefix + "export queue within its capacity", + "yes", + yes(queue <= 1), + ) + memory = [v for _, v in sampler.of("otel-collector", since, down_end)] + peak = max(memory) if memory else 0 + heap = window_max( + grafana, + 'max(otelcol_process_runtime_total_sys_memory_bytes{job="otel-collector"})', + since, + down_end, + ) + note( + f"Collector memory: docker stats max {peak / MIB:.0f} MiB, " + f"runtime sys max {heap / MIB:.0f} MiB, limit " + f"{collector_limit / MIB:.0f} MiB", + ) + add( + prefix + "Collector memory below its limit", + "yes", + yes(0 < peak < collector_limit), + ) + client = load.counts(since, down_end) + note(f"client responses during the outage: {client}") + add(prefix + "client 5xx during the outage", "0", client.get("5xx", 0)) + compose("start", store, timeout=60) + back = time.time() + loss_firing = watch.wait("TelemetryDataLoss", "firing", since, 90) + add( + prefix + "TelemetryDataLoss firing", + "yes", + yes(loss_firing is not None), + ) + time.sleep(AC_SCRAPE_LAG_S) + lost = grafana.prom_sum(loss_expr(exporter, signal_name)) - lost_before + note(f"Collector losses of {exporter}: {lost:.0f} {signal_name}") + add(prefix + "losses counted by the Collector", "yes", yes(lost > 0)) + request_id, trace_id = own_request() + add( + prefix + "new signals arrive after the return", + "yes", + yes(arrived(store, request_id, trace_id, back)), + ) + target_clear = watch.wait( + f"TelemetryTargetDown{{job={store}}}", + "inactive", + back, + BO_CLEAR_S, + ) + rows.append( + alert_row( + prefix + "TelemetryTargetDown resolved", + target_clear, + back, + BO_CLEAR_S, + ), + ) + loss_clear = watch.wait( + "TelemetryDataLoss", + "inactive", + back, + BO_CLEAR_S, + ) + rows.append( + alert_row( + prefix + "TelemetryDataLoss resolved", + loss_clear, + back, + BO_CLEAR_S, + ), + ) + + # --- 2. Prometheus ------------------------------------------------------- + prefix = "[prometheus] " + quiet = watch.wait_quiet(AC_QUIET_WAIT_S) + add(prefix + "stand quiet before the step", "yes", yes(quiet)) + selector = f'http_server_request_duration_seconds_count{{job="{API_SERVICE_NAME}"}}' + count_expr = f"sum({selector})" + stamp_expr = f"max(timestamp({selector}))" + before = grafana.prom_sum(count_expr) + before_at = grafana.prom_sum(stamp_expr) + watch.stop() + compose("stop", "prometheus", timeout=60) + since = time.time() + time.sleep(BO_PROMETHEUS_S) + client = load.counts(since) + note(f"client responses while Prometheus is down: {client}") + add( + prefix + "client 5xx while Prometheus is down", + "0", + client.get("5xx", 0), + ) + compose("start", "prometheus", timeout=60) + back = poll( + lambda: grafana.prom(count_expr), + timeout=120, + interval=3, + ) + add(prefix + "Prometheus answers again", "yes", yes(bool(back))) + time.sleep(AC_SCRAPE_LAG_S) + after = grafana.prom_sum(count_expr) + after_at = grafana.prom_sum(stamp_expr) + # запросы, которые точно учтены в точке после: экспорт SDK и сбор — 30 с + sent = len(load.window(before_at, after_at - 30)) + note( + f"API request count grew by {after - before:.0f} between scrapes " + f"{after_at - before_at:.0f} s apart; load sent {sent} in that window", + ) + add( + prefix + "request count grew at least by the load", + "yes", + yes(after - before >= sent > 0), + ) + watch = AlertWatch(grafana) + state["watch"] = watch + watch.start() + + # --- 3. Collector ---------------------------------------------------------- + prefix = "[collector] " + quiet = watch.wait_quiet(AC_QUIET_WAIT_S) + add(prefix + "stand quiet before the step", "yes", yes(quiet)) + sdk_before = sdk_loss_by_instance(grafana) + replicas = service_ids("api") + compose("stop", "otel-collector", timeout=60) + since = time.time() + code, last = make_test(port) + add(prefix + "make test", "0 PASS", f"{code} {last.split(':')[0]}") + firing = watch.wait( + "TelemetryTargetDown{job=otel-collector}", + "firing", + since, + BO_TARGET_FIRING_S, + ) + rows.append( + alert_row( + prefix + "TelemetryTargetDown{job=otel-collector} firing", + firing, + since, + BO_TARGET_FIRING_S, + ), + ) + time.sleep(max(0.0, BO_COLLECTOR_S - (time.time() - since))) + down_end = time.time() + third = (down_end - since) / 3 + for container in replicas: + name = f"api {container[:12]}" + values = sampler.of(name, since, down_end) + first = [v for t, v in values if t < since + third] + last_third = [v for t, v in values if t >= down_end - third] + limit = replica_limits.get(name, 0) + if first and last_third: + growth = max(last_third) - max(first) + note( + f"{name}: memory max first third {max(first) / MIB:.0f} MiB, " + f"last third {max(last_third) / MIB:.0f} MiB, limit " + f"{limit / MIB:.0f} MiB", + ) + else: + growth = BO_GROWTH_LIMIT + 1 + add( + prefix + f"{name} memory does not grow and is below its limit", + "yes", + yes( + growth <= BO_GROWTH_LIMIT + and bool(values) + and max(v for _, v in values) < limit, + ), + ) + missing = watch.first("MessengerQueueMetricsMissing", "pending", since) + add( + prefix + "MessengerQueueMetricsMissing stayed inactive", + "yes", + yes(missing is None), + ) + records_window = (since + 5, down_end - 5) + stdout = [ + r + for r in service_records("api", records_window[0]) + if "timestamp" in r + and records_window[0] + <= datetime.fromisoformat( + str(r["timestamp"]).replace("Z", "+00:00"), + ).timestamp() + < records_window[1] + ] + compose("start", "otel-collector", timeout=60) + back = time.time() + target_clear = watch.wait( + "TelemetryTargetDown{job=otel-collector}", + "inactive", + back, + BO_CLEAR_S, + ) + rows.append( + alert_row( + prefix + "TelemetryTargetDown resolved", + target_clear, + back, + BO_CLEAR_S, + ), + ) + grown = poll( + lambda: all( + sdk_loss_by_instance(grafana).get(c[:12], 0) + > sdk_before.get(c[:12], 0) + for c in replicas + ), + timeout=METRIC_WAIT_S, + interval=5, + ) + note( + f"SDK losses before {sdk_before}, after {sdk_loss_by_instance(grafana)}", + ) + add(prefix + "SDK loss counters of replicas grew", "yes", yes(bool(grown))) + capacity = grafana.prom_by( + f'max by (instance) (otel_sdk_processor_log_queue_capacity{{job="{API_SERVICE_NAME}"}})', + "instance", + ) + add( + prefix + "SDK queue capacity as [telemetry] max_queue_size", + "{2048.0}", + str(set(capacity.values()) or "{}"), + ) + time.sleep(AC_SCRAPE_LAG_S) + loki = grafana.loki_all( + f'{{service_name="{API_SERVICE_NAME}"}}', + records_window[0], + records_window[1], + ) + note( + f"API records in the outage window: stdout {len(stdout)}, Loki " + f"{len(loki)}", + ) + add( + prefix + "fewer Loki records than stdout records in the window", + "yes", + yes(len(loki) < len(stdout)), + ) + sampler.stop() + state.pop("sampler", None) + load.stop() + state.pop("load", None) + print_peaks(("otel-collector", "prometheus", "api")) + watch.stop() + return report_reconcile( + rows, + passed="API and worker work while telemetry stores and the Collector " + "are down; memory is bounded, losses are counted, alerts fire and " + "resolve", + ) + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--port", type=int, default=DEFAULT_PORT) @@ -12714,6 +14902,8 @@ def main() -> int: sub.add_parser("telemetry-check") sub.add_parser("telemetry-outage") sub.add_parser("trace-chain") + sub.add_parser("alerts-check") + sub.add_parser("backend-outage") scratch = sub.add_parser("stand-from-scratch") scratch.add_argument("--project", default=SCRATCH_PROJECT) scratch.add_argument("--runs", type=int, default=2) @@ -12844,6 +15034,10 @@ def main() -> int: return cmd_telemetry_outage(port) if args.cmd == "trace-chain": return cmd_trace_chain(port) + if args.cmd == "alerts-check": + return cmd_alerts_check(port) + if args.cmd == "backend-outage": + return cmd_backend_outage(port) if args.cmd == "stand-from-scratch": return cmd_stand_from_scratch(args.project, args.runs) if args.cmd == "stop-at-start": diff --git a/.github/ci/compose.yml b/.github/ci/compose.yml index 489f12f..25d0c0c 100644 --- a/.github/ci/compose.yml +++ b/.github/ci/compose.yml @@ -93,6 +93,9 @@ services: configs: - source: prometheus_yml target: /etc/prometheus/prometheus.yml + # правила записи и оповещения (design change slo-alerts, решение 3) + - source: prometheus_rules + target: /etc/prometheus/rules.yml loki: volumes: !override @@ -136,6 +139,8 @@ configs: environment: CI_OTEL_COLLECTOR prometheus_yml: environment: CI_PROMETHEUS_YML + prometheus_rules: + environment: CI_PROMETHEUS_RULES loki_yaml: environment: CI_LOKI_YAML tempo_yaml: diff --git a/.github/ci/stand-env.sh b/.github/ci/stand-env.sh index c9059b5..a3155db 100644 --- a/.github/ci/stand-env.sh +++ b/.github/ci/stand-env.sh @@ -20,8 +20,11 @@ CI_TEMPO_YAML="$(cat infra/otel/tempo/tempo.yaml)$nl" CI_GRAFANA_DATASOURCES="$(cat infra/otel/grafana/datasources.yaml)$nl" CI_GRAFANA_DASHBOARDS="$(cat infra/otel/grafana/dashboards.yaml)$nl" CI_GRAFANA_DASHBOARD_OVERVIEW="$(cat infra/otel/grafana/dashboards/messenger-overview.json)$nl" +# правила Prometheus (design change slo-alerts, решение 3) +CI_PROMETHEUS_RULES="$(cat infra/otel/prometheus/rules.yml)$nl" export CI_OTEL_COLLECTOR CI_PROMETHEUS_YML CI_LOKI_YAML CI_TEMPO_YAML \ - CI_GRAFANA_DATASOURCES CI_GRAFANA_DASHBOARDS CI_GRAFANA_DASHBOARD_OVERVIEW + CI_GRAFANA_DATASOURCES CI_GRAFANA_DASHBOARDS CI_GRAFANA_DASHBOARD_OVERVIEW \ + CI_PROMETHEUS_RULES # готовность стенда через LB: /health/ready отвечает 200 от API_REPLICAS # (из .env, по умолчанию 2) разных реплик — X-Instance-Id. Срок 60 с: diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml index 133c483..659ffcb 100644 --- a/.github/workflows/application.yml +++ b/.github/workflows/application.yml @@ -108,6 +108,12 @@ jobs: # на хосте, в CI его нет (design change unit-of-work, решение 13) run: make service_test + - name: make alerts_test + # правила Prometheus без стенда и без сети (design change slo-alerts, + # решение 11): файлы — tar в одноразовый контейнер образа Prometheus, + # bind mount job не видит + run: make alerts_test + - name: make student_test # через LB: тесты реплик выполняются, проверки отказов — нет run: make student_test diff --git a/AGENTS.md b/AGENTS.md index 2682b84..9113e9f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -37,8 +37,20 @@ relay и consumer span worker (parent и link) — одна трасса на з `evidence/telemetry/check.md`, `queue-snapshot.md`, раздел change в `budget.md`, `evidence/migrations/job-trace-context.md`; правки verify — commit `72e2598`, на нём пересняты `evidence/telemetry/trace-chain.md` и -`collector-outage.md`. Следующий — `slo-alerts` (SLO, -alerts, runbooks, инциденты). +`collector-outage.md`. Третье изменение лабы, вторая часть уровня 4 — +change `slo-alerts` (активный, apply 2026-11-11, +`openspec/changes/slo-alerts/`, изменяет `observability` и `load-balancing`): +SLI и SLO (доступность на LB 99,5 %, задержка «лёгких» ручек ≤ 0,25 с 99 %, +время до `ready` ≤ 30 с 99 %, окно 7 суток), метрики HAProxy (`/metrics` на +порту статистики, забирает только Collector), правила записи и семь +оповещений Prometheus в `infra/otel/prometheus/rules.yml` с тестами +`rules.test.yml` (`make alerts_test`, шаг CI) и runbooks +`infra/otel/runbooks/`, без Alertmanager; очереди экспорта Collector по байтам +и повторы 30 с, срок рядов экспортёра 1 мин, время начала рядов по protobuf +(`created-timestamp-zero-ingestion`); внутренние метрики SDK и учёт потерь +(`telemetry:lost_items:total`); панели SLO, LB и конвейера; команды драйвера +`alerts-check` и `backend-outage`. ВМ Docker Desktop с 2026-11-11 — 12 CPU / +11 902 МиБ. Evidence — после коммита кода. Код перенесён из лабы 5 (репозиторий `mtusi2026lab5-safronov`, ветка `solution/bvt2301-safronov`, commit `046ec9e`) по разделу «Переход в следующую лабу»; отчёт и evidence лабы 5 @@ -125,7 +137,7 @@ max_objects_per_second` (2000 объектов S3/с), отказ по пред `fix-upload-put-flake`, `track2-reconcile-cost` лабы 4, `async-attachments`, `pipeline-reliability`, `unit-of-work` и `track1-queue-overload` лабы 5 и `otel-telemetry` и `job-trace-propagation` лабы 6 — в -`openspec/changes/archive/`, активных нет (новые +`openspec/changes/archive/`, активный — `slo-alerts` (новые capability: с `s3-storage` — `object-storage`, с `attachments` — `attachments`, с `upload-consistency` — `storage-consistency`, с `async-attachments` — @@ -375,7 +387,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `scripts/stop-one.example.sh` | образец failover hook; свой — `scripts/stop-one.sh`: остановить одну API-реплику по `TARGET_INSTANCE_ID` и оставить её остановленной | | `compose.example.yaml` | список ролей с пустым `services`, не стенд; свой стенд — свой compose-файл | | `infra/README.md` | куда класть конфигурации сервисов и что сопоставить в `REPORT.md` | -| `infra/otel/README.md` | с лабы 6: что положить — `collector.yaml` (receivers, processors, exporters, bind endpoints, memory limits / batch, поведение при backpressure), конфиги хранилищ, provisioning datasources и dashboards Grafana, dashboard JSON; на 4 — alert rules и runbooks; OTLP, metrics и административные порты наружу не публиковать; сделано — `infra/otel/` (change `otel-telemetry`, карта кода), правило `telemetry.md` | +| `infra/otel/README.md` | с лабы 6: что положить — `collector.yaml` (receivers, processors, exporters, bind endpoints, memory limits / batch, поведение при backpressure), конфиги хранилищ, provisioning datasources и dashboards Grafana, dashboard JSON; на 4 — alert rules и runbooks; OTLP, metrics и административные порты наружу не публиковать; сделано — `infra/otel/` (change `otel-telemetry`, карта кода; alert rules, тесты и runbooks — change `slo-alerts`: `infra/otel/prometheus/rules.yml`, `rules.test.yml`, `infra/otel/runbooks/`), правило `telemetry.md` | | `REPORT.md` | отчёт: запуск из чистого clone, архитектура, доказательства по каждому критерию, эксперименты, ИИ и источники | | `evidence/` | сохранённые выводы проверок и измерений (что можно класть — `evidence/README.md`) | | `CONTRIBUTING.md` | fork/PR, имя ветки, что переносить в следующую лабу | @@ -538,6 +550,9 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `driver.py freeze-sessions [--rounds 6] [--settle 15]` | сессии PostgreSQL и журнал пула после заморозки (~2,5 мин), работает и на рабочем стенде: приложение в процессе одноразового контейнера `api`, PostgreSQL только через TCP-прокси пробы, заморожен прокси, а не сервер; режимы — между блоками и до запросов при пуле 2 и 4; `evidence/storage/freeze-sessions.md` | | `driver.py --port telemetry-check` | телеметрия рабочего стенда через HTTP API Grafana с паролем из `.env` (~2 мин, change `otel-telemetry`): вход, порт, источники, dashboard provisioned и неизменяем, цели Prometheus; свой запрос → stdout → Loki → Tempo, traceparent, нестандартный метод, 401, 404; загрузка → трасса worker, недекодируемый JPEG → `failed`; рост счётчиков по репликам и исходам; S3 заморожен → span S3 с ошибкой (`unpause` в `finally`); сети хранилищ из api и worker, разовый контейнер с `OTEL_*`, проба приватности, рестарт Collector и хранилищ; `evidence/telemetry/check.md` | | `driver.py --port telemetry-outage` | Collector `stop` и `pause` (~3,5 мин): `make test`, загрузка до `ready`, записи SDK в stdout; возврат Collector — запись, трасса, span producer и ряды API, worker и relay при прежних `StartedAt` и `RestartCount` их контейнеров; второе окно того же вида — `make test`, `docker stop` реплики, worker и relay быстрее 10 с с кодом 0; все сервисы телеметрии остановлены — рестарт api, worker и relay, `make test`; сигналы (и span producer relay) снова приходят; стенд возвращается в `finally`; `evidence/telemetry/collector-outage.md` | +| `make alerts_test` | правила Prometheus без стенда и сети (change `slo-alerts`): `tar` файлов `infra/otel/prometheus/` в одноразовый контейнер образа Prometheus из compose (`--network none`) — `promtool check config`, `check rules`, `test rules rules.test.yml`; затем у каждого оповещения `runbook_url` на существующий файл; шаг CI; `evidence/alerts/rules-test.md` | +| `driver.py --port alerts-check` | учения оповещений на рабочем стенде (~25 мин, change `slo-alerts`), через HTTP API Grafana: правила загружены, доставки нет, тихий стенд (иначе код 2); фоновая нагрузка драйвера; worker остановлен — `MessengerQueueLagHigh` и счёт времени до готовности по точкам; relay остановлен — `MessengerQueueMetricsMissing`; блокировка таблицы сообщений — `MessengerSlowRequests`, доля span PostgreSQL, пул, CPU; входы по Basic — без оповещения; PostgreSQL остановлен — `MessengerNoReadyReplicas` и `MessengerHighErrorRate`, 5xx LB против API; SLI двумя путями, новые панели и история состояний; в `finally` — нагрузка, сессия блокировки, PostgreSQL, worker, relay, LB; `evidence/alerts/check.md` | +| `driver.py --port backend-outage` | отказ хранилищ телеметрии под нагрузкой (~18 мин, change `slo-alerts`): Loki и Tempo 10 с и 120 с, Prometheus 60 с, Collector 120 с — `make test`, 5xx у клиента, очереди и память Collector, память реплик, учёт потерь, `TelemetryTargetDown` и `TelemetryDataLoss`, пики памяти по cgroup; сервисы телеметрии запускаются в `finally`; `evidence/telemetry/backend-outage.md` | | `driver.py --port trace-chain` | сквозная трасса и сигналы уровня 4 на рабочем стенде (~5 мин, change `job-trace-propagation`), через HTTP API Grafana: предусловие — глубина очереди 0 за 120 с (иначе код 2 «stand is not quiet»); очередь и её возраст при остановленном worker и спад до 0; загрузка с повтором при замороженном S3 — одна трасса: server span API, два span producer relay, два consumer span worker (parent и link, span S3 с ошибкой, запись оригинала и вариантов); replay в той же трассе; задание без контекста (`UPDATE` колонок своей строки) — корень worker; время до `ready`, пулы, ёмкость worker, пределы контейнеров = `docker inspect` и рост CPU каждого за прогон, нет сокета Docker, панели уровня 4 с данными; `unpause s3`, worker и relay — в `finally`; `evidence/telemetry/trace-chain.md` | | `driver.py stand-from-scratch [--runs 2]` | `make run_docker` на пустых volumes своим проектом `mtusi-lab6-scratch` (рабочий — код 2) на свободных портах (~1 мин на прогон): код 0, состояния, `RestartCount` брокера и телеметрии 0, нет `eacces`, provisioning, `make test`; проект удаляется с volumes при любом исходе, ID контейнеров рабочего стенда прежние; `evidence/stand/from-scratch.md` | | `driver.py freeze-lb [--rounds 3]` | только не рабочий проект compose (`COMPOSE_PROJECT_NAME`, по умолчанию `mtusi-lab6-freeze`; `mtusi-lab6` — код 2): сама поднимает стенд с данными в tmpfs (volumes нет) на образе `mtusi-messenger:lab6` и убирает его при любом исходе; `docker pause` PostgreSQL, шесть запросов через LB — 503 за ~8 с, 504 нет, `unpause` в `finally`, сессий не больше пулов (~1,5 мин); раздел `evidence/storage/freeze-sessions.md` | @@ -624,7 +639,7 @@ src/ infra/ early_stop.py # ранний обработчик SIGTERM/SIGINT (только stdlib): до старта сервера — запись «Stopped <процесс> before startup» (API, cleaner) и выход 0; disarm() — первая строка lifespan; write_record — запись мимо structlog logger.py # structlog, get_logger(), contextvar-ы request_id / user_id, instance_id в каждой записи; с лабы 6 — хуки телеметрии (export_to_telemetry, add_trace_fields: trace_id и span_id активного span) в обеих цепочках и RateLimitFilter записей opentelemetry.* (одна в минуту на логгер); SDK не импортирует - telemetry/ # change otel-telemetry и job-trace-propagation (telemetry.md): core.py — только opentelemetry-api: start (SDK загружает модуль sdk.py, ресурс из четырёх атрибутов), remove_otel_environment, begin_shutdown / wait_closed / shutdown (daemon-потоки и срок), child_span (правило корня, ошибка — класс без текста), server_span / finish_request (span SERVER и histogram http.server.request.duration), PROPAGATOR (W3C без baggage), current_trace_context, remote_context, Exporters (in-memory для тестов); sdk.py — единственный импорт SDK, экспортёра и requests: провайдеры только из [telemetry], ParentBased(ALWAYS_ON), cumulative, View границ трёх histogram, без exemplars и atexit, otlp_exporters; messaging.py — producer_span (PRODUCER publish <очередь> под сохранённым контекстом, заголовки), consumer_span (CONSUMER дочерний к контексту сообщения с link, без него — корень) и JobObservation (итог доставки: атрибуты, messenger.job.duration и time_to_ready); metrics.py — observe_pool (db.client.connection.* по текущему пулу engine), WorkerLoad / observe_worker, observe_queue (gauge по последнему снимку, старше 30 с — ничего); container.py — cgroup v2 (cpu.stat, memory.current, cpu.max, memory.max); db.py — instrument_engine (слушатели before/after_cursor_execute, handle_error, метрики пула), commit_span; logs.py — экспорт записи structlog в логгер SDK и trace_ids, install_log_hooks; setup.py — start_process_telemetry(, cgroup_root=…): OTEL_* с warning, провайдеры, метрики контейнера (нет cgroup — одна запись), хуки + telemetry/ # change otel-telemetry и job-trace-propagation (telemetry.md): core.py — только opentelemetry-api: start (SDK загружает модуль sdk.py, ресурс из четырёх атрибутов), remove_otel_environment, begin_shutdown / wait_closed / shutdown (daemon-потоки и срок), child_span (правило корня, ошибка — класс без текста), server_span / finish_request (span SERVER и histogram http.server.request.duration), PROPAGATOR (W3C без baggage), current_trace_context, remote_context, Exporters (in-memory для тестов); sdk.py — единственный импорт SDK, экспортёра и requests: провайдеры только из [telemetry], ParentBased(ALWAYS_ON), cumulative, View границ трёх histogram, без exemplars и atexit, otlp_metric_reader / otlp_span_exporter / otlp_log_exporter; с change slo-alerts — сначала MeterProvider, затем процессоры и экспортёры span и журнала с ним внутри _internal_metrics (внутренние метрики SDK otel.sdk.*, переменная SDK только на время сборки), гистограммы SDK — DropAggregation; messaging.py — producer_span (PRODUCER publish <очередь> под сохранённым контекстом, заголовки), consumer_span (CONSUMER дочерний к контексту сообщения с link, без него — корень) и JobObservation (итог доставки: атрибуты, messenger.job.duration и time_to_ready); metrics.py — observe_pool (db.client.connection.* по текущему пулу engine), WorkerLoad / observe_worker, observe_queue (gauge по последнему снимку, старше 30 с — ничего); container.py — cgroup v2 (cpu.stat, memory.current, cpu.max, memory.max); db.py — instrument_engine (слушатели before/after_cursor_execute, handle_error, метрики пула), commit_span; logs.py — экспорт записи structlog в логгер SDK и trace_ids, install_log_hooks; setup.py — start_process_telemetry(, cgroup_root=…): OTEL_* с warning, провайдеры, метрики контейнера (нет cgroup — одна запись), хуки password.py # Argon2id в потоке со своим лимитом, фиктивный хэш для неизвестного username broker/client.py # aio-pika: JobPublisher relay (соединение лениво, publish_many с confirm и общим сроком, ready_messages, сброс после любой ошибки), JobConsumer worker (своё соединение, prefetch), JobDelivery, queue_name <база>.attachment.process.v1; с change job-trace-propagation — span producer и заголовки traceparent / tracestate в _publish_one, JobDelivery.trace_context из заголовков (trace_context_from_headers) render/client.py # ImageRenderer: процесс обработки на задание, окружение без секретов, срок и kill в finally, разбор вывода, коды в ImageRejected / RenderInterrupted; span render attachment variants (размер входа, исход, код выхода, пик) @@ -697,14 +712,17 @@ migrations/, alembic.ini # ревизии alembic, async env.py; приме infra/ # конфигурации сервисов стенда; README.md — skeleton valkey/valkey.conf # лимит памяти и LRU, persistence выключен rabbitmq/rabbitmq.conf # предел памяти брокера 400 МиБ: лимит контейнера он не видит - otel/collector.yaml # Collector contrib (change otel-telemetry): OTLP HTTP :4318, memory_limiter и batch, экспортёры prometheus :8889, otlp_http/loki, otlp_http/tempo, свои метрики :8888 - otel/prometheus/prometheus.yml # scrape Collector (honor_labels), Collector, Loki, Tempo и себя раз в 15 с; срок и объём — флаги compose + otel/collector.yaml # Collector contrib (change otel-telemetry): OTLP HTTP :4318, memory_limiter и batch, экспортёры prometheus :8889, otlp_http/loki, otlp_http/tempo, свои метрики :8888; с change slo-alerts — приёмник prometheus/haproxy (haproxy:8404/metrics, frontend и backend, отбор имён), batch/logs 256, очереди экспорта по байтам 16 / 8 МиБ и повторы 30 с, metric_expiration 1m + otel/prometheus/prometheus.yml # scrape Collector (honor_labels), Collector, Loki, Tempo и себя раз в 15 с; срок и объём — флаги compose; с change slo-alerts — rule_files, protobuf первым у otel-collector-exporter (время начала рядов), глобально прежний текстовый список otel/loki/loki.yaml # монолит filesystem, schema v13, compactor, срок 168h, без отчётов otel/tempo/tempo.yaml # монолит 3.1, OTLP HTTP :4318, local, block_retention 168h у scheduler и worker, без отчётов - otel/grafana/ # datasources.yaml (uid prometheus, loki, tempo; лог ↔ трасса), dashboards.yaml (папка Messenger, без правок из UI), dashboards/messenger-overview.json (панели уровня 3; с change job-trace-propagation — p99 и строки «Pipeline» и «Saturation» уровня 4) + otel/grafana/ # datasources.yaml (uid prometheus, loki, tempo; лог ↔ трасса; с change slo-alerts — manageAlerts у Prometheus), dashboards.yaml (папка Messenger, без правок из UI), dashboards/messenger-overview.json (панели уровня 3; с change job-trace-propagation — p99 и строки «Pipeline» и «Saturation» уровня 4; с change slo-alerts — строки «SLO and alerts» сверху, «Load balancer» и «Telemetry pipeline», id с 25) + otel/prometheus/rules.yml # change slo-alerts: группы messenger-sli (окна 2 мин, telemetry:lost_items:total), messenger-slo (приращения SLI за 5 мин), messenger-alerts и telemetry-alerts — семь оповещений с for, severity, summary, description, runbook_url + otel/prometheus/rules.test.yml # promtool test rules: срабатывание, порог, без трафика, снятие, правила записи (make alerts_test, в контейнер не монтируется) + otel/runbooks/ # change slo-alerts: <оповещение>.md — значение, панели, диагностика по сохранённым наблюдениям (PromQL, LogQL, TraceQL), действия, восстановление, связанные rollback/broker.compose.yml # override отката реплик на образ до pipeline-reliability (прежний код публикует сам): адрес и пароль брокера только на время отката s3/bootstrap.sh # bootstrap S3 (ещё пользователь worker: чтение и запись объектов; сервис s3-bootstrap, network_mode: service:s3): apply — bucket, анонимный доступ none, политики api-objects и cleaner-objects (у уборщика — ещё список только с префиксом S3_CLEANER_LIST_PREFIX = <база>/attachments/), пользователи api и cleaner с ключами из .env, проверки приватности обоих ключей; check (и строки ключа уборщика) и cleanup — для make s3_check; секреты — stdin weed shell и файл curl на tmpfs - haproxy/haproxy.cfg # LB рабочего стенда и bench/: реплики через DNS Docker (8 слотов), проверки /health/ready (inter, fastinter, формулы обнаружения), цепочка таймаутов, http-reuse never (простаивающее соединение закрывает LB), повтор только на conn-failure, ответы LB в формате контракта (400, 502, 503, 504), timeout server 30 с пути загрузки (set-timeout, остальные 10 с), tune.sndbuf.server 256 KiB и tune.rcvbuf.client 128 KiB, мониторинг :8404, runtime API на 127.0.0.1:9999 внутри контейнера (drain / maint / ready при замене) + haproxy/haproxy.cfg # LB рабочего стенда и bench/: реплики через DNS Docker (8 слотов), проверки /health/ready (inter, fastinter, формулы обнаружения), цепочка таймаутов, http-reuse never (простаивающее соединение закрывает LB), повтор только на conn-failure, ответы LB в формате контракта (400, 502, 503, 504), timeout server 30 с пути загрузки (set-timeout, остальные 10 с), tune.sndbuf.server 256 KiB и tune.rcvbuf.client 128 KiB, мониторинг :8404 (с change slo-alerts — ещё /metrics экспортёра Prometheus для Collector), runtime API на 127.0.0.1:9999 внутри контейнера (drain / maint / ready при замене) scripts/restart.sh # restart hook для make test-persistence, по restart.example.sh: LB, все реплики api, postgres, valkey, s3 (~25 с); ожидание хранилищ — up --wait --no-recreate (Compose 5.4 иначе пересоздаёт контейнеры, чьи образы скачивались при первом up, и s3-bootstrap не стартует); start api повторяет migrate и s3-bootstrap (no-op); уборщика не трогает — рестарт хранилищ он переживает сам scripts/stop-one.sh # failover hook для make test-failover: TARGET_INSTANCE_ID → реплика api этого проекта, STOP_MODE stop или kill, STOP_ONE_LOG scripts/rolling-update.sh # make rolling_update: предусловия (в том числе слоты LB без ручного состояния), сборка (или COMMIT через git archive), миграции один раз в контейнере сервиса migrate, по одной: новая UP в LB → старая drain (до 90 с: дольше загрузки) → maint → stop (код выхода в строке) → rm → слот ready; trap при сбое и Ctrl+C; тот же скрипт — профиль rollout стенда bench/ @@ -721,6 +739,7 @@ evidence/reconcile/<метка>/ # результаты make bench_reconcile (c evidence/telemetry/ # change otel-telemetry: budget.md (пики и лимиты сервисов телеметрии, реплик и worker с телеметрией и без); на commit 72cfa9a change job-trace-propagation переснято: check.md (driver.py telemetry-check); на 72e2598 (правки verify) — collector-outage.md (driver.py telemetry-outage, с relay, сигналы без перезапуска) и новое trace-chain.md (driver.py trace-chain); новое на 72cfa9a: queue-snapshot.md (EXPLAIN снимка очереди), раздел change в budget.md (relay с SDK, уборщик после ленивого импорта) evidence/migrations/ # change job-trace-propagation: job-trace-context.md — ревизия e4b8c2d17f90 (временная база: с нуля, повтор, откат, CHECK, lock_timeout; --sql; рабочий стенд: откат реплик на ff0073e с MIGRATE=0, ревизия до и после make rolling_update) evidence/stand/ # change otel-telemetry: from-scratch.md (driver.py stand-from-scratch --runs 2) +evidence/alerts/ # change slo-alerts (после коммита кода): rules-test.md (make alerts_test), check.md (driver.py alerts-check); там же — evidence/telemetry/backend-outage.md (driver.py backend-outage) и раздел change в budget.md evidence/storage/ # отказы БД, пул, statement_timeout, рестарт, порты Postgres, свежий clone; connection-cost.md — цена нового соединения и пинга; freeze-sessions.md — change unit-of-work: сессии и журнал пула после заморозки PostgreSQL (driver.py freeze-sessions и freeze-lb) evidence/migrations/ # миграции с нуля и повторно, ошибка миграции; лаба 4: pending-index.md (ревизия 739b8f04d5fb с нуля, повтор, откат, EXPLAIN общего плана кандидатов уборщика на рабочей базе с откатом, rollout_quick), lost-at.md (ревизия 5c3e1f0a9b7d колонки lost_at: с нуля, повтор, откат, --sql с lock_timeout, make rolling_update с ревизией до и после) evidence/auth/ # passwords-and-tokens.md — driver.py auth-storage на стенде текущей лабы: Argon2id в users, SHA-256 токена в sessions, ни токена, ни пароля в pg_dump (исключения сверки покрытия) diff --git a/Makefile b/Makefile index ec8751d..e112cc0 100644 --- a/Makefile +++ b/Makefile @@ -494,6 +494,37 @@ bench_ab: $(KEEP_AWAKE) uv run python bench/ab.py --before "$(BEFORE)" --after "$(AFTER)" --reapply "$(REAPPLY)" $(if $(SERIES),--series "$(SERIES)") +# ------------------------- +# Observability +# ------------------------- + +PROMETHEUS_DIR = infra/otel/prometheus + +# правила Prometheus без стенда и без сети (design change slo-alerts, решение +# 11): файлы infra/otel/prometheus/ — tar в одноразовый контейнер +# закреплённого образа Prometheus (образ — из docker-compose.yml), там promtool +# check config, check rules и test rules; затем у каждого оповещения есть +# runbook_url, и каждый названный runbook — файл в git. Через stdin, а не bind +# mount: так же работает в CI (job не видит своих файлов на хосте Docker) +.PHONY: alerts_test +alerts_test: + @image=$$(sed -n 's/^ *image: *\(prom\/prometheus:[^ ]*\).*$$/\1/p' docker-compose.yml | head -n 1); \ + if [ -z "$$image" ]; then echo "prometheus image is not found in docker-compose.yml"; exit 2; fi; \ + echo "promtool from $$image"; \ + tar -C $(PROMETHEUS_DIR) -cf - prometheus.yml rules.yml rules.test.yml | \ + docker run --rm -i --network none --entrypoint sh "$$image" -c \ + 'set -e; cd /etc/prometheus; tar -xf -; promtool check config prometheus.yml; promtool check rules rules.yml; promtool test rules rules.test.yml' + @alerts=$$(grep -c '^ *- alert:' $(PROMETHEUS_DIR)/rules.yml); \ + urls=$$(grep -c '^ *runbook_url:' $(PROMETHEUS_DIR)/rules.yml); \ + if [ "$$alerts" -ne "$$urls" ]; then echo "alerts: $$alerts, runbook_url: $$urls"; exit 1; fi; \ + missing=0; \ + for path in $$(sed -n 's/^ *runbook_url: *//p' $(PROMETHEUS_DIR)/rules.yml); do \ + if [ -f "$$path" ]; then echo "runbook $$path: ok"; else echo "runbook $$path: MISSING"; missing=1; fi; \ + done; \ + if [ "$$missing" -ne 0 ]; then exit 1; fi; \ + echo "alerts: $$alerts, each with an existing runbook" + + # ------------------------- # Common targets # ------------------------- diff --git a/QUESTIONS.md b/QUESTIONS.md index 90cd893..b6d551b 100644 --- a/QUESTIONS.md +++ b/QUESTIONS.md @@ -334,6 +334,31 @@ Change `openspec/changes/slo-alerts/` (propose 2026-11-11). Номера — р JTP-10). - Проверки — `make alerts_test` (и в CI), команды драйвера `alerts-check` и `backend-outage`; медленная БД — блокировка таблицы сообщений в отдельной сессии PostgreSQL, а не лимит CPU контейнера (11). +- Пользователь (2026-11-11, во время apply): ВМ Docker Desktop перезапущена с памятью 12 ГБ — `docker info`: 12 CPU, + MemTotal 11 902 МиБ. Это ответ на вопрос 1: строки бюджета в `docker.md` и `REPORT.md` — по новой ВМ. + +### Решения apply + +Без пользователя; подробности и отклонения — design, «Уточнения apply». + +- Тест внутренних метрик экспортёра OTLP — через `Exporters(spans=None, logs=None)` и подставную `requests.Session.send`; + `otlp_exporters()` разделён на три функции (п. 1). +- Глобальные протоколы scrape — список Prometheus 3.15.1 по умолчанию, снятый с `/api/v1/status/config` (п. 4). +- Нагрузка драйвера — 6 потоков записи и 1 чтения: иначе блокировка таблицы сообщений не даёт 10 % медленных «лёгких» + запросов (п. 7). +- `telemetry-check` проверяет ещё метрики LB (сценарии «Метрики балансировщика без доступа к сети хранилищ» и + `load-balancing` «Метрики балансировщика»), а обход панелей всех команд подменяет `$__range` на `1h` (пп. 5, 6). +- Span PostgreSQL с ошибкой при остановленной БД — наблюдение, не проверка: отказ на выдаче соединения span запроса не + создаёт (п. 9). +- Сверка SLI за час «по исходным счётчикам» — сумма `increase(…[5m])` исходных селекторов в тех же окнах, что у правил; + `increase` за час одним окном — наблюдение: непересекающиеся окна теряют приращение на границах, а при остановленном + Prometheus окна нет (п. 12). Пауза блокировки 0,2 с вместо 0,5, нагрузка — чтение раз в 1 с, 3 потока входа, 20 + хороших загрузок перед шагами (п. 7, 12). +- «Ожидающих соединения пула нет» проверяется как «пул не занят целиком и отказов по сроку нет»: счёт `pending` включает + проверку при выдаче и открытие соединения (п. 14). + + Вопрос verify: устраивает ли такая трактовка двух сценариев спека («SLO считается» — те же окна; «Медленный handler» — + место в пуле, а не мгновенный `pending`)? Иначе — правка спека или новый счётчик «ждут места» отдельно от открытия. ### Вопросы @@ -345,7 +370,8 @@ Change `openspec/changes/slo-alerts/` (propose 2026-11-11). Номера — р 2,25 CPU / 1792 МиБ. CPU больше не дать: лимиты — доли времени, сумма больше 12 значит конкуренцию, а не отказ. Памяти, чтобы лимиты стенда с одноразовыми и `make test_isolated` помещались вместе с накладными ВМ (~0,5–1 ГиБ), нужно не меньше ~11 ГиБ; рекомендация — 12 ГиБ. Точные числа — после замера apply (`docker.md`, `REPORT.md`). Увеличить память ВМ? - Ответ меняет только строку ВМ в `REPORT.md` и `docker.md`. + Ответ меняет только строку ВМ в `REPORT.md` и `docker.md`. **Ответ (2026-11-11):** пользователь увеличил память ВМ до + 12 ГБ (MemTotal 11 902 МиБ); с одноразовыми и `make test_isolated` — 9472 МиБ лимитов, запас ~2,4 ГиБ. 2. Преподавателю: SLI доступности и оповещение о доле ошибок считаются по ответам клиентам на LB (включая сгенерированные LB 502, 503, 504 и health через LB), а «доля ошибок» контракта (5xx API / бизнес-запросы без health) осталась отдельной панелью. Допустимо? Иначе — SLI по метрикам API с отдельным счётом ответов LB в числителе (правила записи и панель). diff --git a/REPORT.md b/REPORT.md index 8018617..aadec5b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -108,8 +108,8 @@ API и worker имена `prometheus`, `loki`, `tempo`, `grafana` не разр Лимиты телеметрии: 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 МиБ: лимиты — потолки, а не -резерв. Два замера под `make test` + `make load` + `make student_test` с телеметрией и без +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 МиБ — его пик упирается в него, поэтому @@ -127,8 +127,9 @@ Tempo 253, Grafana 248 МиБ, правило выполнено и для на копит в себе: после возврата Collector счётчики не теряются, теряется разрешение; рестарт Collector сбрасывает ряды экспортёра (`rate()` это переносит). Записи об отказе отправки — только stdout, не чаще одной в минуту на модуль SDK (`evidence/telemetry/collector-outage.md`). -- **Ответы балансировщика** (502, 503, 504, 408 HAProxy) в метрики API не попадают: их генерирует - LB, метрик HAProxy на уровне 3 нет. Нестандартный метод вне списка парсера uvicorn (`BREW`) +- **Ответы балансировщика** (502, 503, 504, 408 HAProxy) в метрики API не попадают: их считают + метрики LB (раздел «SLO, оповещения и инциденты»), в SLI задержки они не входят, а время в + очереди LB метрики API не видят. Нестандартный метод вне списка парсера uvicorn (`BREW`) отклоняется до приложения 400 текстом — ни span, ни ряда (`KNOWN_ISSUES.md`). - **OTLP без аутентификации и TLS** — до лабы 7: Collector принимает от любого контейнера сети `default`; хранилища отделены сетью. @@ -266,8 +267,8 @@ replay, консоль, `make test_isolated`, стенд отказов и `benc - пул и насыщение worker — мгновенные значения раз в интервал отправки (15 с): короткие всплески пропускаются; отказы пула — счётчик, насыщение — ещё и среднее по сумме длительностей; - снимок очереди, который relay не обновил дольше 30 с, не отдаётся, но экспортёр Collector держит - последнюю точку до `metric_expiration` (5 мин) — панель может показать прежнее значение до - 5 мин; у остановленного relay очереди на панели нет; + последнюю точку до `metric_expiration` (с change `slo-alerts` — 1 мин, было 5) — панель может + показать прежнее значение до ~75 с; у остановленного relay очереди на панели нет; - PostgreSQL, S3, брокер, LB и уборщик в метриках CPU и памяти не представлены (нет SDK, сокета Docker нет); у worker в его cgroup — и процессы обработки; - время до `ready` не учитывает задания после replay (их приём — действие оператора) и повторную @@ -275,12 +276,162 @@ replay, консоль, `make test_isolated`, стенд отказов и `benc - трасса без корня, если Collector был недоступен при загрузке («root span not yet received»); длинные трассы повторов и replay искажают длительность трассы в поиске Tempo — искать по атрибутам span (`messenger.job.outcome`); -- при перезапуске процесса counter начинается с нуля под тем же `instance`: если новый процесс - насчитал больше прежнего, Prometheus сброса не видит (`increase()` занижает) — проверка - `trace-chain` складывает счётчики процессов; +- при перезапуске процесса 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/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__good:increase5m[W]) / sum_over_time(messenger:slo__total:increase5m[W])`. + Те же SLI по исходным счётчикам — `increase(…[W])` тех же селекторов (панели и `alerts-check` + считают обоими путями и сверяют, расхождение ≤ 1 п. п.). +- «Лёгкие» маршруты — `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` за час одним + окном; SLI за 7 суток включают учения и проверки; при недоступном Prometheus правила не + вычисляются, приращение счётчиков после возврата прежнее (`evidence/telemetry/backend-outage.md`). +- Значения на момент отчёта — `evidence/alerts/check.md` (раздел SLI). + +**Оповещения (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 нет времени +начала. Внутренние метрики SDK (`otel.sdk.*`) включает код: процессоры и экспортёры OTLP span и +журнала строятся после `MeterProvider` с ним и с переменной SDK только на время сборки; внешняя +`OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED` удаляется, как любая `OTEL_*`; гистограммы SDK не +отдаются. Результаты отказа каждого хранилища и Collector (память, потери, оповещения) — +`evidence/telemetry/backend-outage.md`. + +**Счётчики после перезапуска процесса (SA-6).** Prometheus принимает время начала cumulative-рядов +экспортёра Collector (`PrometheusProto` первым у цели `otel-collector-exporter`, флаг +`created-timestamp-zero-ingestion`; у остальных целей — прежний текстовый список) и пишет ноль в +момент начала ряда нового процесса; экспортёр убирает ряд, не обновлявшийся минуту. Проверка — +`alerts-check`, шаг 1: worker остановлен дольше 2 мин, 3 загрузки, запуск — первая точка ряда +нового процесса — ноль, приращение по точкам ровно 3. Остаётся: перезапуск того же контейнера +быстрее ~75 с, если новый процесс догнал прежнее значение до первого сбора; собственные метрики +Collector без времени начала (их закрывает правило потерь). Число рядов экспортёра до и после +перехода на protobuf на процесс то же (двойников нет). + +**Инциденты.** Разбор — по runbook оповещения и только по сохранённым наблюдениям вывода +`alerts-check` и `backend-outage` (хронология и значения — в файлах evidence). + +1. **Остановлен worker** (`evidence/alerts/check.md`, шаг «worker stopped»). Хронология: остановка, + 3 загрузки (202), `MessengerQueueLagHigh` pending, затем firing; запуск worker, снятие. + Диагностика по runbook `MessengerQueueLagHigh`: «Pipeline» → глубина `outbox` + `published` + выросла на 3 (`max by (messenger_queue_stage) (messenger_queue_depth{job="messenger-relay"})`), + возраст растёт линейно (`max(messenger_queue_oldest_age_seconds{job="messenger-relay"})`), рядов + `messenger-worker` нет → Loki `{service_name="messenger-worker"}`: последняя запись worker до + остановки, «Stopped worker» — в stdout → Tempo `{ resource.service.name = "messenger-worker" && + kind = consumer }`: consumer span после остановки нет ⇒ причина — worker не работает. + Восстановление — `docker start` worker: все `ready`, счёт времени до готовности +3; SLI времени + до `ready` за окно учений — в разделе SLI evidence (время до `ready` этих загрузок не меньше + длительности остановки, выше 30 с — плохие события). +2. **Медленная БД против медленного handler** (шаги «slow database» и «slow handler»). + `MessengerSlowRequests` firing → p95 по маршрутам: медленна только отправка сообщения → Tempo, + медленная трасса отправки: span PostgreSQL занимают больше половины server span → пул: занятость + выше, чем до шагов → CPU реплик ниже половины предела ⇒ БД (держатель блокировки — сессия + `application_name = mtusi-alerts-check`). Для сравнения вход по Basic: длинный server span, span + PostgreSQL меньше пятой части, пул не занят целиком и без отказов по сроку, CPU реплик выше ⇒ + handler (KDF), и вход вне SLI + задержки — оповещения нет. **Недоступная БД** (шаг «database down»): `MessengerNoReadyReplicas` + и `MessengerHighErrorRate` firing → «Load balancer»: 5xx на LB растут, готовых реплик 0, 5xx API + почти нет (почему SLI — на LB) → Loki «Database is unavailable» реплик → Tempo: server span 503 с + ошибкой. Восстановление — `docker compose start postgres`; SLI доступности за окно отказа упал на + долю 5xx, которую видел клиент. +3. **Недоступно хранилище телеметрии** (`evidence/telemetry/backend-outage.md`, шаг «tempo long»). + `TelemetryTargetDown{job="tempo"}` и `TelemetryDataLoss` → «Telemetry pipeline»: очередь Tempo + растёт к ёмкости, `otelcol_exporter_enqueue_failed_spans` / `send_failed_spans` растут, память + Collector ниже лимита → SLI и ответы приложения прежние (`make test` PASS, 5xx 0) ⇒ теряется + телеметрия, а не сообщения. После запуска Tempo — новые трассы, оповещения сняты, потери — число + из счётчиков. + +Числа хронологии и наблюдений — из evidence этого change (после коммита кода). + +**Бюджет (SA-13).** Новых сервисов и портов нет; лимиты — по замеру `backend-outage` и +`alerts-check` и правилу «лимит ≥ 1,5 × пика» (раздел change `slo-alerts` в +`evidence/telemetry/budget.md`). ВМ 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 — конкуренция, а не отказ. + ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | @@ -295,7 +446,9 @@ replay, консоль, `make test_isolated`, стенд отказов и `benc | Уровень 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 (SLO, alerts, runbooks, инциденты) | change `slo-alerts` | TODO | TODO | +| Уровень 4: alert rules с runbooks в git, модульные тесты правил | `make alerts_test` | код 0: `promtool check config`, `check rules`, `test rules`; у каждого из 7 оповещений есть runbook | `evidence/alerts/rules-test.md` | +| Уровень 4: SLI/SLO и окно, firing / resolved искусственным отказом, разбор двух инцидентов | `driver.py --port 8080 alerts-check` | код 0: остановленный worker, relay, медленная и недоступная БД, медленный handler — firing и снятие в сроки, лишних нет; SLI двумя путями | `evidence/alerts/check.md` | +| Уровень 4: memory limiter, batch, ограниченная буферизация, недоступный backend, учёт потерь | `driver.py --port 8080 backend-outage` | код 0: `make test` PASS при остановленных Loki, Tempo, Prometheus и Collector, память ниже лимитов, потери учтены, оповещения | `evidence/telemetry/backend-outage.md` | | Выбранный трек 5, если заявлен | TODO | TODO | TODO | TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. diff --git a/docker-compose.yml b/docker-compose.yml index 479839a..3c2686f 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -602,7 +602,10 @@ services: # Prometheus — метрики: scrape Collector и собственных метрик конвейера; # срок и предел объёма хранения — флаги. Без remote write, OTLP, admin API и - # lifecycle + # lifecycle. Правила записи и оповещения — файл rules.yml (design change + # slo-alerts, решения 1, 3, 4); доставки оповещений наружу нет. Время начала + # cumulative-рядов экспортёра Collector (protobuf) — ноль в момент начала + # ряда нового процесса (решение 6) prometheus: image: prom/prometheus:v3.15.1@sha256:fa3302279710be2f21a8301ec17a8b4f2301fd829bd113839b3b6b02b6f191a2 restart: unless-stopped @@ -611,6 +614,7 @@ services: - --storage.tsdb.path=/prometheus - --storage.tsdb.retention.time=7d - --storage.tsdb.retention.size=1GB + - --enable-feature=created-timestamp-zero-ingestion environment: GOMEMLIMIT: 300MiB volumes: @@ -622,6 +626,12 @@ services: read_only: true bind: create_host_path: false + - type: bind + source: ./infra/otel/prometheus/rules.yml + target: /etc/prometheus/rules.yml + read_only: true + bind: + create_host_path: false networks: - telemetry healthcheck: diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg index 475c0b0..4622bb5 100644 --- a/infra/haproxy/haproxy.cfg +++ b/infra/haproxy/haproxy.cfg @@ -154,11 +154,17 @@ backend api # мониторинг внутри сети compose, наружу не публикуется: # /lb/ready — healthcheck контейнера LB (200, пока есть готовая реплика), -# /stats и /stats;csv — состояние и счётчики каждой реплики (make lb_stats) +# /stats и /stats;csv — состояние и счётчики каждой реплики (make lb_stats), +# /metrics — метрики Prometheus встроенного экспортёра (design change +# slo-alerts, решение 2): ответы frontend entry по классам, в том числе 502, +# 503 и 504 самого LB, ответы backend и число готовых реплик. Забирает их +# только Collector (приёмник prometheus/haproxy, scope frontend и backend): +# LB не входит в сеть хранилищ, Prometheus — в сеть приложения frontend monitor bind :8404 monitor-uri /lb/ready monitor fail if { nbsrv(api) lt 1 } + http-request use-service prometheus-exporter if { path /metrics } stats enable stats uri /stats # адрес реплики в статистике (поле addr): только внутри сети diff --git a/infra/otel/collector.yaml b/infra/otel/collector.yaml index 53a9be5..7abb372 100644 --- a/infra/otel/collector.yaml +++ b/infra/otel/collector.yaml @@ -4,49 +4,113 @@ # логи — Loki (родной OTLP), трассы — Tempo. Расширений нет (pprof, zpages, # health_check образа не берутся). Порты наружу не публикуются: OTLP # слушает сеть приложения, :8888 и :8889 забирает Prometheus в сети -# telemetry. +# telemetry. Буферизация, повторы, метрики LB и срок рядов — design change +# slo-alerts, решения 2, 6, 7. receivers: otlp: protocols: # только OTLP/HTTP: SDK приложения отправляет protobuf по HTTP http: endpoint: 0.0.0.0:4318 + # метрики LB (решение 2): встроенный экспортёр HAProxy на порту статистики + # в сети приложения. LB не входит в сеть хранилищ, Prometheus — в сеть + # приложения: метрики идут через Collector, как метрики API. Только уровни + # frontend и backend (без рядов по слотам и адресов реплик) и отобранные + # имена; на экспортёре — job = haproxy, instance = haproxy:8404, плюс up + prometheus/haproxy: + config: + scrape_configs: + - job_name: haproxy + scrape_interval: 15s + scrape_timeout: 10s + metrics_path: /metrics + params: + scope: [frontend, backend] + static_configs: + - targets: ["haproxy:8404"] + metric_relabel_configs: + - source_labels: [__name__] + action: keep + regex: haproxy_(frontend_http_requests_total|frontend_http_responses_total|backend_http_responses_total|backend_active_servers|backend_connection_errors_total|backend_response_errors_total|backend_retry_warnings_total|backend_redispatch_warnings_total) processors: # предел памяти Collector: при 200 МиБ отказ приёма (SDK получает ошибку и - # теряет пакет), всплеск — 40 МиБ; GOMEMLIMIT контейнера — 160 МиБ + # теряет пакет, otelcol_receiver_refused_*), всплеск — 40 МиБ; GOMEMLIMIT + # контейнера — 160 МиБ. Худший случай очередей экспорта (обе полны, 24 МиБ + # protobuf ≈ 50–75 МиБ в памяти) + основа ~50 МиБ — ниже мягкого предела memory_limiter: check_interval: 1s limit_mib: 200 spike_limit_mib: 40 - # пакеты до хранилищ: не больше 1024 элементов или раз в секунду + # пакеты трасс и метрик: не больше 1024 элементов или раз в секунду; пакет + # span (≤ 1 МиБ) меньше очереди экспорта Tempo — больший отклоняется целиком batch: send_batch_size: 1024 + send_batch_max_size: 1024 + timeout: 1s + # пакеты журнала — не больше 256 записей: запись до 32 КиБ (traceback), и + # пакет (≤ 8 МиБ) всегда помещается в очередь экспорта Loki (16 МиБ) + batch/logs: + send_batch_size: 256 + send_batch_max_size: 256 timeout: 1s exporters: # метрики приложения для scrape Prometheus (honor_labels): job = # service.name, instance = service.instance.id, остальной ресурс — - # target_info; ряды остановленной реплики уходят через 5 мин + # target_info. Ряд, не обновлявшийся минуту (четыре интервала отправки SDK + # 15 с), уходит (решение 6): у процесса, запущенного позже, время начала + # ряда новее последней точки, и Prometheus пишет ноль — increase() видит и + # сброс, и первые события; снимок очереди остановленного relay уходит через + # ≤ 75 с, а не 5 мин prometheus: endpoint: 0.0.0.0:8889 translation_strategy: UnderscoreEscapingWithSuffixes - metric_expiration: 5m + metric_expiration: 1m resource_to_telemetry_conversion: enabled: false - # sending_queue и retry_on_failure — по умолчанию: явные пределы и учёт - # потерь — change 3 (уровень 4) + # очередь в памяти с пределом в байтах и повторы с пределом времени + # (решение 7): полная очередь отклоняет новое (enqueue_failed), не задерживая + # приём; пакет с истёкшими 30 с повторов отбрасывается (send_failed). + # Рестарт хранилища на стенде — 5–15 с: короткий отказ потерь не даёт otlp_http/loki: endpoint: http://loki:3100/otlp + timeout: 5s + sending_queue: + enabled: true + num_consumers: 2 + sizer: bytes + # 16 МиБ записей — ~40–90 с пика (379 записей/с) + queue_size: 16777216 + block_on_overflow: false + retry_on_failure: + enabled: true + initial_interval: 1s + max_interval: 5s + max_elapsed_time: 30s otlp_http/tempo: endpoint: http://tempo:4318 + timeout: 5s + sending_queue: + enabled: true + num_consumers: 2 + sizer: bytes + # 8 МиБ span — ~10–15 с пика (1127 span/с) и минуты обычного трафика + queue_size: 8388608 + block_on_overflow: false + retry_on_failure: + enabled: true + initial_interval: 1s + max_interval: 5s + max_elapsed_time: 30s service: telemetry: logs: level: info encoding: json - # собственные метрики Collector — для Prometheus (жив ли конвейер) + # собственные метрики Collector — для Prometheus (жив ли конвейер, очереди + # экспорта и потери: otelcol_exporter_*, otelcol_receiver_refused_*) metrics: level: normal readers: @@ -57,12 +121,12 @@ service: port: 8888 pipelines: metrics: - receivers: [otlp] + receivers: [otlp, prometheus/haproxy] processors: [memory_limiter, batch] exporters: [prometheus] logs: receivers: [otlp] - processors: [memory_limiter, batch] + processors: [memory_limiter, batch/logs] exporters: [otlp_http/loki] traces: receivers: [otlp] diff --git a/infra/otel/grafana/dashboards/messenger-overview.json b/infra/otel/grafana/dashboards/messenger-overview.json index 249e13e..ee24c94 100644 --- a/infra/otel/grafana/dashboards/messenger-overview.json +++ b/infra/otel/grafana/dashboards/messenger-overview.json @@ -1,25 +1,231 @@ { "uid": "messenger-overview", "title": "Messenger overview", - "description": "Signals of contracts/observability.md, levels 3 and 4: API RPS, errors and duration, worker jobs and duration, queue depth and age, time to ready, PostgreSQL pools, worker and container saturation, logs and traces (design changes otel-telemetry, decision 16, and job-trace-propagation, decision 14). Provisioned from git, UI changes are not saved.", + "description": "Signals of contracts/observability.md, levels 3 and 4: SLI, SLO and error budget, alert windows and alert states, API RPS, errors and duration, worker jobs and duration, queue depth and age, time to ready, PostgreSQL pools, worker and container saturation, load balancer responses and ready replicas, telemetry pipeline queues and losses, logs and traces (design changes otel-telemetry, decision 16, job-trace-propagation, decision 14, and slo-alerts, decision 10). Provisioned from git, UI changes are not saved.", "tags": ["messenger", "lab6"], "timezone": "utc", "editable": false, "graphTooltip": 1, "schemaVersion": 39, - "version": 2, + "version": 3, "refresh": "30s", "time": {"from": "now-1h", "to": "now"}, "annotations": {"list": []}, "templating": {"list": []}, "links": [], "panels": [ + { + "id": 25, + "type": "row", + "title": "SLO and alerts", + "collapsed": false, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 0}, + "panels": [] + }, + { + "id": 26, + "type": "stat", + "title": "SLI over 7 days", + "description": "Sums of 5-minute increments of the recording rules (group messenger-slo) over the SLO window of 7 days. Availability: responses of the public LB frontend without 5xx (SLO 99.5 %); latency: light API requests without 5xx not longer than 0.25 s (SLO 99 %); time to ready: attachments ready without replay within 30 s (SLO 99 %).", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 6, "w": 8, "x": 0, "y": 1}, + "fieldConfig": { + "defaults": {"unit": "percentunit", "decimals": 3, "min": 0, "max": 1, "color": {"mode": "thresholds"}, "thresholds": {"mode": "absolute", "steps": [{"color": "red", "value": null}, {"color": "green", "value": 0.99}]}}, + "overrides": [ + {"matcher": {"id": "byFrameRefID", "options": "A"}, "properties": [{"id": "thresholds", "value": {"mode": "absolute", "steps": [{"color": "red", "value": null}, {"color": "green", "value": 0.995}]}}]} + ] + }, + "options": {"reduceOptions": {"calcs": ["lastNotNull"], "fields": "", "values": false}, "orientation": "vertical", "textMode": "value_and_name", "colorMode": "value", "graphMode": "none", "justifyMode": "auto"}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "1 - sum_over_time(messenger:slo_availability_bad:increase5m[7d]) / sum_over_time(messenger:slo_availability_total:increase5m[7d])", + "legendFormat": "availability (SLO 99.5 %)", + "instant": true + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum_over_time(messenger:slo_latency_good:increase5m[7d]) / sum_over_time(messenger:slo_latency_total:increase5m[7d])", + "legendFormat": "latency ≤ 0.25 s (SLO 99 %)", + "instant": true + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum_over_time(messenger:slo_time_to_ready_good:increase5m[7d]) / sum_over_time(messenger:slo_time_to_ready_total:increase5m[7d])", + "legendFormat": "time to ready ≤ 30 s (SLO 99 %)", + "instant": true + } + ] + }, + { + "id": 27, + "type": "stat", + "title": "Error budget left over 7 days", + "description": "(SLI − SLO) / (1 − SLO) over 7 days: 100 % — no bad events, 0 — the budget is spent, below zero — the SLO is violated.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 6, "w": 8, "x": 8, "y": 1}, + "fieldConfig": { + "defaults": {"unit": "percentunit", "decimals": 1, "color": {"mode": "thresholds"}, "thresholds": {"mode": "absolute", "steps": [{"color": "red", "value": null}, {"color": "orange", "value": 0}, {"color": "green", "value": 0.25}]}}, + "overrides": [] + }, + "options": {"reduceOptions": {"calcs": ["lastNotNull"], "fields": "", "values": false}, "orientation": "vertical", "textMode": "value_and_name", "colorMode": "value", "graphMode": "none", "justifyMode": "auto"}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "((1 - sum_over_time(messenger:slo_availability_bad:increase5m[7d]) / sum_over_time(messenger:slo_availability_total:increase5m[7d])) - 0.995) / (1 - 0.995)", + "legendFormat": "availability", + "instant": true + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "(sum_over_time(messenger:slo_latency_good:increase5m[7d]) / sum_over_time(messenger:slo_latency_total:increase5m[7d]) - 0.99) / (1 - 0.99)", + "legendFormat": "latency", + "instant": true + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "(sum_over_time(messenger:slo_time_to_ready_good:increase5m[7d]) / sum_over_time(messenger:slo_time_to_ready_total:increase5m[7d]) - 0.99) / (1 - 0.99)", + "legendFormat": "time to ready", + "instant": true + } + ] + }, + { + "id": 28, + "type": "stat", + "title": "SLI over the dashboard range", + "description": "The same SLI over the selected time range: how much an incident or a drill spent.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 6, "w": 8, "x": 16, "y": 1}, + "fieldConfig": { + "defaults": {"unit": "percentunit", "decimals": 3, "min": 0, "max": 1, "color": {"mode": "thresholds"}, "thresholds": {"mode": "absolute", "steps": [{"color": "red", "value": null}, {"color": "green", "value": 0.99}]}}, + "overrides": [ + {"matcher": {"id": "byFrameRefID", "options": "A"}, "properties": [{"id": "thresholds", "value": {"mode": "absolute", "steps": [{"color": "red", "value": null}, {"color": "green", "value": 0.995}]}}]} + ] + }, + "options": {"reduceOptions": {"calcs": ["lastNotNull"], "fields": "", "values": false}, "orientation": "vertical", "textMode": "value_and_name", "colorMode": "value", "graphMode": "none", "justifyMode": "auto"}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "1 - sum_over_time(messenger:slo_availability_bad:increase5m[$__range]) / sum_over_time(messenger:slo_availability_total:increase5m[$__range])", + "legendFormat": "availability", + "instant": true + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum_over_time(messenger:slo_latency_good:increase5m[$__range]) / sum_over_time(messenger:slo_latency_total:increase5m[$__range])", + "legendFormat": "latency", + "instant": true + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum_over_time(messenger:slo_time_to_ready_good:increase5m[$__range]) / sum_over_time(messenger:slo_time_to_ready_total:increase5m[$__range])", + "legendFormat": "time to ready", + "instant": true + } + ] + }, + { + "id": 29, + "type": "timeseries", + "title": "Alert windows: 5xx share on LB and slow light requests (2 min)", + "description": "Recording rules of MessengerHighErrorRate (threshold 5 %) and MessengerSlowRequests (threshold 10 %); both also need more than 0.1 request per second.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 7}, + "fieldConfig": { + "defaults": {"unit": "percentunit", "min": 0}, + "overrides": [ + {"matcher": {"id": "byFrameRefID", "options": "C"}, "properties": [{"id": "custom.lineStyle", "value": {"fill": "dash", "dash": [10, 10]}}, {"id": "color", "value": {"mode": "fixed", "fixedColor": "red"}}]}, + {"matcher": {"id": "byFrameRefID", "options": "D"}, "properties": [{"id": "custom.lineStyle", "value": {"fill": "dash", "dash": [10, 10]}}, {"id": "color", "value": {"mode": "fixed", "fixedColor": "orange"}}]} + ] + }, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "messenger:lb_http_errors:ratio_rate2m", + "legendFormat": "5xx on LB" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "messenger:http_light_slow:ratio_rate2m", + "legendFormat": "slow light requests" + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "vector(0.05)", + "legendFormat": "5xx threshold" + }, + { + "refId": "D", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "vector(0.1)", + "legendFormat": "slow threshold" + } + ] + }, + { + "id": 30, + "type": "state-timeline", + "title": "Alert states (1 — pending, 2 — firing)", + "description": "History of the series ALERTS over the retention of Prometheus (7 days): intervals of pending and firing by alert; 0 — no active alerts.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 7}, + "fieldConfig": { + "defaults": { + "color": {"mode": "thresholds"}, + "thresholds": {"mode": "absolute", "steps": [{"color": "green", "value": null}, {"color": "yellow", "value": 1}, {"color": "red", "value": 2}]}, + "mappings": [{"type": "value", "options": {"0": {"text": "none"}, "1": {"text": "pending"}, "2": {"text": "firing"}}}] + }, + "overrides": [] + }, + "options": {"showValue": "never", "mergeValues": true, "rowHeight": 0.8, "legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max by (alertname) (ALERTS{alertstate=\"firing\"}) * 2 or max by (alertname) (ALERTS{alertstate=\"pending\"}) or on() vector(0)", + "legendFormat": "{{alertname}}" + } + ] + }, + { + "id": 31, + "type": "table", + "title": "Slow light requests (traces longer than 0.25 s)", + "description": "TraceQL: server spans of light API routes longer than the latency SLI threshold; compare the server span with its PostgreSQL spans (slow database) or CPU of replicas (slow handler).", + "datasource": {"type": "tempo", "uid": "tempo"}, + "gridPos": {"h": 8, "w": 24, "x": 0, "y": 15}, + "options": {"showHeader": true}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "tempo", "uid": "tempo"}, + "queryType": "traceql", + "query": "{ kind = server && resource.service.name = \"messenger-api\" && duration > 250ms && span.http.response.status_code < 500 && span.http.route !~ \"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content\" }", + "limit": 20, + "tableType": "traces" + } + ] + }, { "id": 1, "type": "row", "title": "API (messenger-api)", "collapsed": false, - "gridPos": {"h": 1, "w": 24, "x": 0, "y": 0}, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 23}, "panels": [] }, { @@ -28,7 +234,7 @@ "title": "Requests per second by route and status class", "description": "Count of the http.server.request.duration histogram, all replicas; health is not recorded.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 12, "x": 0, "y": 1}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 24}, "fieldConfig": {"defaults": {"unit": "reqps"}, "overrides": []}, "options": {"legend": {"displayMode": "table", "placement": "right", "calcs": ["lastNotNull"]}, "tooltip": {"mode": "multi", "sort": "desc"}}, "targets": [ @@ -46,7 +252,7 @@ "title": "Error ratio (5xx of all requests)", "description": "Numerator: API responses 5xx; denominator: all recorded requests. 4xx are shown separately; responses generated by the load balancer are not in API metrics.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 12, "y": 1}, + "gridPos": {"h": 8, "w": 6, "x": 12, "y": 24}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, "targets": [ @@ -64,7 +270,7 @@ "title": "Client errors ratio (4xx of all requests)", "description": "Wrong password, foreign chat, validation: not part of the error ratio.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 18, "y": 1}, + "gridPos": {"h": 8, "w": 6, "x": 18, "y": 24}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, "targets": [ @@ -82,7 +288,7 @@ "title": "Request duration p50, p95 and p99 (all replicas)", "description": "Quantiles from the sum of buckets of all replicas, not averages of replicas.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 12, "x": 0, "y": 9}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 32}, "fieldConfig": {"defaults": {"unit": "s", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -111,7 +317,7 @@ "type": "timeseries", "title": "Request duration p95 by route", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 12, "x": 12, "y": 9}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 32}, "fieldConfig": {"defaults": {"unit": "s", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "table", "placement": "right", "calcs": ["lastNotNull"]}, "tooltip": {"mode": "multi", "sort": "desc"}}, "targets": [ @@ -128,7 +334,7 @@ "type": "row", "title": "Worker (messenger-worker)", "collapsed": false, - "gridPos": {"h": 1, "w": 24, "x": 0, "y": 17}, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 40}, "panels": [] }, { @@ -137,7 +343,7 @@ "title": "Jobs per second by outcome", "description": "Count of messenger.job.duration by messenger.job.outcome. Successful: ready; failed: failed, retry, requeued, dropped, error; skipped is neither.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 0, "y": 18}, + "gridPos": {"h": 8, "w": 8, "x": 0, "y": 41}, "fieldConfig": {"defaults": {"unit": "ops"}, "overrides": []}, "options": {"legend": {"displayMode": "table", "placement": "bottom", "calcs": ["lastNotNull"]}, "tooltip": {"mode": "multi", "sort": "desc"}}, "targets": [ @@ -154,7 +360,7 @@ "type": "timeseries", "title": "Successful and failed jobs per second", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 8, "y": 18}, + "gridPos": {"h": 8, "w": 8, "x": 8, "y": 41}, "fieldConfig": {"defaults": {"unit": "ops", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -178,7 +384,7 @@ "title": "Job duration p50, p95 and p99 (ready)", "description": "Handling of one delivery after the concurrency slot, outcome ready; quantiles from the sum of buckets of all workers.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 16, "y": 18}, + "gridPos": {"h": 8, "w": 8, "x": 16, "y": 41}, "fieldConfig": {"defaults": {"unit": "s", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -207,7 +413,7 @@ "type": "row", "title": "Pipeline (messenger-relay, messenger-worker)", "collapsed": false, - "gridPos": {"h": 1, "w": 24, "x": 0, "y": 26}, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 49}, "panels": [] }, { @@ -216,7 +422,7 @@ "title": "Queue depth by stage", "description": "Unfinished jobs from one source, the relay snapshot of PostgreSQL every 5 s: scheduled (waits for the next attempt), outbox (due, not published), published (not taken), processing. A snapshot older than 30 s is not reported; the Collector keeps the last point up to 5 min.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 0, "y": 27}, + "gridPos": {"h": 8, "w": 8, "x": 0, "y": 50}, "fieldConfig": {"defaults": {"unit": "short", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "table", "placement": "bottom", "calcs": ["lastNotNull"]}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -234,7 +440,7 @@ "title": "Age of the oldest unfinished job", "description": "Seconds since the oldest unfinished job was accepted (queued with its job, before 202): accumulation, not handling time; 0 without unfinished jobs.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 8, "y": 27}, + "gridPos": {"h": 8, "w": 8, "x": 8, "y": 50}, "fieldConfig": {"defaults": {"unit": "s", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, "targets": [ @@ -252,7 +458,7 @@ "title": "Time to ready p50, p95 and p99", "description": "From accepted upload (queued with its job) to committed ready, including waiting in the queue, retries and lease returns; jobs after replay are not counted.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 8, "x": 16, "y": 27}, + "gridPos": {"h": 8, "w": 8, "x": 16, "y": 50}, "fieldConfig": {"defaults": {"unit": "s", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -281,7 +487,7 @@ "type": "row", "title": "Saturation (pools, worker, containers)", "collapsed": false, - "gridPos": {"h": 1, "w": 24, "x": 0, "y": 35}, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 58}, "panels": [] }, { @@ -290,7 +496,7 @@ "title": "PostgreSQL pool: used of max", "description": "db.client.connection.count{state=used} to db.client.connection.max per process with the SDK (API replicas, worker, relay); instantaneous value once per export interval.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 0, "y": 36}, + "gridPos": {"h": 8, "w": 6, "x": 0, "y": 59}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0, "max": 1}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -308,7 +514,7 @@ "title": "PostgreSQL pool: waiting (left) and timeouts/s (right)", "description": "Left axis, requests: requests waiting for a pool connection (instantaneous). Right axis, per second: pool checkouts that timed out.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 6, "y": 36}, + "gridPos": {"h": 8, "w": 6, "x": 6, "y": 59}, "fieldConfig": { "defaults": {"unit": "short", "min": 0, "custom": {"axisLabel": "requests"}}, "overrides": [ @@ -344,7 +550,7 @@ "title": "Worker saturation", "description": "Busy concurrency slots to capacity of all workers (instantaneous) and the window average: sum of delivery durations per second to capacity.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 12, "y": 36}, + "gridPos": {"h": 8, "w": 6, "x": 12, "y": 59}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -368,7 +574,7 @@ "title": "Worker deliveries waiting for a slot", "description": "Deliveries received from the broker (prefetch) that wait for a concurrency slot.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 6, "x": 18, "y": 36}, + "gridPos": {"h": 8, "w": 6, "x": 18, "y": 59}, "fieldConfig": {"defaults": {"unit": "short", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, "targets": [ @@ -386,7 +592,7 @@ "title": "Container CPU of limit", "description": "CPU of the container from its cgroup v2 (cpu.stat) to the CPU limit (cpu.max), API replicas, worker with render processes, relay. PostgreSQL, S3, broker, load balancer and cleaner are not in these metrics.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 12, "x": 0, "y": 44}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 67}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -404,7 +610,7 @@ "title": "Container memory of limit", "description": "memory.current of the container to memory.max, same processes as CPU.", "datasource": {"type": "prometheus", "uid": "prometheus"}, - "gridPos": {"h": 8, "w": 12, "x": 12, "y": 44}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 67}, "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0}, "overrides": []}, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ @@ -416,12 +622,238 @@ } ] }, + { + "id": 32, + "type": "row", + "title": "Load balancer", + "collapsed": false, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 75}, + "panels": [] + }, + { + "id": 33, + "type": "timeseries", + "title": "LB responses per second by status class", + "description": "Responses of the public frontend entry to clients, including 502, 503 and 504 generated by the load balancer itself (HAProxy exporter through the Collector, job haproxy). The availability SLI is counted here.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 76}, + "fieldConfig": {"defaults": {"unit": "reqps", "min": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "table", "placement": "right", "calcs": ["lastNotNull"]}, "tooltip": {"mode": "multi", "sort": "desc"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum by (code) (rate(haproxy_frontend_http_responses_total{job=\"haproxy\",proxy=\"entry\"}[5m]))", + "legendFormat": "{{code}}" + } + ] + }, + { + "id": 34, + "type": "timeseries", + "title": "5xx on LB and 5xx of API per second", + "description": "The difference is responses generated by the load balancer itself: with PostgreSQL down replicas leave the balancer, clients get 503 from it, and API metrics see almost no requests.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 76}, + "fieldConfig": {"defaults": {"unit": "reqps", "min": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(haproxy_frontend_http_responses_total{job=\"haproxy\",proxy=\"entry\",code=\"5xx\"}[5m]))", + "legendFormat": "5xx on LB" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_response_status_code=~\"5..\"}[5m])) or on() vector(0)", + "legendFormat": "5xx of API" + } + ] + }, + { + "id": 35, + "type": "timeseries", + "title": "Ready replicas in LB", + "description": "API replicas that pass the readiness check of the load balancer (haproxy_backend_active_servers of backend api).", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 84}, + "fieldConfig": {"defaults": {"unit": "short", "min": 0, "decimals": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "single"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max(haproxy_backend_active_servers{job=\"haproxy\",proxy=\"api\"})", + "legendFormat": "ready replicas" + } + ] + }, + { + "id": 36, + "type": "timeseries", + "title": "LB retries, redispatches and connection errors per second", + "description": "Backend api: retries on connection failure, redispatches to another replica, connection and response errors.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 84}, + "fieldConfig": {"defaults": {"unit": "ops", "min": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(haproxy_backend_retry_warnings_total{job=\"haproxy\",proxy=\"api\"}[5m]))", + "legendFormat": "retries" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(haproxy_backend_redispatch_warnings_total{job=\"haproxy\",proxy=\"api\"}[5m]))", + "legendFormat": "redispatches" + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(haproxy_backend_connection_errors_total{job=\"haproxy\",proxy=\"api\"}[5m]))", + "legendFormat": "connection errors" + }, + { + "refId": "D", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum(rate(haproxy_backend_response_errors_total{job=\"haproxy\",proxy=\"api\"}[5m]))", + "legendFormat": "response errors" + } + ] + }, + { + "id": 37, + "type": "row", + "title": "Telemetry pipeline", + "collapsed": false, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 92}, + "panels": [] + }, + { + "id": 38, + "type": "timeseries", + "title": "Collector export queues, share of capacity", + "description": "Sending queues of the Loki and Tempo exporters in bytes (16 and 8 MiB): a full queue rejects new data (enqueue_failed).", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 93}, + "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0, "max": 1}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max by (exporter) (otelcol_exporter_queue_size{job=\"otel-collector\"}) / max by (exporter) (otelcol_exporter_queue_capacity{job=\"otel-collector\"})", + "legendFormat": "{{exporter}}" + } + ] + }, + { + "id": 39, + "type": "timeseries", + "title": "SDK queues, share of capacity", + "description": "Span and log record queues of the SDK processors of API replicas, worker and relay ([telemetry] max_queue_size); the oldest item is dropped when a queue is full (queue_full).", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 93}, + "fieldConfig": {"defaults": {"unit": "percentunit", "min": 0, "max": 1}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max by (job, instance) (otel_sdk_processor_span_queue_size / otel_sdk_processor_span_queue_capacity)", + "legendFormat": "spans {{job}} {{instance}}" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max by (job, instance) (otel_sdk_processor_log_queue_size / otel_sdk_processor_log_queue_capacity)", + "legendFormat": "logs {{job}} {{instance}}" + } + ] + }, + { + "id": 40, + "type": "timeseries", + "title": "Telemetry lost per second by place", + "description": "Recording rule telemetry:lost_items:total by process, and its parts: Collector (refused by the memory limiter, queue full, retries expired) and SDK (queue full, failed export). Zero without losses.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 0, "y": 101}, + "fieldConfig": {"defaults": {"unit": "ops", "min": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum by (job) (rate(telemetry:lost_items:total[5m])) or on() vector(0)", + "legendFormat": "lost {{job}}" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum by (metric, receiver, exporter) (rate(label_replace({__name__=~\"otelcol_(receiver_refused|exporter_send_failed|exporter_enqueue_failed)_(spans|log_records|metric_points)\"}, \"metric\", \"$1\", \"__name__\", \"otelcol_(.+)\")[5m:15s])) or on() vector(0)", + "legendFormat": "Collector {{metric}} {{receiver}}{{exporter}}" + }, + { + "refId": "C", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "sum by (job, otel_component_type, error_type) (rate(label_replace({__name__=~\"otel_sdk_(processor|exporter)_(span|log)_(processed|exported)_total\",error_type!=\"\"}, \"metric\", \"$1\", \"__name__\", \"(.+)\")[5m:15s])) or on() vector(0)", + "legendFormat": "SDK {{job}} {{otel_component_type}} {{error_type}}" + } + ] + }, + { + "id": 41, + "type": "timeseries", + "title": "Collector memory", + "description": "Go heap and memory obtained from the system by the Collector; the memory limiter refuses data at 200 MiB, GOMEMLIMIT is 160 MiB. memory_rss includes file pages of the binary and is not used.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 12, "x": 12, "y": 101}, + "fieldConfig": {"defaults": {"unit": "bytes", "min": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max(otelcol_process_runtime_heap_alloc_bytes{job=\"otel-collector\"})", + "legendFormat": "heap" + }, + { + "refId": "B", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max(otelcol_process_runtime_total_sys_memory_bytes{job=\"otel-collector\"})", + "legendFormat": "from the system" + } + ] + }, + { + "id": 42, + "type": "timeseries", + "title": "Metrics targets up", + "description": "1 — Prometheus scrapes the target; haproxy comes through the Collector receiver.", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "gridPos": {"h": 8, "w": 24, "x": 0, "y": 109}, + "fieldConfig": {"defaults": {"unit": "short", "min": 0, "max": 1, "decimals": 0}, "overrides": []}, + "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, + "targets": [ + { + "refId": "A", + "datasource": {"type": "prometheus", "uid": "prometheus"}, + "expr": "max by (job) (up{job=~\"otel-collector|otel-collector-exporter|loki|tempo|prometheus|haproxy\"})", + "legendFormat": "{{job}}" + } + ] + }, { "id": 11, "type": "row", "title": "Logs and traces", "collapsed": false, - "gridPos": {"h": 1, "w": 24, "x": 0, "y": 52}, + "gridPos": {"h": 1, "w": 24, "x": 0, "y": 117}, "panels": [] }, { @@ -430,7 +862,7 @@ "title": "API, worker and relay logs", "description": "Records of stdout exported through the Collector; trace_id opens the trace in Tempo.", "datasource": {"type": "loki", "uid": "loki"}, - "gridPos": {"h": 12, "w": 24, "x": 0, "y": 53}, + "gridPos": {"h": 12, "w": 24, "x": 0, "y": 118}, "options": {"showTime": true, "showLabels": false, "wrapLogMessage": true, "sortOrder": "Descending", "enableLogDetails": true, "dedupStrategy": "none", "prettifyLogMessage": false}, "targets": [ { @@ -447,7 +879,7 @@ "title": "Recent traces", "description": "TraceQL search of API requests and worker deliveries; an upload trace holds its relay publications and worker deliveries; a trace opens with links to its logs.", "datasource": {"type": "tempo", "uid": "tempo"}, - "gridPos": {"h": 10, "w": 24, "x": 0, "y": 65}, + "gridPos": {"h": 10, "w": 24, "x": 0, "y": 130}, "options": {"showHeader": true}, "targets": [ { diff --git a/infra/otel/grafana/datasources.yaml b/infra/otel/grafana/datasources.yaml index b36e8fe..bb9a0ef 100644 --- a/infra/otel/grafana/datasources.yaml +++ b/infra/otel/grafana/datasources.yaml @@ -17,6 +17,10 @@ datasources: jsonData: httpMethod: POST timeInterval: 15s + # правила записи и оповещения Prometheus видны в Alerting только для + # чтения: источник правды — infra/otel/prometheus/rules.yml (design + # change slo-alerts, решение 3); правил Grafana и Alertmanager нет + manageAlerts: true - name: Loki uid: loki diff --git a/infra/otel/prometheus/prometheus.yml b/infra/otel/prometheus/prometheus.yml index cf23b73..a844322 100644 --- a/infra/otel/prometheus/prometheus.yml +++ b/infra/otel/prometheus/prometheus.yml @@ -1,19 +1,41 @@ # Prometheus v3.15.1 — хранилище метрик (design change otel-telemetry, # решения 3 и 15). Метрики приложения — scrape экспортёра prometheus # Collector (honor_labels: job = service.name, instance = service.instance.id -# из OTLP), плюс собственные метрики Collector, Loki, Tempo и самого -# Prometheus: по ним видно, жив ли конвейер. Срок и предел объёма хранения, -# путь данных — флаги команды в docker-compose.yml. Приёмников remote write и -# OTLP, admin API и lifecycle нет; порт не публикуется. +# из OTLP; там же метрики LB с job = haproxy), плюс собственные метрики +# Collector, Loki, Tempo и самого Prometheus: по ним видно, жив ли конвейер. +# Срок и предел объёма хранения, путь данных и время начала рядов — флаги +# команды в docker-compose.yml. Приёмников remote write и OTLP, admin API и +# lifecycle нет; порт не публикуется. Правила записи и оповещения — rules.yml +# (design change slo-alerts, решения 1, 3, 4, 9); блока alerting нет: +# доставки наружу нет, состояние firing / resolved — API правил, ряды ALERTS и +# Grafana. global: scrape_interval: 15s scrape_timeout: 10s evaluation_interval: 15s + # явно прежний текстовый список Prometheus 3 по умолчанию: флаг + # created-timestamp-zero-ingestion иначе переводит на protobuf все цели, а + # время начала нужно только экспортёру Collector (решение 6) + scrape_protocols: + - OpenMetricsText1.0.0 + - OpenMetricsText0.0.1 + - PrometheusText1.0.0 + - PrometheusText0.0.4 + +rule_files: + - /etc/prometheus/rules.yml scrape_configs: - # метрики API и worker, пришедшие в Collector по OTLP + # метрики API, worker и relay, пришедшие в Collector по OTLP, и метрики LB + # с приёмника prometheus/haproxy. Protobuf первым: время начала + # cumulative-ряда экспортёр Collector отдаёт только в нём, и Prometheus + # пишет ноль в момент старта нового процесса (решение 6) - job_name: otel-collector-exporter honor_labels: true + scrape_protocols: + - PrometheusProto + - OpenMetricsText1.0.0 + - PrometheusText0.0.4 static_configs: - targets: ["otel-collector:8889"] - job_name: otel-collector diff --git a/infra/otel/prometheus/rules.test.yml b/infra/otel/prometheus/rules.test.yml new file mode 100644 index 0000000..30cbf32 --- /dev/null +++ b/infra/otel/prometheus/rules.test.yml @@ -0,0 +1,490 @@ +# Модульные тесты правил (design change slo-alerts, решение 11): promtool test +# rules на синтетических рядах, без стенда и без сети — make alerts_test. На +# каждое оповещение — срабатывание после for, нет срабатывания ниже порога и +# без трафика, снятие после восстановления; правила записи — значения. +# Интервал рядов и вычисления — 15 с, как у стенда; шаг i — время 15 × i с. + +rule_files: + - rules.yml + +evaluation_interval: 15s + +tests: + # --- MessengerHighErrorRate и правила записи окна LB ---------------------- + # 2xx по 10 за шаг всё время; 5xx — по 10 за шаг с шага 11 (165 с) по шаг + # 40 (600 с), дальше не растут: доля 5xx — 50 %, трафик 1,33 запроса/с + - interval: 15s + input_series: + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="2xx"}' + values: '0+10x60' + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="5xx"}' + values: '0x10 10+10x29 300x20' + # ответы monitor (health LB) в SLI не входят + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="monitor",code="5xx"}' + values: '0+100x60' + promql_expr_test: + - expr: messenger:lb_http_errors:ratio_rate2m + eval_time: 6m + exp_samples: + - labels: 'messenger:lb_http_errors:ratio_rate2m' + value: 0.5 + - expr: messenger:lb_http_responses:rate2m + eval_time: 6m + exp_samples: + - labels: 'messenger:lb_http_responses:rate2m' + value: 1.3333333333333333 + alert_rule_test: + # ошибок ещё нет + - eval_time: 2m + alertname: MessengerHighErrorRate + exp_alerts: [] + # ошибки идут 15 с: pending, for 1 мин ещё не прошёл + - eval_time: 3m + alertname: MessengerHighErrorRate + exp_alerts: [] + - eval_time: 6m + alertname: MessengerHighErrorRate + exp_alerts: + - exp_labels: + severity: critical + exp_annotations: + summary: High share of 5xx responses to clients on the load balancer + description: '50% of responses of the public frontend in the last 2 minutes are 5xx (threshold 5 %, SLO 99.5 %), including responses generated by the load balancer itself. Runbook: infra/otel/runbooks/MessengerHighErrorRate.md' + runbook_url: infra/otel/runbooks/MessengerHighErrorRate.md + # 5xx не растут с 600 с: окно 2 мин без ошибок — снято + - eval_time: 13m + alertname: MessengerHighErrorRate + exp_alerts: [] + + # ниже порога: 1 % 5xx + - interval: 15s + input_series: + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="2xx"}' + values: '0+99x40' + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="5xx"}' + values: '0+1x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerHighErrorRate + exp_alerts: [] + + # без трафика: все ответы 5xx, но 0,03 запроса/с; и вовсе нет ответов + - interval: 15s + input_series: + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="5xx"}' + values: '0+0.5x40' + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="2xx"}' + values: '0x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerHighErrorRate + exp_alerts: [] + - interval: 15s + input_series: + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="2xx"}' + values: '0x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerHighErrorRate + exp_alerts: [] + + # --- MessengerSlowRequests ----------------------------------------------- + # «лёгкая» отправка сообщения: 10 запросов за шаг, с шага 11 быстрые — + # только 5 из 10 (до шага 40), дальше снова все быстрые + - interval: 15s + input_series: + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/messages",http_response_status_code="201"}' + values: '0+10x60' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/messages",http_response_status_code="201",le="0.25"}' + values: '0+10x10 105+5x29 260+10x20' + promql_expr_test: + - expr: messenger:http_light_slow:ratio_rate2m + eval_time: 6m + exp_samples: + - labels: 'messenger:http_light_slow:ratio_rate2m' + value: 0.5 + alert_rule_test: + - eval_time: 2m + alertname: MessengerSlowRequests + exp_alerts: [] + - eval_time: 3m + alertname: MessengerSlowRequests + exp_alerts: [] + - eval_time: 6m + alertname: MessengerSlowRequests + exp_alerts: + - exp_labels: + severity: warning + exp_annotations: + summary: Many light API requests are slower than 0.25 s + description: '50% of light API requests without 5xx in the last 2 minutes took longer than 0.25 s (threshold 10 %, SLO 99 %); login, registration and attachment bytes are not counted. Runbook: infra/otel/runbooks/MessengerSlowRequests.md' + runbook_url: infra/otel/runbooks/MessengerSlowRequests.md + - eval_time: 13m + alertname: MessengerSlowRequests + exp_alerts: [] + + # тяжёлые ручки и 5xx вне SLI задержки: вход, регистрация, загрузка и + # скачивание байтов медленные, у «лёгкой» — медленные только 5xx; плюс + # быстрые «лёгкие» запросы без маршрута (404) + - interval: 15s + input_series: + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/auth/sessions",http_response_status_code="201"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/auth/sessions",http_response_status_code="201",le="0.25"}' + values: '0x40' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/users",http_response_status_code="201"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/users",http_response_status_code="201",le="0.25"}' + values: '0x40' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/attachments",http_response_status_code="202"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/attachments",http_response_status_code="202",le="0.25"}' + values: '0x40' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/attachments/{attachment_id}/content",http_response_status_code="200"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/attachments/{attachment_id}/content",http_response_status_code="200",le="0.25"}' + values: '0x40' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/messages",http_response_status_code="503"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="POST",http_route="/api/v1/chats/{chat_id}/messages",http_response_status_code="503",le="0.25"}' + values: '0x40' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="GET",http_response_status_code="404"}' + values: '0+10x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="GET",http_response_status_code="404",le="0.25"}' + values: '0+10x40' + promql_expr_test: + - expr: messenger:http_light_slow:ratio_rate2m + eval_time: 6m + exp_samples: + - labels: 'messenger:http_light_slow:ratio_rate2m' + value: 0 + alert_rule_test: + - eval_time: 6m + alertname: MessengerSlowRequests + exp_alerts: [] + + # ниже порога (5 % медленных) и без трафика (все медленные, 0,03 запроса/с) + - interval: 15s + input_series: + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200"}' + values: '0+20x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200",le="0.25"}' + values: '0+19x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerSlowRequests + exp_alerts: [] + - interval: 15s + input_series: + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200"}' + values: '0+0.5x40' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200",le="0.25"}' + values: '0x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerSlowRequests + exp_alerts: [] + + # --- MessengerNoReadyReplicas -------------------------------------------- + # готовых реплик 0 с шага 5 (75 с) по шаг 15 (225 с), затем снова 2 + - interval: 15s + input_series: + - series: 'haproxy_backend_active_servers{job="haproxy",instance="haproxy:8404",proxy="api"}' + values: '2x4 0x10 2x10' + alert_rule_test: + - eval_time: 1m + alertname: MessengerNoReadyReplicas + exp_alerts: [] + # 0 с 75 с: в 90 с — pending, for 30 с прошёл к 105 с + - eval_time: 90s + alertname: MessengerNoReadyReplicas + exp_alerts: [] + - eval_time: 2m + alertname: MessengerNoReadyReplicas + exp_alerts: + - exp_labels: + severity: critical + exp_annotations: + summary: No API replica is ready behind the load balancer + description: 'The load balancer sees 0 ready API replicas: clients get 503 from the load balancer. Fires without traffic too. Runbook: infra/otel/runbooks/MessengerNoReadyReplicas.md' + runbook_url: infra/otel/runbooks/MessengerNoReadyReplicas.md + - eval_time: 5m + alertname: MessengerNoReadyReplicas + exp_alerts: [] + # одна реплика из двух готова — не оповещение + - interval: 15s + input_series: + - series: 'haproxy_backend_active_servers{job="haproxy",instance="haproxy:8404",proxy="api"}' + values: '2x4 1x20' + alert_rule_test: + - eval_time: 4m + alertname: MessengerNoReadyReplicas + exp_alerts: [] + + # --- MessengerQueueLagHigh ----------------------------------------------- + # worker стоит: возраст растёт на 15 с за шаг с шага 5 (75 с), на шаге 26 + # (390 с) задания разобраны + - interval: 15s + input_series: + - series: 'messenger_queue_oldest_age_seconds{job="messenger-relay",instance="r1"}' + values: '0x5 15+15x20 0x10' + alert_rule_test: + - eval_time: 2m + alertname: MessengerQueueLagHigh + exp_alerts: [] + # больше 60 с с шага 10 (150 с): firing с 210 с + - eval_time: 3m + alertname: MessengerQueueLagHigh + exp_alerts: [] + - eval_time: 4m + alertname: MessengerQueueLagHigh + exp_alerts: + - exp_labels: + severity: warning + exp_annotations: + summary: The oldest unfinished attachment job is older than 60 s + description: 'The oldest unfinished job waits 2m 45s (threshold 60 s, time to ready SLO 30 s). Runbook: infra/otel/runbooks/MessengerQueueLagHigh.md' + runbook_url: infra/otel/runbooks/MessengerQueueLagHigh.md + - eval_time: 7m + alertname: MessengerQueueLagHigh + exp_alerts: [] + # ниже порога: возраст до 45 с + - interval: 15s + input_series: + - series: 'messenger_queue_oldest_age_seconds{job="messenger-relay",instance="r1"}' + values: '0x5 15 30 45 0x20' + alert_rule_test: + - eval_time: 4m + alertname: MessengerQueueLagHigh + exp_alerts: [] + + # --- MessengerQueueMetricsMissing ---------------------------------------- + # relay остановлен: снимок пропал после шага 4 (ряд stale с 75 с), экспортёр + # Collector доступен; relay вернулся на шаге 20 (300 с) + - interval: 15s + input_series: + - series: 'messenger_queue_oldest_age_seconds{job="messenger-relay",instance="r1"}' + values: '3x4 stale _x14 3x20' + - series: 'up{job="otel-collector-exporter",instance="otel-collector:8889"}' + values: '1x40' + alert_rule_test: + - eval_time: 3m + alertname: MessengerQueueMetricsMissing + exp_alerts: [] + - eval_time: 4m + alertname: MessengerQueueMetricsMissing + exp_alerts: + - exp_labels: + severity: warning + job: messenger-relay + exp_annotations: + summary: The relay queue snapshot is missing + description: 'There is no queue depth and age snapshot of the relay while the Collector exporter is up: the relay is stopped or cannot read PostgreSQL, and MessengerQueueLagHigh is blind. Runbook: infra/otel/runbooks/MessengerQueueMetricsMissing.md' + runbook_url: infra/otel/runbooks/MessengerQueueMetricsMissing.md + - eval_time: 6m + alertname: MessengerQueueMetricsMissing + exp_alerts: [] + # экспортёр Collector недоступен: снимка нет, но молчит (TelemetryTargetDown) + - interval: 15s + input_series: + - series: 'messenger_queue_oldest_age_seconds{job="messenger-relay",instance="r1"}' + values: '3x4 stale' + - series: 'up{job="otel-collector-exporter",instance="otel-collector:8889"}' + values: '1x4 0x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerQueueMetricsMissing + exp_alerts: [] + # снимок есть — тихо + - interval: 15s + input_series: + - series: 'messenger_queue_oldest_age_seconds{job="messenger-relay",instance="r1"}' + values: '3x40' + - series: 'up{job="otel-collector-exporter",instance="otel-collector:8889"}' + values: '1x40' + alert_rule_test: + - eval_time: 6m + alertname: MessengerQueueMetricsMissing + exp_alerts: [] + + # --- TelemetryTargetDown ------------------------------------------------- + # Tempo недоступен с шага 4 (60 с) по шаг 13 (195 с); Loki — 30 с (короче + # for); экспортёр Collector в правило не входит (его закрывает otel-collector) + - interval: 15s + input_series: + - series: 'up{job="tempo",instance="tempo:3200"}' + values: '1x3 0x9 1x20' + - series: 'up{job="loki",instance="loki:3100"}' + values: '1x3 0x1 1x20' + - series: 'up{job="otel-collector",instance="otel-collector:8888"}' + values: '1x30' + - series: 'up{job="haproxy",instance="haproxy:8404"}' + values: '1x30' + alert_rule_test: + - eval_time: 90s + alertname: TelemetryTargetDown + exp_alerts: [] + - eval_time: 2m + alertname: TelemetryTargetDown + exp_alerts: + - exp_labels: + severity: warning + job: tempo + instance: tempo:3200 + exp_annotations: + summary: Metrics target tempo is down + description: 'Prometheus cannot scrape tempo (tempo:3200) for a minute; with job haproxy the load balancer metrics are missing and MessengerHighErrorRate is blind. Runbook: infra/otel/runbooks/TelemetryTargetDown.md' + runbook_url: infra/otel/runbooks/TelemetryTargetDown.md + - eval_time: 5m + alertname: TelemetryTargetDown + exp_alerts: [] + + # --- TelemetryDataLoss и сумма потерь ------------------------------------- + # Collector: ряд отказов очереди Tempo появился на шаге 9 (135 с) сразу со + # значением 50 (`_xN` — N пропусков), вырос до 80 на шаге 21 (315 с), рестарт + # Collector на шаге 42 (630 с) — 0. SDK реплики: отброшено из-за полной + # очереди 36 с шага 5 (75 с); отправленное без ошибки (error_type пуст) — не + # потеря + - interval: 15s + input_series: + - series: 'otelcol_exporter_enqueue_failed_spans{job="otel-collector",instance="otel-collector:8888",exporter="otlp_http/tempo"}' + values: '_x9 50x11 80x20 0x10' + - series: 'otel_sdk_processor_span_processed_total{job="messenger-api",instance="a1",otel_component_type="batching_span_processor",otel_component_name="batching_span_processor/0",error_type="queue_full"}' + values: '_x5 36x40' + - series: 'otel_sdk_processor_span_processed_total{job="messenger-api",instance="a1",otel_component_type="batching_span_processor",otel_component_name="batching_span_processor/0"}' + values: '0+100x46' + - series: 'otelcol_exporter_sent_spans{job="otel-collector",instance="otel-collector:8888",exporter="otlp_http/tempo"}' + values: '0+100x46' + promql_expr_test: + - expr: telemetry:lost_items:total + eval_time: 6m + exp_samples: + - labels: 'telemetry:lost_items:total{job="otel-collector",instance="otel-collector:8888"}' + value: 80 + - labels: 'telemetry:lost_items:total{job="messenger-api",instance="a1"}' + value: 36 + alert_rule_test: + # новый ряд SDK со значением 36 (шаг 6, 90 с) — рост целиком + - eval_time: 2m + alertname: TelemetryDataLoss + exp_alerts: + - exp_labels: + severity: warning + job: messenger-api + instance: a1 + exp_annotations: + summary: Telemetry of messenger-api is being lost + description: 'messenger-api (a1) lost 36 spans, log records or metric points in the last 2 minutes (full queue, failed export or refused by the memory limiter). Runbook: infra/otel/runbooks/TelemetryDataLoss.md' + runbook_url: infra/otel/runbooks/TelemetryDataLoss.md + # новый ряд Collector со значением 50 (150 с); у SDK 2 мин без роста + - eval_time: 4m + alertname: TelemetryDataLoss + exp_alerts: + - exp_labels: + severity: warning + job: otel-collector + instance: otel-collector:8888 + exp_annotations: + summary: Telemetry of otel-collector is being lost + description: 'otel-collector (otel-collector:8888) lost 50 spans, log records or metric points in the last 2 minutes (full queue, failed export or refused by the memory limiter). Runbook: infra/otel/runbooks/TelemetryDataLoss.md' + runbook_url: infra/otel/runbooks/TelemetryDataLoss.md + # 2 мин без роста — снято + - eval_time: 5m + alertname: TelemetryDataLoss + exp_alerts: [] + - eval_time: 6m + alertname: TelemetryDataLoss + exp_alerts: + - exp_labels: + severity: warning + job: otel-collector + instance: otel-collector:8888 + exp_annotations: + summary: Telemetry of otel-collector is being lost + description: 'otel-collector (otel-collector:8888) lost 30 spans, log records or metric points in the last 2 minutes (full queue, failed export or refused by the memory limiter). Runbook: infra/otel/runbooks/TelemetryDataLoss.md' + runbook_url: infra/otel/runbooks/TelemetryDataLoss.md + - eval_time: 9m + alertname: TelemetryDataLoss + exp_alerts: [] + # сброс суммы (рестарт Collector) — не потеря + - eval_time: 11m + alertname: TelemetryDataLoss + exp_alerts: [] + # без потерь — тихо, сумма потерь пуста + - interval: 15s + input_series: + - series: 'otelcol_exporter_sent_spans{job="otel-collector",instance="otel-collector:8888",exporter="otlp_http/tempo"}' + values: '0+100x40' + promql_expr_test: + - expr: telemetry:lost_items:total + eval_time: 6m + exp_samples: [] + alert_rule_test: + - eval_time: 6m + alertname: TelemetryDataLoss + exp_alerts: [] + + # --- правила SLO: приращения за непересекающиеся 5 мин ---------------------- + # LB: 2xx по 9 и 5xx по 1 за шаг; «лёгкие» запросы по 10 за шаг, быстрые — + # 9; готовые вложения по 2 за шаг, не дольше 30 с — 1 + - interval: 15s + input_series: + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="2xx"}' + values: '0+9x80' + - series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="haproxy:8404",proxy="entry",code="5xx"}' + values: '0+1x80' + - series: 'http_server_request_duration_seconds_count{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200"}' + values: '0+10x80' + - series: 'http_server_request_duration_seconds_bucket{job="messenger-api",instance="a1",http_request_method="GET",http_route="/api/v1/chats/{chat_id}",http_response_status_code="200",le="0.25"}' + values: '0+9x80' + - series: 'messenger_job_time_to_ready_seconds_count{job="messenger-worker",instance="w1",messenger_job_type="attachment.process"}' + values: '0+2x80' + - series: 'messenger_job_time_to_ready_seconds_bucket{job="messenger-worker",instance="w1",messenger_job_type="attachment.process",le="30.0"}' + values: '0+1x80' + promql_expr_test: + - expr: messenger:slo_availability_bad:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_availability_bad:increase5m' + value: 20 + - expr: messenger:slo_availability_total:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_availability_total:increase5m' + value: 200 + - expr: messenger:slo_latency_good:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_latency_good:increase5m' + value: 180 + - expr: messenger:slo_latency_total:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_latency_total:increase5m' + value: 200 + - expr: messenger:slo_time_to_ready_good:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_time_to_ready_good:increase5m' + value: 20 + - expr: messenger:slo_time_to_ready_total:increase5m + eval_time: 10m + exp_samples: + - labels: 'messenger:slo_time_to_ready_total:increase5m' + value: 40 + # SLI окна по рядам правил: доступность 1 − 20 / 200, задержка 180 / 200 + - expr: 1 - sum_over_time(messenger:slo_availability_bad:increase5m[10m]) / sum_over_time(messenger:slo_availability_total:increase5m[10m]) + eval_time: 15m + exp_samples: + - labels: '{}' + value: 0.9 + - expr: sum_over_time(messenger:slo_latency_good:increase5m[10m]) / sum_over_time(messenger:slo_latency_total:increase5m[10m]) + eval_time: 15m + exp_samples: + - labels: '{}' + value: 0.9 + - expr: sum_over_time(messenger:slo_time_to_ready_good:increase5m[10m]) / sum_over_time(messenger:slo_time_to_ready_total:increase5m[10m]) + eval_time: 15m + exp_samples: + - labels: '{}' + value: 0.5 diff --git a/infra/otel/prometheus/rules.yml b/infra/otel/prometheus/rules.yml new file mode 100644 index 0000000..909474e --- /dev/null +++ b/infra/otel/prometheus/rules.yml @@ -0,0 +1,175 @@ +# Правила Prometheus стенда (design change slo-alerts): правила записи SLI и +# SLO (решение 1), учёт потерь телеметрии (решение 9) и оповещения (решения 3, +# 4). Вычисляет Prometheus; доставки наружу нет — состояние firing / resolved: +# /api/v1/rules, /api/v1/alerts, ряды ALERTS и Grafana (правила источника +# prometheus только для чтения, панель истории). Модульные тесты — +# rules.test.yml (make alerts_test). У каждого оповещения — локальный runbook +# infra/otel/runbooks/<имя>.md. +# +# SLI (окно SLO — скользящие 7 суток, срок хранения Prometheus): +# доступность — ответы публичного frontend LB (entry) не 5xx, вместе с 502, +# 503 и 504 самого LB; SLO 99,5 %; +# задержка — «лёгкие» запросы API без 5xx не дольше 0,25 с; SLO 99 %. +# Не «лёгкие» — регистрация и вход (KDF, тот же шаблон у DELETE +# /api/v1/users), загрузка и скачивание байтов вложения; запросы без +# маршрута (404 неизвестного пути) входят; +# время до ready — вложение ready без replay не позже 30 с от устойчивого +# приёма; SLO 99 %. +# SLI окна W — sum_over_time(good[W]) / sum_over_time(total[W]) по рядам +# группы messenger-slo (для доступности — 1 − bad / total); остаток бюджета — +# (SLI − SLO) / (1 − SLO). + +groups: + # окна оповещений и панелей — 2 мин (8 сборов при 15 с) + - name: messenger-sli + interval: 15s + rules: + - record: messenger:lb_http_responses:rate2m + expr: sum(rate(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry"}[2m])) + - record: messenger:lb_http_errors:rate2m + expr: sum(rate(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry",code="5xx"}[2m])) + - record: messenger:lb_http_errors:ratio_rate2m + expr: messenger:lb_http_errors:rate2m / messenger:lb_http_responses:rate2m + - record: messenger:http_light_requests:rate2m + expr: >- + sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code!~"5..",http_route!~"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content"}[2m])) + - record: messenger:http_light_fast:rate2m + expr: >- + sum(rate(http_server_request_duration_seconds_bucket{job="messenger-api",le="0.25",http_response_status_code!~"5..",http_route!~"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content"}[2m])) + - record: messenger:http_light_slow:ratio_rate2m + expr: 1 - messenger:http_light_fast:rate2m / messenger:http_light_requests:rate2m + # потери телеметрии по процессу (решение 9): Collector — отказ приёма + # (memory_limiter), очередь экспорта полна, повторы истекли; SDK API, + # worker и relay — отброшено из-за полной очереди и неудачные отправки. + # Сумма, а не increase(): ряд отказов появляется с первой потерей, у + # метрик Collector нет времени начала — первое значение нового ряда + # целиком рост + - record: telemetry:lost_items:total + expr: >- + sum by (job, instance) ({__name__=~"otelcol_(receiver_refused|exporter_send_failed|exporter_enqueue_failed)_(spans|log_records|metric_points)"}) + or + sum by (job, instance) ({__name__=~"otel_sdk_(processor|exporter)_(span|log)_(processed|exported)_total",error_type!=""}) + + # приращения событий SLI за непересекающиеся 5-минутные окна: SLI любого + # окна — отношение сумм, без чтения 7 суток histogram на каждое обновление + - name: messenger-slo + interval: 5m + rules: + - record: messenger:slo_availability_bad:increase5m + expr: sum(increase(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry",code="5xx"}[5m])) + - record: messenger:slo_availability_total:increase5m + expr: sum(increase(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry"}[5m])) + - record: messenger:slo_latency_good:increase5m + expr: >- + sum(increase(http_server_request_duration_seconds_bucket{job="messenger-api",le="0.25",http_response_status_code!~"5..",http_route!~"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content"}[5m])) + - record: messenger:slo_latency_total:increase5m + expr: >- + sum(increase(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code!~"5..",http_route!~"/api/v1/users|/api/v1/auth/sessions|/api/v1/chats/.+/attachments|/api/v1/attachments/.+/content"}[5m])) + - record: messenger:slo_time_to_ready_good:increase5m + expr: sum(increase(messenger_job_time_to_ready_seconds_bucket{job="messenger-worker",le="30.0"}[5m])) + - record: messenger:slo_time_to_ready_total:increase5m + expr: sum(increase(messenger_job_time_to_ready_seconds_count{job="messenger-worker"}[5m])) + + # оповещения о сервисе: пороги — 10 × допустимой доли SLO, шум отсекают for + # и порог трафика 0,1 запроса/с (не меньше 12 запросов за окно) + - name: messenger-alerts + interval: 15s + rules: + - alert: MessengerHighErrorRate + expr: messenger:lb_http_errors:ratio_rate2m > 0.05 and messenger:lb_http_responses:rate2m > 0.1 + for: 1m + labels: + severity: critical + annotations: + summary: High share of 5xx responses to clients on the load balancer + description: >- + {{ $value | humanizePercentage }} of responses of the public frontend + in the last 2 minutes are 5xx (threshold 5 %, SLO 99.5 %), including + responses generated by the load balancer itself. Runbook: + infra/otel/runbooks/MessengerHighErrorRate.md + runbook_url: infra/otel/runbooks/MessengerHighErrorRate.md + - alert: MessengerSlowRequests + expr: messenger:http_light_slow:ratio_rate2m > 0.1 and messenger:http_light_requests:rate2m > 0.1 + for: 1m + labels: + severity: warning + annotations: + summary: Many light API requests are slower than 0.25 s + description: >- + {{ $value | humanizePercentage }} of light API requests without 5xx + in the last 2 minutes took longer than 0.25 s (threshold 10 %, SLO + 99 %); login, registration and attachment bytes are not counted. + Runbook: infra/otel/runbooks/MessengerSlowRequests.md + runbook_url: infra/otel/runbooks/MessengerSlowRequests.md + - alert: MessengerNoReadyReplicas + expr: max(haproxy_backend_active_servers{job="haproxy",proxy="api"}) < 1 + for: 30s + labels: + severity: critical + annotations: + summary: No API replica is ready behind the load balancer + description: >- + The load balancer sees {{ $value }} ready API replicas: clients get + 503 from the load balancer. Fires without traffic too. Runbook: + infra/otel/runbooks/MessengerNoReadyReplicas.md + runbook_url: infra/otel/runbooks/MessengerNoReadyReplicas.md + - alert: MessengerQueueLagHigh + expr: max(messenger_queue_oldest_age_seconds{job="messenger-relay"}) > 60 + for: 1m + labels: + severity: warning + annotations: + summary: The oldest unfinished attachment job is older than 60 s + description: >- + The oldest unfinished job waits {{ $value | humanizeDuration }} + (threshold 60 s, time to ready SLO 30 s). Runbook: + infra/otel/runbooks/MessengerQueueLagHigh.md + runbook_url: infra/otel/runbooks/MessengerQueueLagHigh.md + - alert: MessengerQueueMetricsMissing + # снимка очереди relay нет (relay остановлен или не читает PostgreSQL), + # и MessengerQueueLagHigh слеп; при недоступном экспортёре Collector + # молчит — там срабатывает TelemetryTargetDown + expr: absent(messenger_queue_oldest_age_seconds{job="messenger-relay"}) unless on() (up{job="otel-collector-exporter"} == 0) + for: 2m + labels: + severity: warning + annotations: + summary: The relay queue snapshot is missing + description: >- + There is no queue depth and age snapshot of the relay while the + Collector exporter is up: the relay is stopped or cannot read + PostgreSQL, and MessengerQueueLagHigh is blind. Runbook: + infra/otel/runbooks/MessengerQueueMetricsMissing.md + runbook_url: infra/otel/runbooks/MessengerQueueMetricsMissing.md + + # оповещения о самом конвейере телеметрии + - name: telemetry-alerts + interval: 15s + rules: + - alert: TelemetryTargetDown + expr: up{job=~"otel-collector|loki|tempo|haproxy"} == 0 + for: 1m + labels: + severity: warning + annotations: + summary: 'Metrics target {{ $labels.job }} is down' + description: >- + Prometheus cannot scrape {{ $labels.job }} ({{ $labels.instance }}) + for a minute; with job haproxy the load balancer metrics are missing + and MessengerHighErrorRate is blind. Runbook: + infra/otel/runbooks/TelemetryTargetDown.md + runbook_url: infra/otel/runbooks/TelemetryTargetDown.md + - alert: TelemetryDataLoss + # рост суммы потерь процесса за 2 мин; новый ряд — целиком рост, сброс + # суммы (рестарт Collector) — отрицательный, оповещения нет + expr: telemetry:lost_items:total - (telemetry:lost_items:total offset 2m or telemetry:lost_items:total * 0) > 0 + labels: + severity: warning + annotations: + summary: 'Telemetry of {{ $labels.job }} is being lost' + description: >- + {{ $labels.job }} ({{ $labels.instance }}) lost {{ $value }} spans, + log records or metric points in the last 2 minutes (full queue, + failed export or refused by the memory limiter). Runbook: + infra/otel/runbooks/TelemetryDataLoss.md + runbook_url: infra/otel/runbooks/TelemetryDataLoss.md diff --git a/infra/otel/runbooks/MessengerHighErrorRate.md b/infra/otel/runbooks/MessengerHighErrorRate.md new file mode 100644 index 0000000..bea4e09 --- /dev/null +++ b/infra/otel/runbooks/MessengerHighErrorRate.md @@ -0,0 +1,68 @@ +# MessengerHighErrorRate + +Правило — `infra/otel/prometheus/rules.yml`, группа `messenger-alerts`; решения — design change +`slo-alerts`, решения 1, 2, 4. `severity: critical`. + +## Что значит и на что влияет + +Больше 5 % ответов публичного frontend LB (`entry`) за последние 2 минуты — 5xx, при трафике больше +0,1 запроса/с, одну минуту подряд. В счёт входят и 5xx реплик API, и ответы, которые сгенерировал +сам LB (502, 503, 504): клиент видит отказ. Порог — 10 × допустимой доли SLO доступности (99,5 % +за 7 суток): при такой доле бюджет 7 суток уходит за ~17 часов. + +## Первые панели + +Dashboard «Messenger overview»: + +1. «SLO and alerts» → «Alert windows: 5xx share on LB and slow light requests (2 min)» — доля 5xx + на LB, порог 5 %; «Alert states» — что ещё в pending / firing. +2. «Load balancer» → «5xx on LB and 5xx of API per second» — кто отвечает 5xx; «Ready replicas in + LB» — сколько реплик в балансировке. +3. «API (messenger-api)» → «Error ratio (5xx of all requests)», «Requests per second by route and + status class» — какие маршруты. + +## Диагностика (только по сохранённым наблюдениям) + +Шаг 1 — кто отвечает 5xx. Prometheus: + +```promql +sum(rate(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry",code="5xx"}[2m])) +sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[2m])) +max(haproxy_backend_active_servers{job="haproxy",proxy="api"}) +``` + +- **PostgreSQL недоступен.** 5xx на LB растут, 5xx API — около нуля (запросы до API не доходят), + готовых реплик 0, вместе с этим в firing `MessengerNoReadyReplicas`. Метрики API почти без + запросов — поэтому SLI доступности считается на LB. Loki: + `{service_name="messenger-api"} |= "Database is unavailable"` — записи `warning` реплик (модуль + `database`) в начале отказа; Tempo: `{ resource.service.name = "messenger-api" && status = error + && span.db.system.name = "postgresql" }` — span запроса PostgreSQL с ошибкой у 503 реплик до + вывода их из LB. +- **Отказ реплик API (процесс).** 5xx на LB — 502 / 503 / 504, готовых реплик меньше + `API_REPLICAS`, 5xx API — нет. `make lb_stats` — состояние слотов; журнал LB `docker compose logs + haproxy` — смена состояния слотов и ответы LB (успешные не пишутся). +- **5xx самого API.** 5xx API ≈ 5xx на LB, готовые реплики на месте. По маршрутам: + `sum by (http_route, http_response_status_code) (rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[2m]))`; + 503 вложений при работающем остальном API — S3 (`{service_name="messenger-api"} |= "Object storage + is unavailable"`, span `S3.*` с ошибкой); 500 — дефект: Tempo `{ resource.service.name = + "messenger-api" && status = error }`, `span.error.type` — класс исключения, traceback — запись + журнала с тем же `trace_id`. + +## Действия + +- PostgreSQL: `docker compose ps postgres`, `docker compose start postgres` (или `make start_db`), + затем `make lb_stats` — реплики `UP`. +- Реплики: `make replicas` (вернуть остановленные), `docker compose logs --no-log-prefix api`. +- S3: `docker compose ps s3`, `make start_s3`. + +## Восстановление + +Оповещение снимается через 2–3 минуты после конца отказа (окно 2 мин). Проверить: +`messenger:lb_http_errors:ratio_rate2m` ниже 0,05, готовых реплик `API_REPLICAS`, `make test` — +`PASS`. Сколько бюджета ушло — панель «SLI over the dashboard range» за интервал отказа. + +## Связанные оповещения + +`MessengerNoReadyReplicas` (все реплики вне LB — почти всегда PostgreSQL), +`TelemetryTargetDown{job="haproxy"}` (LB недоступен — это оповещение слепо), +`MessengerQueueMetricsMissing` в pending при недоступном PostgreSQL (relay не читает снимок). diff --git a/infra/otel/runbooks/MessengerNoReadyReplicas.md b/infra/otel/runbooks/MessengerNoReadyReplicas.md new file mode 100644 index 0000000..eeef4e7 --- /dev/null +++ b/infra/otel/runbooks/MessengerNoReadyReplicas.md @@ -0,0 +1,52 @@ +# MessengerNoReadyReplicas + +Правило — `infra/otel/prometheus/rules.yml`, группа `messenger-alerts`; решения — design change +`slo-alerts`, решения 2, 4. `severity: critical`. + +## Что значит и на что влияет + +LB не видит ни одной реплики API, прошедшей проверку готовности (`/health/ready`), 30 секунд +подряд. Все запросы клиентов получают 503 от самого LB (формат ошибки контракта, без +`X-Instance-Id`). Срабатывает и без трафика. Все реплики сразу выходят из LB почти всегда из-за +PostgreSQL: `/health/ready` проверяет только его. + +## Первые панели + +1. «Load balancer» → «Ready replicas in LB», «5xx on LB and 5xx of API per second». +2. «SLO and alerts» → «Alert states» — `MessengerHighErrorRate` при трафике рядом. + +## Диагностика (только по сохранённым наблюдениям) + +```promql +max(haproxy_backend_active_servers{job="haproxy",proxy="api"}) +sum by (code) (rate(haproxy_frontend_http_responses_total{job="haproxy",proxy="entry"}[2m])) +sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[2m])) +up{job="haproxy"} +``` + +- **PostgreSQL недоступен.** Готовых реплик 0, ответы LB — 5xx, запросов в метриках API почти нет + (реплики живы, но вне LB). Loki: `{service_name="messenger-api"} |= "Database is unavailable"` — + записи реплик в начале отказа; Tempo: `{ resource.service.name = "messenger-api" && status = error + && span.db.system.name = "postgresql" }`. Состояние: `docker compose ps postgres`. +- **Реплики остановлены или падают.** Метрик реплик нет (`up` есть, а рядов + `http_server_request_duration_seconds_count` с их `instance` больше нет), `docker compose ps api` + — `exited` или `restarting`; журнал — `docker compose logs --no-log-prefix api`. +- **Ряд пропал совсем** — недоступен сам LB или Collector: тогда это оповещение молчит, а + срабатывает `TelemetryTargetDown` (`job="haproxy"` или `otel-collector`). + +## Действия + +- PostgreSQL: `docker compose start postgres` (или `make start_db`); реплики вернутся в LB сами за + ≤ 1,5 с после готовности. +- Реплики: `make replicas`. +- `make lb_stats` — слоты `UP`. + +## Восстановление + +Оповещение снимается на первом вычислении после возврата реплики (≤ 30 с). Проверить: готовых +реплик `API_REPLICAS`, `make test` — `PASS`. + +## Связанные оповещения + +`MessengerHighErrorRate` (при трафике — те же 503 LB), `MessengerQueueMetricsMissing` (relay тоже не +читает PostgreSQL), `TelemetryTargetDown{job="haproxy"}`. diff --git a/infra/otel/runbooks/MessengerQueueLagHigh.md b/infra/otel/runbooks/MessengerQueueLagHigh.md new file mode 100644 index 0000000..0498d7a --- /dev/null +++ b/infra/otel/runbooks/MessengerQueueLagHigh.md @@ -0,0 +1,60 @@ +# MessengerQueueLagHigh + +Правило — `infra/otel/prometheus/rules.yml`, группа `messenger-alerts`; решения — design change +`slo-alerts`, решение 4. `severity: warning`. + +## Что значит и на что влияет + +Старейшее незавершённое задание обработки вложения (`queued` или `processing`) ждёт дольше 60 +секунд, одну минуту подряд (растущий queue lag). Источник — снимок очереди relay из PostgreSQL. +Вложения остаются `queued`: загрузка отвечает 202, текст и история работают, превью и варианты не +появляются. Такое задание уже нарушает SLO времени до `ready` (30 с). + +## Первые панели + +1. «Pipeline» → «Age of the oldest unfinished job» (растёт линейно, если не разбирается ничего), + «Queue depth by stage» (какая стадия копится), «Time to ready p50, p95 and p99». +2. «Worker» → «Jobs per second by outcome»; «Saturation» → «Worker saturation». + +## Диагностика (только по сохранённым наблюдениям) + +```promql +max by (messenger_queue_stage) (messenger_queue_depth{job="messenger-relay"}) +max(messenger_queue_oldest_age_seconds{job="messenger-relay"}) +sum(rate(messenger_job_duration_seconds_count{job="messenger-worker"}[2m])) +count(messenger_worker_capacity{job="messenger-worker"}) +``` + +- **Worker остановлен или упал.** Растут `outbox` и `published` (relay публикует, никто не берёт), + возраст растёт линейно, заданий в секунду 0, рядов `messenger-worker` нет (`count(...)` пусто — + экспортёр убирает ряды остановленного процесса через ≤ 75 с). Loki: + `{service_name="messenger-worker"}` — последняя запись worker (запись «Stopped worker» пишется + после закрытия SDK, только в stdout: `docker compose logs --no-log-prefix worker`); Tempo: `{ + resource.service.name = "messenger-worker" && kind = consumer }` — consumer span после момента + остановки нет. +- **Worker перегружен.** Растёт `published`, задания в секунду есть, «Worker saturation» у 1, + «Worker deliveries waiting for a slot» > 0, время задания (`Job duration`) выросло. +- **Задания ждут повтора.** Растёт `scheduled` (временные ошибки: S3, PostgreSQL), в журнале worker — + `{service_name="messenger-worker"} |= "Retrying job"` с `reason`. +- **Relay не публикует.** Растёт `outbox`, `published` нет — брокер недоступен: + `{service_name="messenger-relay"} |= "Broker is unavailable"`. + +## Действия + +- Worker: `docker compose ps worker`, `docker compose start worker` (или `docker compose up -d + --no-deps worker`). +- Брокер: `make start_broker`. +- Перегрузка: второй worker или конкуренция по `.claude/rules/worker.md` («Подбор конкуренции»). + +## Восстановление + +После запуска worker очередь разбирается за секунды, возраст падает до нуля, оповещение снимается +на первом вычислении ниже порога (≤ 2 мин с учётом сбора). Проверить: все вложения прогона +`ready` (`GET /api/v1/attachments/{id}`), «Queue depth by stage» — ноль, время до `ready` этих +вложений — не меньше длительности остановки (SLI времени до `ready` за окно — «SLI over the dashboard +range»). + +## Связанные оповещения + +`MessengerQueueMetricsMissing` — снимка нет, и это оповещение слепо (relay остановлен или не читает +PostgreSQL); `TelemetryTargetDown{job="otel-collector"}` — метрик нет совсем. diff --git a/infra/otel/runbooks/MessengerQueueMetricsMissing.md b/infra/otel/runbooks/MessengerQueueMetricsMissing.md new file mode 100644 index 0000000..7e25b70 --- /dev/null +++ b/infra/otel/runbooks/MessengerQueueMetricsMissing.md @@ -0,0 +1,50 @@ +# MessengerQueueMetricsMissing + +Правило — `infra/otel/prometheus/rules.yml`, группа `messenger-alerts`; решения — design change +`slo-alerts`, решения 4, 6. `severity: warning`. + +## Что значит и на что влияет + +Снимка очереди relay (`messenger_queue_oldest_age_seconds{job="messenger-relay"}`) нет две минуты +подряд, хотя экспортёр Collector доступен. Значит, relay остановлен или не читает PostgreSQL дольше +30 с (снимок старше 30 с не отдаётся, экспортёр убирает ряд через минуту). Оповещение +`MessengerQueueLagHigh` слепо. Если relay остановлен, новые задания не публикуются: вложения +остаются `queued`. При недоступном экспортёре Collector оповещение молчит — там срабатывает +`TelemetryTargetDown`. + +## Первые панели + +1. «Pipeline» → «Queue depth by stage», «Age of the oldest unfinished job» — пустые с момента + отказа. +2. «Telemetry pipeline» → «Metrics targets up» — Collector доступен. + +## Диагностика (только по сохранённым наблюдениям) + +```promql +absent(messenger_queue_oldest_age_seconds{job="messenger-relay"}) +up{job="otel-collector-exporter"} +count by (job) (target_info{job="messenger-relay"}) +``` + +- **Relay остановлен.** Рядов `messenger-relay` нет совсем (`target_info` тоже пуст), `docker + compose ps relay` — `exited`; Loki: `{service_name="messenger-relay"}` — записей после остановки + нет (запись «Stopped relay» — только в stdout: `docker compose logs --no-log-prefix relay`). +- **Relay жив, PostgreSQL недоступен.** `target_info{job="messenger-relay"}` есть, а снимка нет; + Loki: `{service_name="messenger-relay"} |= "Database is unavailable"` или `|= "Relay pass was + interrupted"`; рядом `MessengerNoReadyReplicas`. + +## Действия + +- Relay: `docker compose start relay` (или `docker compose up -d --no-deps relay`). +- PostgreSQL: `docker compose start postgres`. + +## Восстановление + +Первый снимок приходит через ≤ 5 с после прохода relay и ≤ 15 с отправки метрик, оповещение +снимается на следующем вычислении (≤ 2 мин). Проверить: ряды глубины и возраста снова есть, очередь +разобрана. + +## Связанные оповещения + +`MessengerQueueLagHigh` (слепо, пока снимка нет), `MessengerNoReadyReplicas` (PostgreSQL), +`TelemetryTargetDown` (экспортёр Collector недоступен — это оповещение подавлено). diff --git a/infra/otel/runbooks/MessengerSlowRequests.md b/infra/otel/runbooks/MessengerSlowRequests.md new file mode 100644 index 0000000..0ea30d8 --- /dev/null +++ b/infra/otel/runbooks/MessengerSlowRequests.md @@ -0,0 +1,75 @@ +# MessengerSlowRequests + +Правило — `infra/otel/prometheus/rules.yml`, группа `messenger-alerts`; решения — design change +`slo-alerts`, решения 1, 4. `severity: warning`. + +## Что значит и на что влияет + +Больше 10 % «лёгких» запросов API без 5xx за последние 2 минуты длились дольше 0,25 с, при трафике +больше 0,1 запроса/с, одну минуту подряд. «Лёгкие» — все маршруты, кроме регистрации и входа (KDF +пароля), загрузки и скачивания байтов вложения. Порог — 10 × допустимой доли SLO задержки (99 % за +7 суток). Клиенты ждут дольше обычного; ошибок может не быть. + +## Первые панели + +1. «SLO and alerts» → «Alert windows: 5xx share on LB and slow light requests (2 min)» — доля + медленных, порог 10 %; «Slow light requests (traces longer than 0.25 s)» — трассы. +2. «API (messenger-api)» → «Request duration p95 by route» — какой маршрут медленный. +3. «Saturation» → «PostgreSQL pool: used of max», «PostgreSQL pool: waiting», «Container CPU of + limit». + +## Диагностика (только по сохранённым наблюдениям) + +Шаг 1 — какие маршруты медленные: + +```promql +histogram_quantile(0.95, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[2m]))) +``` + +Шаг 2 — трасса медленного запроса. Tempo (TraceQL): + +```traceql +{ kind = server && resource.service.name = "messenger-api" && duration > 250ms && span.http.route = "/api/v1/chats/{chat_id}/messages" } +``` + +В трассе сравнить длительность server span и сумму span PostgreSQL (`INSERT`, `SELECT`, `COMMIT`, +атрибут `db.system.name = "postgresql"`). + +Шаг 3 — пул и CPU: + +```promql +sum by (job, instance) (db_client_connection_count{db_client_connection_state="used"}) / sum by (job, instance) (db_client_connection_max) +sum by (job, instance) (db_client_connection_pending_requests) +sum by (job, instance) (rate(container_cpu_time_seconds_total{job="messenger-api"}[2m])) / sum by (job, instance) (messenger_container_cpu_limit{job="messenger-api"}) +``` + +- **Медленная БД (блокировка, тяжёлый запрос, нехватка CPU PostgreSQL).** Медленны маршруты, + которые пишут или читают затронутую таблицу (например, только отправка сообщения); в медленной + трассе span PostgreSQL занимают больше половины server span; занятость пула выше обычной, есть + ожидающие соединения; CPU реплик ниже половины предела. Кто держит блокировку — `docker compose + exec postgres psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "SELECT pid, application_name, state, + wait_event_type, query FROM pg_stat_activity WHERE wait_event_type = 'Lock' OR state = 'idle in + transaction'"`. +- **Медленный handler (CPU реплики).** Длинный server span, span PostgreSQL короткие (меньше пятой + части), пул свободен, ожидающих нет, CPU реплик у предела. Если медленны только вход и + регистрация (KDF) — это вне SLI, и оповещение не срабатывает: длительность входа видна на панели + квантилей по маршрутам. +- **Перегрузка.** Растёт RPS («Requests per second by route and status class»), медленны все + маршруты, CPU реплик или PostgreSQL у предела. + +## Действия + +- Блокировка: найти сессию по `pg_stat_activity` и завершить (`SELECT pg_terminate_backend()`), + выяснить, кто её взял (`application_name`). +- CPU реплик: `make replicas API_REPLICAS=` (больше реплик), разбор горячего маршрута по трассам. + +## Восстановление + +Оповещение снимается через 2–4 минуты после конца причины. Проверить: +`messenger:http_light_slow:ratio_rate2m` ниже 0,1, p95 маршрутов вернулся, SLI задержки за +интервал — панель «SLI over the dashboard range». + +## Связанные оповещения + +`MessengerHighErrorRate` (если медленная БД дошла до сроков — 503 и 504), `MessengerNoReadyReplicas` +(проверка готовности тоже не укладывается в срок). diff --git a/infra/otel/runbooks/TelemetryDataLoss.md b/infra/otel/runbooks/TelemetryDataLoss.md new file mode 100644 index 0000000..55a5884 --- /dev/null +++ b/infra/otel/runbooks/TelemetryDataLoss.md @@ -0,0 +1,60 @@ +# TelemetryDataLoss + +Правило — `infra/otel/prometheus/rules.yml`, группа `telemetry-alerts`; решения — design change +`slo-alerts`, решения 7–9. `severity: warning`, без `for`: потеря уже случилась. + +## Что значит и на что влияет + +Сумма учтённых потерь телеметрии процесса (`telemetry:lost_items:total`) выросла за последние 2 +минуты. Потери считают: + +| Где | Счётчик | +| --- | --- | +| очередь SDK (API, worker, relay) | `otel_sdk_processor_{span,log}_processed_total{error_type="queue_full"}` | +| отправка SDK | `otel_sdk_exporter_{span,log}_exported_total{error_type!=""}` | +| приём Collector (`memory_limiter`) | `otelcol_receiver_refused_{spans,log_records,metric_points}` | +| очередь экспорта Collector полна | `otelcol_exporter_enqueue_failed_{spans,log_records}` | +| повторы экспорта Collector истекли (30 с) | `otelcol_exporter_send_failed_{spans,log_records}` | + +Пропали трассы или записи журнала за интервал отказа; сообщения и вложения не затронуты. Метрики +cumulative не теряют счёт — только точки. + +## Первые панели + +«Telemetry pipeline» → «Telemetry lost per second by place», «Collector export queues, share of +capacity», «SDK queues, share of capacity», «Metrics targets up», «Collector memory». + +## Диагностика (только по сохранённым наблюдениям) + +```promql +telemetry:lost_items:total +sum by (job, instance, __name__, exporter, error_type) ({__name__=~"otelcol_(receiver_refused|exporter_send_failed|exporter_enqueue_failed)_(spans|log_records|metric_points)"}) +sum by (job, instance, __name__, error_type) ({__name__=~"otel_sdk_(processor|exporter)_(span|log)_(processed|exported)_total",error_type!=""}) +``` + +- **Хранилище (Tempo / Loki) недоступно дольше 30 с.** Растут `enqueue_failed` и `send_failed` + экспортёра этого хранилища (`exporter="otlp_http/tempo"`), очередь у ёмкости, рядом + `TelemetryTargetDown{job="tempo"}`. SLI приложения прежние. +- **Collector недоступен или перегружен.** После его возврата растут счётчики SDK реплик + (`error_type="queue_full"` — очередь 2048 заполнилась; `error_type="ConnectionError"` или + `ReadTimeout` — отправка не удалась за 2 с); записей Loki за окно отказа меньше, чем в stdout + (`docker compose logs --no-log-prefix api`). +- **Предел памяти Collector.** Растут `otelcol_receiver_refused_*`, «Collector memory» у мягкого + предела `memory_limiter` (160 МиБ); журнал Collector — «Memory usage is above soft limit». + +## Действия + +Вернуть хранилище или Collector (`docker compose start <сервис>`, runbook `TelemetryTargetDown`). +Предел памяти — разобрать всплеск (пик span/с на панелях), при необходимости поднять лимит +контейнера по правилу «лимит ≥ 1,5 × пика» (`.claude/rules/telemetry.md`). + +## Восстановление + +Оповещение снимается через 2 минуты без нового роста. Число потерь за отказ — разность +`telemetry:lost_items:total` до и после (рестарт Collector сбрасывает его счётчики — рост +отрицательный, оповещения нет). + +## Связанные оповещения + +`TelemetryTargetDown` (причина долгого отказа), `MessengerQueueMetricsMissing` (не срабатывает при +недоступном Collector). diff --git a/infra/otel/runbooks/TelemetryTargetDown.md b/infra/otel/runbooks/TelemetryTargetDown.md new file mode 100644 index 0000000..eed8d63 --- /dev/null +++ b/infra/otel/runbooks/TelemetryTargetDown.md @@ -0,0 +1,59 @@ +# TelemetryTargetDown + +Правило — `infra/otel/prometheus/rules.yml`, группа `telemetry-alerts`; решения — design change +`slo-alerts`, решения 2, 4, 7. `severity: warning`. + +## Что значит и на что влияет + +Prometheus минуту не может собрать метрики цели `otel-collector` (собственные метрики Collector), +`loki`, `tempo` или `haproxy` (метрики LB через приёмник Collector). Приложение от телеметрии не +зависит: API и worker работают, `make test` проходит. Теряется наблюдаемость: + +- `otel-collector` — Collector недоступен: метрик, логов и трасс приложения нет, SDK копит в своих + очередях и теряет сверх них (учтено, `TelemetryDataLoss` после возврата); +- `loki` / `tempo` — хранилище недоступно: Collector держит данные в очереди экспорта (16 / 8 МиБ) + и повторяет 30 с, дальше отбрасывает (учтено); +- `haproxy` — LB недоступен для сбора (или сам LB лежит): `MessengerHighErrorRate` и + `MessengerNoReadyReplicas` слепы. + +## Первые панели + +«Telemetry pipeline» → «Metrics targets up», «Collector export queues, share of capacity», +«Telemetry lost per second by place», «Collector memory». + +## Диагностика (только по сохранённым наблюдениям) + +```promql +up{job=~"otel-collector|otel-collector-exporter|loki|tempo|haproxy"} +max by (exporter) (otelcol_exporter_queue_size{job="otel-collector"}) / max by (exporter) (otelcol_exporter_queue_capacity{job="otel-collector"}) +sum by (exporter) (otelcol_exporter_send_failed_spans{job="otel-collector"}) +otelcol_process_runtime_total_sys_memory_bytes{job="otel-collector"} +``` + +- **Tempo или Loki остановлен.** `up{job="tempo"}` (или `loki`) = 0, очередь экспорта этого + хранилища растёт к ёмкости, потом растут `otelcol_exporter_enqueue_failed_*` и + `otelcol_exporter_send_failed_*`; память Collector ниже лимита (256 МиБ); метрики приложения и SLI + прежние — теряется телеметрия, а не сообщения. Журнал Collector: `docker compose logs + otel-collector` — «Exporting failed» с именем экспортёра. `docker compose ps tempo loki`. +- **Collector остановлен.** `up{job="otel-collector"}` и `up{job="otel-collector-exporter"}` = 0, + ряды приложения пропали, `MessengerQueueMetricsMissing` подавлено. В stdout реплик — записи SDK + «Failed to export» не чаще раза в минуту на логгер. +- **LB.** `up{job="haproxy"}` = 0 при работающем Collector — LB недоступен по `haproxy:8404`: + `docker compose ps haproxy`, `make lb_stats`. + +## Действия + +`docker compose start <сервис>` (`otel-collector`, `loki`, `tempo`, `haproxy`); после правки +конфигурации — `docker compose up -d --force-recreate <сервис>`. + +## Восстановление + +`up` = 1, оповещение снимается на следующем вычислении. Очередь экспорта разбирается до нуля, +новые записи и трассы находятся (Loki `{service_name="messenger-api"}`, Tempo `{ +resource.service.name = "messenger-api" }`). Потери за отказ — счётчики `TelemetryDataLoss`. + +## Связанные оповещения + +`TelemetryDataLoss` (потери долгого отказа), `MessengerQueueMetricsMissing` (подавлено при +недоступном экспортёре Collector), `MessengerHighErrorRate` (слепо при `job="haproxy"`). +Отказ самого Prometheus оповещением не ловится: в Grafana — ошибка источника. diff --git a/openspec/changes/slo-alerts/design.md b/openspec/changes/slo-alerts/design.md index 0b5cf4c..17bda28 100644 --- a/openspec/changes/slo-alerts/design.md +++ b/openspec/changes/slo-alerts/design.md @@ -504,3 +504,74 @@ COMMIT=<прежний> MIGRATE=0`; схема не меняется, нули Блокирующих нет. Решения без пользователя и вопросы, которые не меняют спеки и задачи, — `QUESTIONS.md`, раздел `## slo-alerts`. + +## Уточнения apply + +1. **Тестовые получатели (решение 8).** `core.Exporters.spans` и `.logs` могут быть `None` — тогда `sdk.build()` строит + экспортёр OTLP из `[telemetry]` с `meter_provider` процесса: так быстрый тест проверяет счёт неудачных отправок + настоящего экспортёра на подставной `requests.Session.send` (сети нет). `otlp_exporters()` заменён тремя функциями + (`otlp_metric_reader`, `otlp_span_exporter`, `otlp_log_exporter`); прежний тест прокси окружения — на них. +2. **Переменная внутренних метрик.** `_internal_metrics()` после сборки возвращает прежнее состояние окружения, а не + удаляет переменную безусловно: внешнее значение к этому моменту уже удалил `remove_otel_environment()`, так что итог тот + же (переменной нет — тест), а прямой вызов `core.start()` без удаления чужое окружение не портит. +3. **Имена SDK в Prometheus (9.4).** Как в пробе, плюс метка `otel_scope_name="opentelemetry-sdk"`; ёмкость очередей SDK + у `messenger-api`, `messenger-worker`, `messenger-relay` — 2048; гистограмм SDK нет. Ряды HAProxy после отбора — 31 + (frontend `entry` и `monitor` по `code`, backend `api`), `up{job="haproxy"}` = 1. +4. **Протоколы scrape (решение 6).** Список Prometheus 3.15.1 по умолчанию снят с `/api/v1/status/config` без флага: + `OpenMetricsText1.0.0, OpenMetricsText0.0.1, PrometheusText1.0.0, PrometheusText0.0.4` — он и записан глобально. Число + рядов экспортёра на процесс до и после перехода на protobuf: API 265 → 235, relay 15 → 15, worker 70 → 42 (после + рестартов меньше маршрутов и исходов, а не больше); двойников нет — число рядов равно числу разных наборов меток. +5. **Панели (решение 10).** `rate()` по селектору `{__name__=~…}` убирает `__name__`, и ряды разных имён с одними метками + совпадают — 422 «vector cannot contain metrics with the same labelset» (первый пробный прогон `alerts-check`). + Составляющие потерь на панели — `rate(label_replace({…}, "metric", "$1", "__name__", …)[5m:15s])`: имя ряда — метка + `metric`, подзапрос с шагом сбора. Макрос `$__range` драйвер подменяет на `1h` (`panel_expr`) в обходе панелей + `telemetry-check`, `trace-chain` и `alerts-check`; панели SLI — `instant`. +6. **`telemetry-check` (11.4).** В него добавлены сценарии «Метрики балансировщика без доступа к сети хранилищ» и + `load-balancing` «Метрики балансировщика» (`lb_metrics_rows`): сети LB, порт 8404 не опубликован, у Prometheus нет цели + LB, ряды `haproxy_*`, рост ответов frontend на 20 своих запросов; цель `haproxy` — в списке целей `up`. +7. **Нагрузка драйвера (решение 11).** 6 потоков отправки раз в 0,25 с и 1 поток чтения раз в 1 с (~25 запросов/с): + при равных долях запись, ждущая блокировку, почти не делает запросов, и доля медленных «лёгких» опускалась бы ниже + 10 %. Первый пробный прогон (чтение тоже раз в 0,25 с): доля 0,214, firing через 165 с при сроке 180 — запаса мало, + чтение реже (оценка ~29 %). Медленный handler — 3 потока входа, а не 4: при 4 CPU реплик доходил до 0,77 предела и + доля медленных «лёгких» — до 0,062 при пороге 0,1; вход и при 3 потоках медленнее 0,25 с (p95 0,92 с при 4). + Второй пробный прогон: доля 0,29, но firing всё равно через 166 с — время задают конвейер (экспорт SDK 15 с, сбор + 15 с, слот точки правила 15 с) и `for` 1 мин, а не доля. Пауза блокировки — 0,2 с вместо 0,5 (решение 11): в паузе + поток записи успевает ~1 быстрый запрос, доля ~0,4, порог окна 2 мин пересекается на ~13 с раньше. +8. **Grafana и правила источника (7.1).** Правила источника — `GET /api/prometheus/prometheus/api/v1/rules` (uid + `prometheus`), правка — `POST /api/ruler/prometheus/api/v1/rules/` отклоняется (у Prometheus нет ruler API). +9. **Недоступная БД, наблюдение трасс.** При остановленном PostgreSQL отказ — на выдаче соединения из пула, до + `before_cursor_execute`, поэтому span PostgreSQL с ошибкой может и не быть: `alerts-check` печатает число трасс с + ошибкой server span и с ошибкой span PostgreSQL как наблюдение, без проверки. +10. **`promtool`:** `_xN` во входных рядах — N пропусков (не N + 1, как у `a xN`); в `exp_annotations` — все аннотации + дословно, с подставленным `$value`. +11. **Время точек правил.** Prometheus 3.15 пишет результат вычисления группы с временем предыдущего слота: вычисление + `messenger-slo` в 20:07:46 дало точку с временем 20:02:46 (у групп 15 с — то же со сдвигом 15 с). Окно точки верное + (`increase(…[5m])` на её время), но мгновенный запрос «сейчас» видит запись приращений 5–10 мин давности и не видит + её вовсе, когда она старше lookback (5 мин). Поэтому сверка SLI за час в `alerts-check` берёт время последней точки + из сырых точек ряда и считает оба пути на него, SLI за окно учений — по исходным счётчикам, а панель «SLI over the + dashboard range» отстаёт на 5–10 мин (ограничение в `REPORT.md`). +12. **Сверка SLI за час (решение 1, спек «SLO считается»).** `increase(…[1h])` одним окном с суммой 5-минутных + приращений не совпадает по двум причинам, и обе — не ошибка правил: (а) непересекающиеся окна `increase(…[5m])` + теряют приращение между последним сбором одного окна и первым следующего (~15 с из 300, ~5 % событий наугад) — у + времени до `ready` за час единицы событий, и одно потерянное меняет SLI на 10–25 п. п. (третий пробный прогон: 0,248 + по правилам против 0,400 одним окном при 8 событиях); (б) пока Prometheus остановлен (`backend-outage`), правила не + вычисляются, и окна в рядах правил нет. Поэтому «по исходным счётчикам» в `alerts-check` — сумма `increase(…[5m])` + исходных селекторов на время каждой точки правила за час (те же окна, выражения независимы от правил); `increase` за + час одним окном печатается рядом как наблюдение, число окон за час — тоже. Для сигнала времени до `ready` команда + перед шагами грузит 20 файлов при работающем worker. Потеря на границах окон — ограничение SLI по рядам правил в + `REPORT.md`. +13. **Бюджет (решение 13, 9.8, пробные прогоны).** Collector в долгом отказе Loki и Tempo под нагрузкой: `docker stats` + до 200 МиБ, `memory.peak` 220–256 МиБ, из них файловый кэш 157–187, `anon` + `kernel` + `shmem` 62–72 МиБ, + `otelcol_process_runtime_total_sys_memory_bytes` до 80 МиБ; очередь Tempo — до 0,63 ёмкости, Loki — 0,13. Правило + «лимит ≥ 1,5 × пика» по неосвобождаемой части выполнено (1,5 × 72 = 108 ≤ 256), лимит прежний. Prometheus в + `alerts-check`: `memory.peak` 240 МиБ (кэш 148), неосвобождаемая 53–83 — 1,5 × 240 = 360 ≤ 384. Реплики API в отказе + Collector: `memory.current` без роста (191 → 187 и 160 → 160 МиБ), `memory.peak` 417–441 с начала жизни (входы + `alerts-check`), неосвобождаемая 137–138. Лимиты и суммы не меняются; числа для evidence — раздел change в + `evidence/telemetry/budget.md` (11.4). +14. **«Ожидающих соединения пула нет» (спек «Медленный handler не путается с БД»).** `db.client.connection.pending_requests` + (`CountingQueuePool.pending()`) считает весь `Pool.connect()` — ожидание места, открытие и проверку `;` при выдаче. + Под CPU входов выборка раз в 15 с в четвёртом пробном прогоне застала 1 (проверка при выдаче в полёте), хотя пул был + занят на 0,3. Проверка шага — «ни один запрос не ждёт свободного места»: доля занятых соединений пула каждой реплики + в окне меньше 1 и отказов по сроку нет; наибольшее `pending` печатается как наблюдение. +15. **ВМ.** Во время первого пробного прогона `alerts-check` пользователь перезапустил ВМ Docker Desktop с памятью 12 ГБ + (MemTotal 11 902 МиБ): прогон прерван ошибкой соединения с Grafana и повторён; строки бюджета — по новой ВМ. diff --git a/openspec/changes/slo-alerts/tasks.md b/openspec/changes/slo-alerts/tasks.md index f2d2b99..50a66cc 100644 --- a/openspec/changes/slo-alerts/tasks.md +++ b/openspec/changes/slo-alerts/tasks.md @@ -11,20 +11,20 @@ ## 1. Правила и константы -- [ ] 1.1 Прочитать (Read) правила `telemetry.md`, `docker.md`, `balancer.md`, `infra.md`, `logging.md`, `settings.md`, +- [x] 1.1 Прочитать (Read) правила `telemetry.md`, `docker.md`, `balancer.md`, `infra.md`, `logging.md`, `settings.md`, `service-tests.md`, `run-modes.md`, `bench.md`, `student-tests.md` — до правок файлов их слоёв. Проверка: каждое прочитано через Read в этой сессии. -- [ ] 1.2 Константы `src/utils/constants.py` (8): имя переменной внутренних метрик SDK, имена гистограмм SDK, которые не +- [x] 1.2 Константы `src/utils/constants.py` (8): имя переменной внутренних метрик SDK, имена гистограмм SDK, которые не отдаются (`otel.sdk.exporter.operation.duration`, `otel.sdk.metric_reader.collection.duration`). Проверка: `make lint`. ## 2. SDK: внутренние метрики (8, 9) -- [ ] 2.1 `src/infra/telemetry/sdk.py`: сначала `MeterProvider`, затем процессоры span и журнала и экспортёры OTLP span и +- [x] 2.1 `src/infra/telemetry/sdk.py`: сначала `MeterProvider`, затем процессоры span и журнала и экспортёры OTLP span и журнала с `meter_provider=`; переменная внутренних метрик ставится только на время их конструирования и удаляется в `finally`; Views `DropAggregation` для гистограмм SDK; `otlp_exporters` разделён так, чтобы экспортёры span и журнала получали провайдер. Тестовые получатели (`core.Exporters`) — прежним путём. Проверка: тесты 2.2; прежние тесты `test_telemetry.py` зелёные (там, где считаются все метрики провайдера, — с учётом имён `otel.sdk.*`). -- [ ] 2.2 Быстрые тесты `service-tests/unit/test_telemetry.py` без сети: очередь 2 и блокирующий экспортёр — растёт +- [x] 2.2 Быстрые тесты `service-tests/unit/test_telemetry.py` без сети: очередь 2 и блокирующий экспортёр — растёт `otel.sdk.processor.span.processed` с `error.type` = `queue_full`; экспортёр OTLP с подставной `requests.Session`, которая бросает `ConnectionError`, — растёт `otel.sdk.exporter.span.exported` с `error.type`; то же для журнала; гистограмм SDK нет; после `start()` переменной в окружении нет; внешняя `OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED=false` удалена с @@ -33,14 +33,14 @@ ## 3. HAProxy (2) -- [ ] 3.1 `infra/haproxy/haproxy.cfg`, `frontend monitor`: `http-request use-service prometheus-exporter if { path /metrics }` +- [x] 3.1 `infra/haproxy/haproxy.cfg`, `frontend monitor`: `http-request use-service prometheus-exporter if { path /metrics }` с комментарием (забирает только Collector, наружу не публикуется). Проверка: `haproxy -c` в закреплённом образе с `API_PORT`; после 9.3 — `make lb_stats` (обе реплики `UP`), а `/metrics?scope=frontend&scope=backend` изнутри контейнера LB (`bash` и `/dev/tcp`) отдаёт `haproxy_frontend_http_responses_total`. ## 4. Collector (2, 6, 7) -- [ ] 4.1 `infra/otel/collector.yaml`: приёмник `prometheus/haproxy` (цель `haproxy:8404`, `/metrics`, `scope` frontend и +- [x] 4.1 `infra/otel/collector.yaml`: приёмник `prometheus/haproxy` (цель `haproxy:8404`, `/metrics`, `scope` frontend и backend, 15 с, отбор имён решения 2) в pipeline `metrics`; `batch` — `send_batch_max_size: 1024`, у pipeline логов — `batch/logs` (256 и 256); `otlp_http/loki` и `otlp_http/tempo` — `timeout: 5s`, `sending_queue` (`sizer: bytes`, 16 и 8 МиБ, `num_consumers: 2`, `block_on_overflow: @@ -50,97 +50,97 @@ ## 5. Prometheus: правила, тесты, конфигурация (1, 3, 4, 6, 9, 11) -- [ ] 5.1 `infra/otel/prometheus/rules.yml`: группы `messenger-sli` (15 с: доли окон оповещений, `telemetry:lost_items:total`), +- [x] 5.1 `infra/otel/prometheus/rules.yml`: группы `messenger-sli` (15 с: доли окон оповещений, `telemetry:lost_items:total`), `messenger-slo` (5 мин: приращения событий трёх SLI), `messenger-alerts`, `telemetry-alerts` — правила записи и семь оповещений решения 4 с `for`, `severity`, `summary`, `description` и `runbook_url`; `le` — `"0.25"`, `"30.0"`. Проверка: `promtool check rules` (5.4). -- [ ] 5.2 `infra/otel/prometheus/rules.test.yml`: на каждое оповещение — срабатывание после `for`, нет срабатывания ниже +- [x] 5.2 `infra/otel/prometheus/rules.test.yml`: на каждое оповещение — срабатывание после `for`, нет срабатывания ниже порога и без трафика, снятие после восстановления; `MessengerQueueMetricsMissing` молчит при недоступном экспортёре Collector; `TelemetryDataLoss` — новый ряд, рост, сброс; значения правил записи. Проверка: `promtool test rules` зелёный; временное изменение порога в `rules.yml` даёт красный прогон (вывод в отчёте apply, правка не коммитится). -- [ ] 5.3 `infra/otel/prometheus/prometheus.yml`: `rule_files`, глобальный `scrape_protocols` — явно прежний текстовый список +- [x] 5.3 `infra/otel/prometheus/prometheus.yml`: `rule_files`, глобальный `scrape_protocols` — явно прежний текстовый список Prometheus 3, у `otel-collector-exporter` — `[PrometheusProto, OpenMetricsText1.0.0, PrometheusText0.0.4]`; `docker-compose.yml`: флаг `--enable-feature=created-timestamp-zero-ingestion`, bind mount `rules.yml` длинной записью; `.github/ci/compose.yml` — `configs` `prometheus_rules`, `.github/ci/stand-env.sh` — `CI_PROMETHEUS_RULES`. Проверка: `docker compose config --quiet` рабочего стенда, CI (с переменными `stand-env.sh`), `bench/` и стенда отказов — коды 0. -- [ ] 5.4 Цель `make alerts_test` (своя секция `Makefile`): `tar` файлов `infra/otel/prometheus/` в одноразовый контейнер +- [x] 5.4 Цель `make alerts_test` (своя секция `Makefile`): `tar` файлов `infra/otel/prometheus/` в одноразовый контейнер закреплённого образа Prometheus (`--network none`, `/etc/prometheus`) — `promtool check config`, `check rules`, `test rules`; затем каждый `runbook_url` — существующий файл. Шаг `make alerts_test` в `.github/workflows/application.yml`. Проверка: `make alerts_test` — код 0; временно переименованный runbook — ненулевой код (правка не коммитится). ## 6. Runbooks (5, 12) -- [ ] 6.1 Семь файлов `infra/otel/runbooks/<оповещение>.md` по разделам решения 5: значение и влияние, первые панели, +- [x] 6.1 Семь файлов `infra/otel/runbooks/<оповещение>.md` по разделам решения 5: значение и влияние, первые панели, диагностика по сохранённым наблюдениям с запросами Prometheus, LogQL и TraceQL и ожидаемым видом результата для каждой причины, действия, проверка восстановления, связанные оповещения. Проверка: `make alerts_test` (ссылки); запросы runbooks выполняются через Grafana без ошибки на пробном прогоне 9.6. ## 7. Grafana (3, 10) -- [ ] 7.1 `infra/otel/grafana/datasources.yaml`: у Prometheus `manageAlerts: true`. Проверка: после 9.3 API Grafana +- [x] 7.1 `infra/otel/grafana/datasources.yaml`: у Prometheus `manageAlerts: true`. Проверка: после 9.3 API Grafana отдаёт правила источника `prometheus` (эндпоинт — в отчёте apply), правка их через Grafana невозможна. -- [ ] 7.2 `infra/otel/grafana/dashboards/messenger-overview.json`: строки «SLO and alerts» (сверху), «Load balancer», «Telemetry +- [x] 7.2 `infra/otel/grafana/dashboards/messenger-overview.json`: строки «SLO and alerts» (сверху), «Load balancer», «Telemetry pipeline» по решению 10, id с 25, у рядов, которых может не быть, — `or on() vector(0)`, единицы; прежние панели сдвинуты вниз без изменений запросов. Проверка: `python3 -m json.tool`; после 9.3 и пересоздания Grafana — dashboard provisioned, обход панелей `telemetry-check` и `trace-chain` без ошибок и с данными (9.6). ## 8. Драйвер скилла `run-mtusi-messenger` (11) -- [ ] 8.1 Фоновая нагрузка драйвера: потоки через LB (отправка сообщения с ключом, чтение истории), счёт ответов по классам +- [x] 8.1 Фоновая нагрузка драйвера: потоки через LB (отправка сообщения с ключом, чтение истории), счёт ответов по классам и времени, остановка по событию, без печати токенов. Проверка: `python3 -m py_compile` системным `python3`; используется в 8.2 и 8.3. -- [ ] 8.2 Команда `driver.py --port alerts-check` (решение 11, шаги 1–6; спеки «Проверка оповещений отказами», «SLI и +- [x] 8.2 Команда `driver.py --port alerts-check` (решение 11, шаги 1–6; спеки «Проверка оповещений отказами», «SLI и SLO», «Счётчики после перезапуска процесса», «Правила оповещений»): предусловие тихого стенда (код 2), моменты pending / firing / снятия по API правил и `ALERTS`, наблюдения для разбора инцидентов, таблица «шаг → ожидаемо → получено», коды 0 / 1 / 2, восстановление в `finally` (нагрузка, сессия блокировки, PostgreSQL, worker, relay, LB). Только stdlib и синтаксис 3.9. Проверка: `py_compile`; `--help` называет команду; пробный прогон 9.6 — код 0. -- [ ] 8.3 Команда `driver.py --port backend-outage` (решение 11; спеки «Буферизация Collector и отказ хранилищ +- [x] 8.3 Команда `driver.py --port backend-outage` (решение 11; спеки «Буферизация Collector и отказ хранилищ телеметрии», «Учёт потерь телеметрии»): Loki и Tempo коротко и долго, Prometheus, Collector под нагрузкой; память по cgroup и метрикам Collector, потери, оповещения, сверка записей stdout и Loki; восстановление в `finally`. Проверка: `py_compile`; пробный прогон 9.6 — код 0. -- [ ] 8.4 `SKILL.md` — `alerts-check`, `backend-outage`, `make alerts_test`. Проверка: `grep -n` команд по `SKILL.md`. +- [x] 8.4 `SKILL.md` — `alerts-check`, `backend-outage`, `make alerts_test`. Проверка: `grep -n` команд по `SKILL.md`. ## 9. Стенд и регрессия (до коммита) -- [ ] 9.1 `make lint`, `make service_test`, `make service_test_db`. Проверка: зелёные; причины падений — в отчёте apply до +- [x] 9.1 `make lint`, `make service_test`, `make service_test_db`. Проверка: зелёные; причины падений — в отчёте apply до правок. -- [ ] 9.2 Конфигурации: `docker compose config --quiet` (четыре варианта 5.3), `haproxy -c`, `validate` Collector, `make +- [x] 9.2 Конфигурации: `docker compose config --quiet` (четыре варианта 5.3), `haproxy -c`, `validate` Collector, `make alerts_test`. Проверка: коды 0. -- [ ] 9.3 Развёртывание (Migration Plan): HAProxy, Collector, Prometheus, Grafana, затем `make rolling_update` и `docker +- [x] 9.3 Развёртывание (Migration Plan): HAProxy, Collector, Prometheus, Grafana, затем `make rolling_update` и `docker compose up -d --no-deps worker relay`. Проверка: `make lb_stats` — `UP`; в Prometheus все группы правил загружены без ошибок, цели `up` = 1, `up{job="haproxy"}` = 1; источники Grafana проходят проверку. -- [ ] 9.4 Имена в Prometheus: ряды отбора HAProxy с `proxy` и `code`; внутренние метрики SDK у `messenger-api`, +- [x] 9.4 Имена в Prometheus: ряды отбора HAProxy с `proxy` и `code`; внутренние метрики SDK у `messenger-api`, `messenger-worker`, `messenger-relay` (ёмкость очередей 2048); ёмкость очередей экспорта Collector в байтах (16 и 8 МиБ); ряды `messenger-sli` через ~15 с, `messenger-slo` — через ≤ 5 мин; число рядов экспортёра до и после перехода на protobuf без двойников. Расхождение — правка запросов и правил, запись в «Уточнения apply». Проверка: запросы через Grafana. -- [ ] 9.5 Время начала (6): worker остановлен дольше 2 мин, загрузка, запуск — в точках +- [x] 9.5 Время начала (6): worker остановлен дольше 2 мин, загрузка, запуск — в точках `messenger_job_time_to_ready_seconds_count` ноль в момент старта процесса и приращение ровно на число загрузок. Проверка: вывод запроса в scratchpad (evidence — `alerts-check` в 11.2). -- [ ] 9.6 Пробные прогоны (scratchpad): `alerts-check`, `backend-outage`, `telemetry-check`, `trace-chain`, +- [x] 9.6 Пробные прогоны (scratchpad): `alerts-check`, `backend-outage`, `telemetry-check`, `trace-chain`, `telemetry-outage`. Проверка: коды 0; расхождение — сначала причина, потом правка. -- [ ] 9.7 Регрессия: `make test`; `make student_test` через LB (красный только `test_exclusion_evidence_exists`); `make +- [x] 9.7 Регрессия: `make test`; `make student_test` через LB (красный только `test_exclusion_evidence_exists`); `make test_isolated`; `make failure_checks`; `make test-persistence ACTION_SCRIPT=scripts/restart.sh`; `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` со `STOP_MODE` `stop` и `kill`; после каждого — нет firing, кроме ожидаемых короткими отказами (`/api/v1/alerts`). Проверка: выводы команд; причины падений — до правок. -- [ ] 9.8 Бюджет (13): пики Collector (долгий отказ хранилища под нагрузкой), Prometheus (`alerts-check`) и реплик API +- [x] 9.8 Бюджет (13): пики Collector (долгий отказ хранилища под нагрузкой), Prometheus (`alerts-check`) и реплик API (отказ Collector) по `memory.peak` / `memory.stat` и правилу «лимит ≥ 1,5 × пика»; не выполняется — лимит поднимается; суммы по `docker compose config` и `docker inspect`; сколько CPU и памяти нужно ВМ. Проверка: числа в scratchpad для 11.4; суммы совпадают с `docker.md` и `REPORT.md`. ## 10. Документы -- [ ] 10.1 Правила (14): `telemetry.md`, `docker.md`, `balancer.md`. Проверка: в каждом — ссылка на design change +- [x] 10.1 Правила (14): `telemetry.md`, `docker.md`, `balancer.md`. Проверка: в каждом — ссылка на design change `slo-alerts` и нет пересказа спека; `docker.md` называет восемь `configs` CI и строку ВМ. -- [ ] 10.2 `AGENTS.md`: состояние лабы (третий change), таблица важных файлов, команды `make alerts_test`, `alerts-check`, +- [x] 10.2 `AGENTS.md`: состояние лабы (третий change), таблица важных файлов, команды `make alerts_test`, `alerts-check`, `backend-outage`, карта кода (`rules.yml`, `rules.test.yml`, `runbooks/`, `evidence/alerts/`). Проверка: `grep` новых путей и команд. -- [ ] 10.3 `REPORT.md` по требованию «SLO, оповещения и инциденты в отчёте»: SLI/SLO, таблица оповещений, буферизация и +- [x] 10.3 `REPORT.md` по требованию «SLO, оповещения и инциденты в отчёте»: SLI/SLO, таблица оповещений, буферизация и потери, отказы хранилищ, счётчики после перезапуска, три инцидента по решению 12, бюджет и строка ВМ, строки «Доказательства критериев»; ограничения — без «ответов балансировщика вне метрик» и с 1 мин вместо 5. Числа из evidence — в 11.5. Проверка: сценарий «Отчёт по SLO и инцидентам» после 11.5. -- [ ] 10.4 `QUESTIONS.md`, раздел `## slo-alerts` (создан на propose) — решения и вопросы apply; design — «Уточнения apply» +- [x] 10.4 `QUESTIONS.md`, раздел `## slo-alerts` (создан на propose) — решения и вопросы apply; design — «Уточнения apply» с отклонениями от решений. Проверка: каждое отклонение названо там. -- [ ] 10.5 `KNOWN_ISSUES.md` — дефекты, найденные попутно вне change (путь и предложение правки), если есть. Проверка: +- [x] 10.5 `KNOWN_ISSUES.md` — дефекты, найденные попутно вне change (путь и предложение правки), если есть. Проверка: записи в формате файла. ## 11. Evidence (после коммита кода основной сессией) diff --git a/service-tests/unit/test_telemetry.py b/service-tests/unit/test_telemetry.py index cd99daf..2e8e464 100644 --- a/service-tests/unit/test_telemetry.py +++ b/service-tests/unit/test_telemetry.py @@ -7,6 +7,7 @@ import asyncio import io import json import logging +import threading import time from collections.abc import Iterator from dataclasses import dataclass, field @@ -23,6 +24,8 @@ from opentelemetry._logs import SeverityNumber from opentelemetry.sdk._logs import LoggerProvider from opentelemetry.sdk._logs.export import ( InMemoryLogRecordExporter, + LogRecordExporter, + LogRecordExportResult, SimpleLogRecordProcessor, ) from opentelemetry.sdk.metrics import MeterProvider @@ -630,21 +633,26 @@ def test_exporters_ignore_proxy_environment( return response monkeypatch.setattr(requests.Session, "send", send) - exporters = sdk.otlp_exporters( - TelemetrySettings(otlp_endpoint=COLLECTOR), - ) + config = TelemetrySettings(otlp_endpoint=COLLECTOR) + reader = sdk.otlp_metric_reader(config) tracer_provider = TracerProvider() - tracer_provider.add_span_processor(SimpleSpanProcessor(exporters.spans)) + tracer_provider.add_span_processor( + SimpleSpanProcessor( + sdk.otlp_span_exporter(config, meter_provider=None), + ), + ) logger_provider = LoggerProvider() logger_provider.add_log_record_processor( - SimpleLogRecordProcessor(exporters.logs), + SimpleLogRecordProcessor( + sdk.otlp_log_exporter(config, meter_provider=None), + ), ) - meter_provider = MeterProvider(metric_readers=[exporters.metrics]) + meter_provider = MeterProvider(metric_readers=[reader]) try: tracer_provider.get_tracer("t").start_span("probe").end() logger_provider.get_logger("t").emit(body="probe") meter_provider.get_meter("t").create_counter("probe").add(1) - exporters.metrics.force_flush() + reader.force_flush() finally: tracer_provider.shutdown() logger_provider.shutdown() @@ -1460,3 +1468,253 @@ def test_sdk_modules_not_loaded_without_telemetry() -> None: ) assert not {name for name in loaded if name.startswith(forbidden)} assert loaded <= _loaded_modules("redis.asyncio") + + +# --- внутренние метрики SDK (design change slo-alerts, решения 8–9) ------- + +INTERNAL_METRICS_ENV = "OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED" +SPAN_PROCESSED = "otel.sdk.processor.span.processed" +LOG_PROCESSED = "otel.sdk.processor.log.processed" +SPAN_EXPORTED = "otel.sdk.exporter.span.exported" +LOG_EXPORTED = "otel.sdk.exporter.log.exported" +SDK_HISTOGRAMS = ( + "otel.sdk.exporter.operation.duration", + "otel.sdk.metric_reader.collection.duration", +) + + +class _GateSpanExporter(SpanExporter): + """Отправка ждёт, пока тест не откроет ворота: очередь процессора + заполняется, как при медленном Collector.""" + + def __init__(self) -> None: + self.gate = threading.Event() + + def export(self, spans: Any) -> SpanExportResult: + self.gate.wait(5) + return SpanExportResult.SUCCESS + + def shutdown(self) -> None: + self.gate.set() + + +class _GateLogExporter(LogRecordExporter): + def __init__(self) -> None: + self.gate = threading.Event() + + def export(self, batch: Any) -> LogRecordExportResult: + self.gate.wait(5) + return LogRecordExportResult.SUCCESS + + def shutdown(self) -> None: + self.gate.set() + + def force_flush(self, timeout_millis: int = 30000) -> bool: # noqa: ARG002 + return True + + +def _metric_names(reader: InMemoryMetricReader) -> set[str]: + data = reader.get_metrics_data() + if data is None: + return set() + return { + metric.name + for resource in data.resource_metrics + for scope in resource.scope_metrics + for metric in scope.metrics + } + + +def _sum_where(signals: Signals, name: str, **attributes: Any) -> int: + return sum( + point.value + for point in signals.points(name) + if all( + point.attributes.get(key) == value + for key, value in attributes.items() + ) + ) + + +@pytest.fixture +def small_queue(monkeypatch: pytest.MonkeyPatch) -> None: + """Очередь процессоров 2, пакет 1, пауза 10 мс: третий span ждёт места.""" + monkeypatch.setattr(settings.telemetry, "max_queue_size", 2) + monkeypatch.setattr(settings.telemetry, "max_export_batch_size", 1) + monkeypatch.setattr(settings.telemetry, "schedule_delay_seconds", 0.01) + + +@pytest.mark.usefixtures("small_queue") +def test_sdk_counts_queue_full() -> None: + """Полная очередь процессора — счёт `error.type` = `queue_full` у span и + записей журнала, ёмкость очереди — как `[telemetry] max_queue_size`.""" + spans, logs = _GateSpanExporter(), _GateLogExporter() + collected = Signals( + spans=InMemorySpanExporter(), + metrics=InMemoryMetricReader(), + logs=InMemoryLogRecordExporter(), + ) + assert telemetry.start_process_telemetry( + SERVICE, + exporters=telemetry.Exporters( + spans=spans, + metrics=collected.metrics, + logs=logs, + ), + ) + try: + for number in range(10): + with core.tracer().start_as_current_span(f"span-{number}"): + pass + otel_logger = core.otel_logger() + for number in range(10): + otel_logger.emit(body=f"record-{number}") + dropped_spans = _sum_where( + collected, + SPAN_PROCESSED, + **{"error.type": "queue_full"}, + ) + dropped_logs = _sum_where( + collected, + LOG_PROCESSED, + **{"error.type": "queue_full"}, + ) + capacity = { + point.value + for name in ( + "otel.sdk.processor.span.queue.capacity", + "otel.sdk.processor.log.queue.capacity", + ) + for point in collected.points(name) + } + finally: + spans.gate.set() + logs.gate.set() + collected.finish() + telemetry.remove_log_hooks() + # в полёте — не больше одного пакета, в очереди — два: остальные отброшены + assert dropped_spans >= 10 - 2 - 1 + assert dropped_logs >= 10 - 2 - 1 + assert capacity == {2} + + +def test_sdk_counts_failed_export( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Экспортёр OTLP span и журнала, отправка которого падает + `ConnectionError` (подставная `requests.Session.send`, сети нет), — + `otel.sdk.exporter.*.exported` с `error.type`; гистограмм SDK нет.""" + + def send( + self: requests.Session, # noqa: ARG001 + request: requests.PreparedRequest, # noqa: ARG001 + **kwargs: Any, # noqa: ARG001 + ) -> requests.Response: + raise requests.exceptions.ConnectionError("collector is down") + + monkeypatch.setattr(requests.Session, "send", send) + monkeypatch.setattr(settings.telemetry, "otlp_endpoint", COLLECTOR) + monkeypatch.setattr(settings.telemetry, "export_timeout_seconds", 0.2) + monkeypatch.setattr(settings.telemetry, "schedule_delay_seconds", 0.01) + collected = Signals( + spans=InMemorySpanExporter(), + metrics=InMemoryMetricReader(), + logs=InMemoryLogRecordExporter(), + ) + assert telemetry.start_process_telemetry( + SERVICE, + exporters=telemetry.Exporters( + spans=None, + metrics=collected.metrics, + logs=None, + ), + ) + try: + with core.tracer().start_as_current_span("probe"): + pass + core.otel_logger().emit(body="probe") + deadline = time.monotonic() + 5 + failed: dict[str, int] = {} + while time.monotonic() < deadline: + failed = { + name: _sum_where( + collected, + name, + **{"error.type": "ConnectionError"}, + ) + for name in (SPAN_EXPORTED, LOG_EXPORTED) + } + if all(failed.values()): + break + time.sleep(0.05) + names = _metric_names(collected.metrics) + exported = collected.points(SPAN_EXPORTED) + finally: + collected.finish() + telemetry.remove_log_hooks() + assert failed == {SPAN_EXPORTED: 1, LOG_EXPORTED: 1} + assert not names & set(SDK_HISTOGRAMS) + # метки — компонент и адрес Collector, без id + (point,) = exported + assert set(point.attributes) == { + "otel.component.type", + "otel.component.name", + "server.address", + "server.port", + "error.type", + } + assert point.attributes["server.address"] == "otel-collector" + + +def test_sdk_internal_metrics_environment( + monkeypatch: pytest.MonkeyPatch, + stdout: io.StringIO, +) -> None: + """Внешняя переменная внутренних метрик удаляется с `warning` и ни на что + не влияет: метрики SDK есть, после `start()` переменной в окружении нет.""" + import os + + monkeypatch.setenv(INTERNAL_METRICS_ENV, "false") + collected = Signals( + spans=InMemorySpanExporter(), + metrics=InMemoryMetricReader(), + logs=InMemoryLogRecordExporter(), + ) + try: + assert telemetry.start_process_telemetry( + SERVICE, + exporters=telemetry.Exporters( + spans=collected.spans, + metrics=collected.metrics, + logs=collected.logs, + ), + ) + assert INTERNAL_METRICS_ENV not in os.environ + with core.tracer().start_as_current_span("probe"): + pass + names = _metric_names(collected.metrics) + finally: + collected.finish() + telemetry.remove_log_hooks() + assert "otel.sdk.processor.span.queue.capacity" in names + assert "otel.sdk.processor.log.queue.capacity" in names + assert not names & set(SDK_HISTOGRAMS) + (warning,) = [ + record + for record in _records(stdout) + if record["event"] == "Ignored OpenTelemetry environment variables" + ] + assert warning["names"] == [INTERNAL_METRICS_ENV] + + +def test_sdk_internal_metrics_off_without_telemetry( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Выключенная телеметрия — ничего: ни провайдеров, ни переменной.""" + import os + + monkeypatch.setattr(settings.telemetry, "enabled", False) + monkeypatch.delenv(INTERNAL_METRICS_ENV, raising=False) + assert telemetry.start_process_telemetry(SERVICE) is False + assert not telemetry.is_enabled() + assert INTERNAL_METRICS_ENV not in os.environ diff --git a/src/infra/telemetry/core.py b/src/infra/telemetry/core.py index d0a73de..96a69a6 100644 --- a/src/infra/telemetry/core.py +++ b/src/infra/telemetry/core.py @@ -59,11 +59,12 @@ PROPAGATOR = TraceContextTextMapPropagator() @dataclass(frozen=True, slots=True) class Exporters: """Получатели сигналов вместо OTLP — только для быстрых тестов - (in-memory экспортёры SDK).""" + (in-memory экспортёры SDK). `spans` или `logs` `None` — экспортёр OTLP из + `[telemetry]` (тест его внутренних метрик на подставной отправке).""" - spans: "SpanExporter" + spans: "SpanExporter | None" metrics: "MetricReader" - logs: "LogRecordExporter" + logs: "LogRecordExporter | None" @dataclass(slots=True) diff --git a/src/infra/telemetry/sdk.py b/src/infra/telemetry/sdk.py index 857e5e7..e3de555 100644 --- a/src/infra/telemetry/sdk.py +++ b/src/infra/telemetry/sdk.py @@ -10,9 +10,17 @@ replay модулей SDK, protobuf и HTTP-клиента экспортёра конструктором без детекторов, у параметров явные значения, `atexit` SDK выключен. Sampler — `ParentBased(ALWAYS_ON)` (решение 5): корни выбираются всегда, удалённый родитель из задания передаёт свой флаг выборки. + +Внутренние метрики SDK (design change `slo-alerts`, решения 8–9): процессоры +span и журнала и экспортёры OTLP span и журнала считают отброшенное и +неудачные отправки в `MeterProvider` процесса. SDK 1.45 включает их только +переменной окружения в конструкторе, поэтому код ставит её на время их сборки +(`_internal_metrics`) — внешние `OTEL_*` к этому моменту уже удалены. """ -from collections.abc import Mapping +import os +from collections.abc import Iterator, Mapping +from contextlib import contextmanager from dataclasses import dataclass from typing import Any @@ -46,6 +54,7 @@ from opentelemetry.sdk.metrics.export import ( PeriodicExportingMetricReader, ) from opentelemetry.sdk.metrics.view import ( + DropAggregation, ExplicitBucketHistogramAggregation, View, ) @@ -65,6 +74,8 @@ from src.utils.constants import ( TELEMETRY_LOGS_PATH, TELEMETRY_MAX_ATTRIBUTES, TELEMETRY_METRICS_PATH, + TELEMETRY_SDK_DROPPED_HISTOGRAMS, + TELEMETRY_SDK_INTERNAL_METRICS_ENV, TELEMETRY_SPAN_ATTRIBUTE_LENGTH, TELEMETRY_TRACES_PATH, TIME_TO_READY_BUCKETS, @@ -97,6 +108,23 @@ class Providers: logger_provider: LoggerProvider +@contextmanager +def _internal_metrics() -> Iterator[None]: + """Включить внутренние метрики SDK на время сборки процессоров и + экспортёров: переменную читают их конструкторы, другого выключателя в SDK + 1.45 нет. После — прежнее состояние окружения (внешнее значение уже удалил + `core.remove_otel_environment`, так что переменной не остаётся).""" + previous = os.environ.get(TELEMETRY_SDK_INTERNAL_METRICS_ENV) + os.environ[TELEMETRY_SDK_INTERNAL_METRICS_ENV] = "true" + try: + yield + finally: + if previous is None: + os.environ.pop(TELEMETRY_SDK_INTERNAL_METRICS_ENV, None) + else: + os.environ[TELEMETRY_SDK_INTERNAL_METRICS_ENV] = previous + + def build( *, resource: Mapping[str, Any], @@ -104,13 +132,75 @@ def build( exporters: Any | None, ) -> Providers: """Провайдеры трасс, метрик и логов. `exporters` — получатели вместо OTLP - (`core.Exporters`, быстрые тесты) или `None`.""" - if exporters is None: - exporters = otlp_exporters(config) + (`core.Exporters`, быстрые тесты; `spans` или `logs` `None` — экспортёр + OTLP из `[telemetry]`) или `None` — всё OTLP. + + Порядок (design change `slo-alerts`, решение 8): сначала `MeterProvider`, + затем процессоры span и журнала и экспортёры OTLP span и журнала с его + `meter_provider` — внутренние метрики SDK идут тем же путём, что метрики + приложения. Читатель метрик строится до провайдера и своих метрик не + получает: неудачная отправка метрик счёт не теряет (cumulative).""" attributes = Resource(dict(resource)) timeout_ms = config.export_timeout_seconds * 1000 delay_ms = config.schedule_delay_seconds * 1000 + reader = ( + exporters.metrics + if exporters is not None + else otlp_metric_reader(config) + ) + meter_provider = MeterProvider( + metric_readers=[reader], + resource=attributes, + exemplar_filter=AlwaysOffExemplarFilter(), + shutdown_on_exit=False, + views=[ + *( + View( + instrument_name=name, + aggregation=ExplicitBucketHistogramAggregation( + boundaries=boundaries, + ), + ) + for name, boundaries in _BUCKETS.items() + ), + # гистограммы самого SDK для учёта потерь не нужны (решение 8) + *( + View(instrument_name=name, aggregation=DropAggregation()) + for name in TELEMETRY_SDK_DROPPED_HISTOGRAMS + ), + ], + ) + with _internal_metrics(): + span_exporter = getattr(exporters, "spans", None) + if span_exporter is None: + span_exporter = otlp_span_exporter( + config, + meter_provider=meter_provider, + ) + log_exporter = getattr(exporters, "logs", None) + if log_exporter is None: + log_exporter = otlp_log_exporter( + config, + meter_provider=meter_provider, + ) + span_processor = BatchSpanProcessor( + span_exporter, + max_queue_size=config.max_queue_size, + schedule_delay_millis=delay_ms, + max_export_batch_size=config.max_export_batch_size, + export_timeout_millis=timeout_ms, + meter_provider=meter_provider, + ) + log_processor = BatchLogRecordProcessor( + log_exporter, + schedule_delay_millis=delay_ms, + max_export_batch_size=config.max_export_batch_size, + export_timeout_millis=timeout_ms, + max_queue_size=config.max_queue_size, + meter_provider=meter_provider, + ) + tracer_provider = TracerProvider( sampler=ParentBased(ALWAYS_ON), resource=attributes, @@ -126,30 +216,7 @@ def build( max_span_attribute_length=TELEMETRY_SPAN_ATTRIBUTE_LENGTH, ), ) - tracer_provider.add_span_processor( - BatchSpanProcessor( - exporters.spans, - max_queue_size=config.max_queue_size, - schedule_delay_millis=delay_ms, - max_export_batch_size=config.max_export_batch_size, - export_timeout_millis=timeout_ms, - ), - ) - meter_provider = MeterProvider( - metric_readers=[exporters.metrics], - resource=attributes, - exemplar_filter=AlwaysOffExemplarFilter(), - shutdown_on_exit=False, - views=[ - View( - instrument_name=name, - aggregation=ExplicitBucketHistogramAggregation( - boundaries=boundaries, - ), - ) - for name, boundaries in _BUCKETS.items() - ], - ) + tracer_provider.add_span_processor(span_processor) logger_provider = LoggerProvider( resource=attributes, shutdown_on_exit=False, @@ -158,15 +225,7 @@ def build( max_attribute_length=TELEMETRY_LOG_ATTRIBUTE_LENGTH, ), ) - logger_provider.add_log_record_processor( - BatchLogRecordProcessor( - exporters.logs, - schedule_delay_millis=delay_ms, - max_export_batch_size=config.max_export_batch_size, - export_timeout_millis=timeout_ms, - max_queue_size=config.max_queue_size, - ), - ) + logger_provider.add_log_record_processor(log_processor) return Providers( tracer_provider=tracer_provider, meter_provider=meter_provider, @@ -183,40 +242,58 @@ def export_session() -> requests.Session: return session -def otlp_exporters(config: TelemetrySettings) -> Any: - """OTLP/HTTP protobuf только из `[telemetry]`: адрес, срок, без - заголовков и сжатия, своя сессия без прокси окружения.""" - # тип получателей живёт в core: он нужен быстрым тестам без этого модуля - from src.infra.telemetry.core import Exporters +# OTLP/HTTP protobuf только из `[telemetry]`: адрес, срок, без заголовков и +# сжатия, своя сессия без прокси окружения + +def otlp_metric_reader( + config: TelemetrySettings, +) -> PeriodicExportingMetricReader: + """Читатель метрик с экспортёром OTLP; строится до `MeterProvider` и + внутренних метрик SDK не получает.""" timeout = config.export_timeout_seconds - endpoint = config.otlp_endpoint - return Exporters( - spans=OTLPSpanExporter( - endpoint=endpoint + TELEMETRY_TRACES_PATH, - headers={}, - timeout=timeout, - compression=Compression.NoCompression, - session=export_session(), - ), - metrics=PeriodicExportingMetricReader( - OTLPMetricExporter( - endpoint=endpoint + TELEMETRY_METRICS_PATH, - headers={}, - timeout=timeout, - compression=Compression.NoCompression, - preferred_temporality=_CUMULATIVE, - session=export_session(), - ), - export_interval_millis=config.metric_export_interval_seconds - * 1000, - export_timeout_millis=timeout * 1000, - ), - logs=OTLPLogExporter( - endpoint=endpoint + TELEMETRY_LOGS_PATH, + return PeriodicExportingMetricReader( + OTLPMetricExporter( + endpoint=config.otlp_endpoint + TELEMETRY_METRICS_PATH, headers={}, timeout=timeout, compression=Compression.NoCompression, + preferred_temporality=_CUMULATIVE, session=export_session(), ), + export_interval_millis=config.metric_export_interval_seconds * 1000, + export_timeout_millis=timeout * 1000, + ) + + +def otlp_span_exporter( + config: TelemetrySettings, + *, + meter_provider: MeterProvider | None, +) -> OTLPSpanExporter: + """Экспортёр span; с `meter_provider` внутри `_internal_metrics` — + счёт отправленного и неудачных отправок (`otel.sdk.exporter.span.*`).""" + return OTLPSpanExporter( + endpoint=config.otlp_endpoint + TELEMETRY_TRACES_PATH, + headers={}, + timeout=config.export_timeout_seconds, + compression=Compression.NoCompression, + session=export_session(), + meter_provider=meter_provider, + ) + + +def otlp_log_exporter( + config: TelemetrySettings, + *, + meter_provider: MeterProvider | None, +) -> OTLPLogExporter: + """Экспортёр записей журнала; счёт — `otel.sdk.exporter.log.*`.""" + return OTLPLogExporter( + endpoint=config.otlp_endpoint + TELEMETRY_LOGS_PATH, + headers={}, + timeout=config.export_timeout_seconds, + compression=Compression.NoCompression, + session=export_session(), + meter_provider=meter_provider, ) diff --git a/src/utils/constants.py b/src/utils/constants.py index 8fc688f..e1362b5 100644 --- a/src/utils/constants.py +++ b/src/utils/constants.py @@ -286,6 +286,16 @@ QUEUE_SNAPSHOT_STALE_SECONDS = 30 # cgroup v2 контейнера изнутри (решение 12) CGROUP_ROOT = "/sys/fs/cgroup" +# внутренние метрики SDK для учёта потерь (design change `slo-alerts`, +# решения 8–9): SDK 1.45 читает эту переменную в конструкторах процессоров и +# экспортёров OTLP; код ставит её только на время их сборки +TELEMETRY_SDK_INTERNAL_METRICS_ENV = "OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED" +# гистограммы длительности самого SDK: для учёта не нужны и множат ряды +TELEMETRY_SDK_DROPPED_HISTOGRAMS = ( + "otel.sdk.exporter.operation.duration", + "otel.sdk.metric_reader.collection.duration", +) + # хранилище объектов (S3) # имя bucket по правилам S3: 3–63 символа, строчные латинские буквы, # цифры, точка и дефис, по краям — буква или цифра