From c885462c044f560ed4ea12e3c0048be40766da13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9?= Date: Fri, 6 Nov 2026 09:39:53 +0300 Subject: [PATCH] add level 5 --- REPORT.md | 12 +- docs/observability.md | 2 +- docs/slo-runbook.md | 41 + evidence/slo-analysis.json | 53 + evidence/slo-incidents.json | 1170 +++++++++++++++++++++++ evidence/slo-ready-incident.json | 211 ++++ evidence/slo-track.md | 34 + infra/grafana/dashboards/messenger.json | 110 ++- infra/prometheus/alerts.yaml | 16 + src/outbox.py | 14 +- src/telemetry.py | 5 +- student-tests/burn_rules.test.yaml | 83 ++ student-tests/slo_analyze.py | 32 + student-tests/slo_incidents.py | 121 +++ student-tests/slo_ready_incident.py | 70 ++ 15 files changed, 1966 insertions(+), 8 deletions(-) create mode 100644 docs/slo-runbook.md create mode 100644 evidence/slo-analysis.json create mode 100644 evidence/slo-incidents.json create mode 100644 evidence/slo-ready-incident.json create mode 100644 evidence/slo-track.md create mode 100644 student-tests/burn_rules.test.yaml create mode 100644 student-tests/slo_analyze.py create mode 100644 student-tests/slo_incidents.py create mode 100644 student-tests/slo_ready_incident.py diff --git a/REPORT.md b/REPORT.md index e23516b..6a79e7e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,7 +1,7 @@ # Отчёт — лабораторная 6 - Автор, группа: Kozyrev, BVT2301 -- Целевая оценка: 4 +- Целевая оценка: 5, трек 2 — SLO и обнаружение инцидентов - Commit/PR: TODO после публикации - Источники: [контракт телеметрии](contracts/observability.md), [OTel Collector](https://opentelemetry.io/docs/collector/configuration/), [OTel Python exporters](https://opentelemetry.io/docs/languages/python/exporters/), [Loki OTLP](https://grafana.com/docs/loki/latest/send-data/otel/), [Grafana provisioning](https://grafana.com/docs/grafana/latest/administration/provisioning/), исходники lab5 commit `6bc0712`. При реализации использован Codex. @@ -42,8 +42,16 @@ API, outbox и worker отправляют OTLP через Collector в Promethe Идентификаторы трасс, результаты, формулы и границы проверки приведены в [evidence/observability.md](evidence/observability.md). Raw summaries нагрузки: [инцидент БД](evidence/db-incident-load-repeat.json), [отказ Tempo](evidence/tempo-outage-load.json). Полный набор наблюдений живёт в локальных volumes, а не в Git. +## Трек 5: SLO и обнаружение инцидентов + +Заданы учебные SLO 99% за 24 часа для API и времени готовности принятых вложений. Для каждого настроены быстрые и медленные multiwindow burn-rate alerts; формулы, допущения и пошаговая диагностика — в [runbook](docs/slo-runbook.md). Последние 30 секунд заданий исключены из зрелой когорты; просроченные, failed и неготовые задания входят в ошибки SLO. Моменты начала и окончания приблизительны из-за транзакционных границ. При недоступном outbox счётчики устаревают. + +Повторяемые сценарии и наблюдения — в [отчёте трека](evidence/slo-track.md), исходные отсчёты — [API](evidence/slo-incidents.json), [расчёт](evidence/slo-analysis.json) и [вложения](evidence/slo-ready-incident.json). При короткой и длительной блокировке API fast alert обнаружен через 55,088 и 50,278 секунды; slow в первом случае впервые появился после конца инцидента (одна новая тревога в фазе восстановления), во втором — через 90,428 секунды. На коротком baseline из 13 проб не наблюдалось burn alerts; долгосрочная частота ложных срабатываний не измерена. При тесте восьми вложений обнаружение — 40,279 секунды после последнего принятия, после запуска worker все восемь стали ready. Опросный метод, ограничения и заметный скачок UTC-часов описаны в отчёте трека. Проведена собственная проверка runbook по Loki/Tempo; прохождение другим студентом не подтверждено. + +Проверка правил: `docker run --rm -v "$PWD:/workspace:ro" --entrypoint promtool prom/prometheus:v3.2.1 test rules /workspace/student-tests/burn_rules.test.yaml`. Синтетические проверки нормальной нагрузки, всплеска, устойчивой деградации и малого числа событий прошли. + ## Эксперименты и ограничения Docker Engine 29.8.0, `aarch64`; Docker VM сообщил 10 CPU и 10 416 644 096 байт RAM. Лимиты контейнеров указаны в Compose: например, Collector — 256 MiB, каждая API-реплика — 0,5 CPU и 512 MB. Ограниченная нагрузка была closed-loop; прогрев и статистические повторы для сравнения производительности не проводились. Числа не являются оценкой максимальной пропускной способности. В отчёте о первом опыте блокировки БД alert не успел перейти в firing; после изменения выдержки до 10 секунд повторный опыт показал firing и восстановление. -`messenger_job_ready_duration_seconds` измеряет время от создания DB-записи о вложении до фиксации ready; оно включает время до commit принятия. Измерение SLO за полное 24-часовое окно ещё не проведено. Данные queue age обновляет outbox: при его остановке gauge устаревает. RSS/CPU worker не включают отдельный render-процесс; pool waiting зависит от внутреннего API закреплённой версии asyncpg. Один Docker-host и единственные экземпляры DB, broker и LB не обеспечивают HA при их потере. Три замера RAM при отказе Tempo не доказывают поведение для произвольной длительности; переполнение очереди приводит к потере spans. При необходимости переносимой защиты следует отдельно сохранить наблюдения и подтвердить состояние alerts и трасс после нового clone. +`messenger_job_ready_duration_seconds` измеряет время от создания DB-записи о вложении до фиксации ready; оно включает время до commit принятия. Репрезентативность 24-часового окна и долгосрочная частота ложных срабатываний не проверены. Данные queue age обновляет outbox: при его остановке gauge устаревает. RSS/CPU worker не включают отдельный render-процесс; pool waiting зависит от внутреннего API закреплённой версии asyncpg. Один Docker-host и единственные экземпляры DB, broker и LB не обеспечивают HA при их потере. Три замера RAM при отказе Tempo не доказывают поведение для произвольной длительности; переполнение очереди приводит к потере spans. При необходимости переносимой защиты следует отдельно сохранить наблюдения и подтвердить состояние alerts и трасс после нового clone. diff --git a/docs/observability.md b/docs/observability.md index 9caf9a3..60a2da1 100644 --- a/docs/observability.md +++ b/docs/observability.md @@ -10,7 +10,7 @@ API, worker и outbox отправляют OTLP/HTTP в Collector. Prometheus х Dashboard использует счётчики и гистограммы с единицами секунд: p50/p95/p99 HTTP вычисляются через `histogram_quantile` по сумме buckets, не по среднему перцентилей. `messenger_job_ready_duration_seconds` измеряет от времени создания записи о вложении в DB до фиксации ready; эта оценка включает время до commit принятия и не претендует на точную границу durable acceptance. Queue depth и age — число и возраст самого старого задания в состоянии queued из PostgreSQL, включая ожидающие retry; это не длина очереди RabbitMQ. Данные обновляет outbox. DB pool отражает пул каждой API-реплики; число ожидающих читается из внутренней очереди asyncpg 0.31.0 и зависит от этой версии. Worker busy/capacity — число занятых executor threads и их лимит; повторная доставка уже завершённой задачи учитывается как успешная обработка. CPU и RSS — процессы API/worker/outbox, без дочерних процессов render. При остановленном outbox queue gauge устаревает. -SLI: доля ответов 5xx среди всех HTTP бизнес-запросов API, исключая health. Целевой SLO: не менее 99% запросов без 5xx за скользящие 24 часа; ошибки балансировщика, которые не дошли до API, SLI не учитывает. Целевое значение выбрано для учебного стенда, а не по измеренным требованиям пользователей. Alert `MessengerHighErrorRate` срабатывает при >5% за минуту в течение 10 секунд; это оперативный порог, не burn-rate alert. `MessengerQueueLag` срабатывает при возрасте queued >30 секунд в течение 15 секунд. Состояния доступны в Prometheus через Grafana Explore или локальный API Prometheus внутри контейнера. +SLI: доля ответов 5xx среди всех HTTP бизнес-запросов API, исключая health. Целевой SLO: не менее 99% запросов без 5xx за скользящие 24 часа; ошибки балансировщика, которые не дошли до API, SLI не учитывает. Целевое значение выбрано для учебного стенда, а не по измеренным требованиям пользователей. Второй SLO и расчёт burn-rate описаны в [runbook](slo-runbook.md); его DB-счётчики учитывают и невыполненные в срок задания. Alert `MessengerHighErrorRate` срабатывает при >5% за минуту в течение 10 секунд; это оперативный порог, не burn-rate alert. `MessengerQueueLag` срабатывает при возрасте queued >30 секунд в течение 15 секунд. Состояния доступны в Prometheus через Grafana Explore или локальный API Prometheus внутри контейнера. Collector использует memory limiter 192 MiB, batch до 1024 записей, очереди экспортёров по 128 batches и retry до 60 секунд; лимит контейнера 256 MiB. SDK использует ограниченные очереди spans/logs по 2048 и timeout экспорта 2 секунды. При долгом отказе хранилища возможна потеря телеметрии; это не должно блокировать бизнес-обработку. Наблюдайте внутренние метрики `otelcol_exporter_queue_size`, `otelcol_exporter_send_failed_spans_total`, `otelcol_exporter_enqueue_failed_spans_total`, `otelcol_exporter_send_failed_log_records_total` и `otelcol_receiver_refused_*`. Очереди не сохраняются после перезапуска Collector. diff --git a/docs/slo-runbook.md b/docs/slo-runbook.md new file mode 100644 index 0000000..d449ed1 --- /dev/null +++ b/docs/slo-runbook.md @@ -0,0 +1,41 @@ +# Runbook: расход бюджета SLO + +Используйте только учебный стенд с синтетическими данными. Grafana: `http://localhost:3000`, имя `admin`, пароль в `secrets/grafana_password`. На dashboard `Messenger — observability` находятся панели API/ready SLI и burn rates. В Explore выберите Prometheus; логи и traces доступны через Loki и Tempo. Правила — [alerts.yaml](../infra/prometheus/alerts.yaml). + +## Что означает сигнал + +Два учебных SLO на скользящие 24 часа: 99% бизнес-запросов API без 5xx и 99% принятых вложений становятся ready не позднее чем через 30 секунд после создания записи о задании. API исключает health и ошибки LB до попадания в приложение; 4xx остаются в знаменателе. Для готовности учтены только задания, достигшие 30-секундного возраста: неготовые, failed и завершённые позднее срока считаются плохими. Счётчики вычисляет outbox по PostgreSQL, поэтому при его недоступности данные не обновляются; события между последним scrape старого процесса и первым scrape нового могут не попасть в расчёт `increase`. Момент создания записи немного предшествует commit принятия, а время ready фиксируется внутри транзакции до её commit: это приближение к пользовательским границам. Порог 30 секунд — половина 60-секундного бюджета smoke-теста для одного файла при свободном worker; это учебная цель, не измеренное требование пользователей. Цель 99% также выбрана для демонстрации, а не выведена из пользовательского исследования. + +Error budget каждого SLO — `1 − 0,99 = 0,01`. Burn rate — доля плохих событий за окно / 0,01. Приближение расхода бюджета `burn × окно / 24 часа` предполагает стабильную интенсивность событий; при сильно меняющейся нагрузке бюджет, выраженный в доле событий за 24 часа, расходуется иначе. Значение 1 означает, что при сохранении текущей доли плохих событий все допустимые ошибки будут израсходованы за период SLO. + +- Fast: одновременно 1 минута и 20 секунд выше `28,8 × 0,01 = 28,8%`; в коротком окне не менее 5 событий. При постоянной интенсивности это `28,8 × 1 / 1440 = 0,02`, то есть 2% суточного бюджета за минуту. +- Slow: одновременно 5 минут и 1 минута выше `14,4 × 0,01 = 14,4%`; в коротком окне не менее 5 событий. При постоянной интенсивности это `14,4 × 5 / 1440 = 0,05`, то есть 5% бюджета за пять минут. + +В окне недостаточно событий — alert молчит; отсутствие ряда не является доказательством здоровья. Короткие окна и пороги выбраны для воспроизводимого лабораторного опыта, не являются рекомендацией для production. Источник метода multiwindow/multi-burn-rate и ограничений: [Google SRE Workbook](https://sre.google/workbook/alerting-on-slos/). Гистограмма: [Prometheus histograms](https://prometheus.io/docs/practices/histograms/). + +## API burn + +1. Убедитесь в наличии запросов: `sum(rate(messenger_http_requests_total{route!~"/health/.*"}[1m]))`. Отсутствие запросов требует отдельной проверки LB/readiness, а не вывода об отсутствии ошибок. +2. Сравните на dashboard 20s/1m/5m и долю 5xx по маршрутам: `sum by(route) (rate(messenger_http_requests_total{status_class="5xx"}[1m]))`. Если burn high, перейдите в Loki: `{service_name="messenger-api"} | status="503"`. Ограничьте диапазон временем alert. +3. Откройте trace из metadata лога в Tempo. Если `postgres.user_for_token` или другая DB-операция занимает большую часть HTTP span, проверьте подключение к PostgreSQL и блокировки (`pg_locks`, `pg_stat_activity`); не печатайте параметры SQL или credentials. Если вместо этого длителен S3 span — проверьте S3 и сеть. Проверьте также pool used/waiting. +4. Устраните причину в рамках полномочий: в учебном опыте дождитесь окончания контролируемой блокировки. Проверьте уменьшение error ratio, отсутствие активного burn alert и успешный `make test`. Сообщение об устранении возможно после короткого окна; долгая часть условия может ещё некоторое время оставаться выше порога. + +## Ready burn / очередь + +1. Проверьте `sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[1m]))`, p95 ready и исходы jobs. Счётчик `messenger_slo_ready_bad_total` включает задания, нарушившие срок. Отсутствие событий не делает SLI хорошим: проверьте `messenger_queue_depth{service_name="messenger-outbox"}` и `messenger_queue_age_seconds{service_name="messenger-outbox"}`. +2. В Loki откройте `{service_name="messenger-worker"}`, найдите событие и trace ID. В Tempo проверьте цепочку upload → producer → consumer → S3/DB; посмотрите busy/capacity и состояние broker/worker через `docker compose ps`. +3. В учебном опыте запустите остановленный worker, наблюдайте уменьшение глубины/возраста и новые ready. Проверьте resolved и метаданные вложений. Не удаляйте volumes и не запускайте replay вслепую. + +## Повторение экспериментов + +`python3 student-tests/slo_incidents.py` создаёт синтетические данные, ведёт три клиента и выполняет краткую и длительную блокировку таблицы `users`. Скрипт пишет временные отметки и наблюдения в [evidence/slo-incidents.json](../evidence/slo-incidents.json), не сохраняет tokens; опрашивает alert примерно каждые 5 секунд. `python3 student-tests/slo_analyze.py` строит сводку, включая срабатывания уже после завершения воздействия. Тест намеренно ухудшает локальный API и занимает несколько минут. Первая отметка воздействия — момент, когда скрипт увидел granted `AccessExclusiveLock`; окончание — возврат команды транзакции, поэтому обе оценки имеют задержку наблюдения. Длительности считаются по монотонным часам: при выполненном опыте системное UTC скачкообразно изменилось. Аварийное прерывание клиентской команды может оставить server-side `pg_sleep` до окончания заданного ограниченного времени; проверьте состояние блокировки. + +`python3 student-tests/slo_ready_incident.py` проверяет отсутствие незавершённых заданий, останавливает worker, принимает восемь синтетических файлов и восстанавливает worker в `finally`. До запуска убедитесь, что API и worker свободны. Результат — [evidence/slo-ready-incident.json](../evidence/slo-ready-incident.json). Снятие alerts при малом количестве новых событий может означать недостаток событий в коротком окне, а не доказательство выполнения 24-часового SLO. + +Проверка правил без стенда и в ускоренном времени: + +```sh +docker run --rm -v "$PWD:/workspace:ro" --entrypoint promtool prom/prometheus:v3.2.1 test rules /workspace/student-tests/burn_rules.test.yaml +``` + +В runbook зафиксируйте фазу, UTC начала/окончания, первый firing и первое наблюдение после исчезновения alert. Первый и последний интервалы ограничены частотой опроса, а отсутствие ложного firing в одном baseline не оценивает долгосрочный false-positive rate. diff --git a/evidence/slo-analysis.json b/evidence/slo-analysis.json new file mode 100644 index 0000000..9c5d11c --- /dev/null +++ b/evidence/slo-analysis.json @@ -0,0 +1,53 @@ +{ + "sampling_interval_seconds": 5, + "monitor_errors": 0, + "phases": { + "burst": { + "observed_lock_seconds": 75.033, + "alerts": { + "MessengerApiBurnFast": { + "active_before_lock": false, + "first_firing": "2026-11-05T19:30:49.560423+00:00", + "first_firing_after_incident": false, + "detection_seconds": 55.088, + "first_clear": "2026-11-05T19:31:24.687321+00:00", + "recovery_seconds": 15.181 + }, + "MessengerApiBurnSlow": { + "active_before_lock": false, + "first_firing": "2026-11-05T19:31:14.651231+00:00", + "first_firing_after_incident": true, + "detection_seconds": 80.179, + "first_clear": "2026-11-05T19:31:24.687321+00:00", + "recovery_seconds": 15.181 + } + } + }, + "sustained": { + "observed_lock_seconds": 180.134, + "alerts": { + "MessengerApiBurnFast": { + "active_before_lock": false, + "first_firing": "2026-11-05T19:33:40.096081+00:00", + "first_firing_after_incident": false, + "detection_seconds": 50.278, + "first_clear": "2026-11-05T19:36:10.387240+00:00", + "recovery_seconds": 10.648 + }, + "MessengerApiBurnSlow": { + "active_before_lock": false, + "first_firing": "2026-11-05T19:34:20.245337+00:00", + "first_firing_after_incident": false, + "detection_seconds": 90.428, + "first_clear": "2026-11-05T19:37:53.534744+00:00", + "recovery_seconds": 30.724 + } + } + } + }, + "baseline": { + "samples": 13, + "samples_with_burn_alert": 0, + "scope": "one observed healthy baseline, not a long-term false-positive rate" + } +} diff --git a/evidence/slo-incidents.json b/evidence/slo-incidents.json new file mode 100644 index 0000000..742ed8f --- /dev/null +++ b/evidence/slo-incidents.json @@ -0,0 +1,1170 @@ +{ + "description": "controlled DB table lock; three synthetic clients; 5s alert sampling", + "periods": { + "burst": { + "lock_observed": { + "time": "2026-11-05T19:29:54.472744+00:00", + "monotonic": 43527.079238041, + "command_started": { + "time": "2026-11-05T19:29:54.163828+00:00", + "monotonic": 43526.770364958 + } + }, + "command_completed": { + "time": "2026-11-05T19:31:09.505932+00:00", + "monotonic": 43602.112587416 + } + }, + "sustained": { + "lock_observed": { + "time": "2026-11-05T19:32:49.817996+00:00", + "monotonic": 43702.424801208, + "command_started": { + "time": "2026-11-05T19:32:49.516057+00:00", + "monotonic": 43702.122908708 + } + }, + "command_completed": { + "time": "2026-11-05T19:35:59.744503+00:00", + "monotonic": 43882.558427291 + } + } + }, + "samples": [ + { + "time": "2026-11-05T19:28:54.176617+00:00", + "monotonic": 43466.783021166, + "phase": "baseline", + "counts": { + "ok": 1, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:28:59.184768+00:00", + "monotonic": 43471.791177208, + "phase": "baseline", + "counts": { + "ok": 15, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:04.205356+00:00", + "monotonic": 43476.8117975, + "phase": "baseline", + "counts": { + "ok": 30, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:09.226269+00:00", + "monotonic": 43481.832718708, + "phase": "baseline", + "counts": { + "ok": 45, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:14.243046+00:00", + "monotonic": 43486.849499708, + "phase": "baseline", + "counts": { + "ok": 60, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:19.249330+00:00", + "monotonic": 43491.855772208, + "phase": "baseline", + "counts": { + "ok": 75, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:24.265281+00:00", + "monotonic": 43496.871750375, + "phase": "baseline", + "counts": { + "ok": 90, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:29.284910+00:00", + "monotonic": 43501.891384583, + "phase": "baseline", + "counts": { + "ok": 105, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:34.295325+00:00", + "monotonic": 43506.901793458, + "phase": "baseline", + "counts": { + "ok": 120, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:39.306441+00:00", + "monotonic": 43511.91291825, + "phase": "baseline", + "counts": { + "ok": 135, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:44.313768+00:00", + "monotonic": 43516.920254333, + "phase": "baseline", + "counts": { + "ok": 150, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:49.331915+00:00", + "monotonic": 43521.938423708, + "phase": "baseline", + "counts": { + "ok": 165, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:54.351411+00:00", + "monotonic": 43526.957913708, + "phase": "baseline", + "counts": { + "ok": 180, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:29:59.372201+00:00", + "monotonic": 43531.978732458, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 0 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:04.386019+00:00", + "monotonic": 43536.992552291, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 3 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:09.401930+00:00", + "monotonic": 43542.0084625, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 6 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:14.419029+00:00", + "monotonic": 43547.025585291, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 9 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:19.433563+00:00", + "monotonic": 43552.040130916, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 12 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:24.450146+00:00", + "monotonic": 43557.05672225, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 15 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:29.473233+00:00", + "monotonic": 43562.079822583, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 15 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:34.493955+00:00", + "monotonic": 43567.1005505, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 18 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:39.519370+00:00", + "monotonic": 43572.125976166, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 21 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:44.535535+00:00", + "monotonic": 43577.142128416, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 24 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:30:49.560423+00:00", + "monotonic": 43582.167042875, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 27 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:30:54.583572+00:00", + "monotonic": 43587.190215125, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 30 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:30:59.600250+00:00", + "monotonic": 43592.206889708, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 30 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:31:04.616531+00:00", + "monotonic": 43597.223167708, + "phase": "burst", + "counts": { + "ok": 180, + "failed": 33 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:31:09.632643+00:00", + "monotonic": 43602.239279708, + "phase": "burst_recovery", + "counts": { + "ok": 183, + "failed": 36 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:31:14.651231+00:00", + "monotonic": 43607.257891625, + "phase": "burst_recovery", + "counts": { + "ok": 198, + "failed": 36 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:31:19.663273+00:00", + "monotonic": 43612.269926416, + "phase": "burst_recovery", + "counts": { + "ok": 211, + "failed": 36 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:31:24.687321+00:00", + "monotonic": 43617.294002291, + "phase": "burst_recovery", + "counts": { + "ok": 225, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:29.708468+00:00", + "monotonic": 43622.315158041, + "phase": "burst_recovery", + "counts": { + "ok": 240, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:34.728166+00:00", + "monotonic": 43627.334856708, + "phase": "burst_recovery", + "counts": { + "ok": 255, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:39.733767+00:00", + "monotonic": 43632.340459958, + "phase": "burst_recovery", + "counts": { + "ok": 270, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:44.755480+00:00", + "monotonic": 43637.36218675, + "phase": "burst_recovery", + "counts": { + "ok": 285, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:49.769677+00:00", + "monotonic": 43642.376390333, + "phase": "burst_recovery", + "counts": { + "ok": 300, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:54.778133+00:00", + "monotonic": 43647.384860875, + "phase": "burst_recovery", + "counts": { + "ok": 315, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:31:59.788234+00:00", + "monotonic": 43652.394963833, + "phase": "burst_recovery", + "counts": { + "ok": 330, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:04.797259+00:00", + "monotonic": 43657.403998, + "phase": "burst_recovery", + "counts": { + "ok": 345, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:09.813581+00:00", + "monotonic": 43662.42033325, + "phase": "burst_recovery", + "counts": { + "ok": 360, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:14.823961+00:00", + "monotonic": 43667.430715458, + "phase": "burst_recovery", + "counts": { + "ok": 375, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:19.834831+00:00", + "monotonic": 43672.441596833, + "phase": "burst_recovery", + "counts": { + "ok": 390, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:24.847866+00:00", + "monotonic": 43677.454636958, + "phase": "burst_recovery", + "counts": { + "ok": 405, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:29.862747+00:00", + "monotonic": 43682.469528375, + "phase": "burst_recovery", + "counts": { + "ok": 417, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:34.870564+00:00", + "monotonic": 43687.47735275, + "phase": "burst_recovery", + "counts": { + "ok": 432, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:39.880308+00:00", + "monotonic": 43692.487106, + "phase": "burst_recovery", + "counts": { + "ok": 447, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:44.899942+00:00", + "monotonic": 43697.506751, + "phase": "burst_recovery", + "counts": { + "ok": 462, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:49.916853+00:00", + "monotonic": 43702.523669458, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:54.942437+00:00", + "monotonic": 43707.549288958, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 36 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:32:59.957394+00:00", + "monotonic": 43712.564228083, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 39 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:04.970687+00:00", + "monotonic": 43717.577532333, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 42 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:09.993536+00:00", + "monotonic": 43722.600420875, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 45 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:15.009372+00:00", + "monotonic": 43727.616250583, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 48 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:20.031828+00:00", + "monotonic": 43732.638718, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 51 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:25.051997+00:00", + "monotonic": 43737.658880125, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 51 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:30.067799+00:00", + "monotonic": 43742.674685791, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 54 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:35.075453+00:00", + "monotonic": 43747.682349166, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 57 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:33:40.096081+00:00", + "monotonic": 43752.703001416, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 60 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:33:45.119089+00:00", + "monotonic": 43757.7260235, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 63 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:33:50.133709+00:00", + "monotonic": 43762.740644916, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 66 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:33:55.161233+00:00", + "monotonic": 43767.768187291, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 66 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:34:00.176785+00:00", + "monotonic": 43772.783745208, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 69 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:34:05.196858+00:00", + "monotonic": 43777.803812291, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 72 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:34:10.212935+00:00", + "monotonic": 43782.819901041, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 75 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:34:15.231470+00:00", + "monotonic": 43787.838454541, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 78 + }, + "firing": [ + "MessengerApiBurnFast" + ] + }, + { + "time": "2026-11-05T19:34:20.245337+00:00", + "monotonic": 43792.852329875, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 81 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:25.257984+00:00", + "monotonic": 43797.864980958, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 81 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:30.282024+00:00", + "monotonic": 43802.889036875, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 84 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:35.303328+00:00", + "monotonic": 43807.910348833, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 87 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:40.328342+00:00", + "monotonic": 43812.935370625, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 90 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:45.343604+00:00", + "monotonic": 43817.950633291, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 93 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:50.359471+00:00", + "monotonic": 43822.966518166, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 96 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:34:55.367578+00:00", + "monotonic": 43827.974616416, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 96 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:00.386215+00:00", + "monotonic": 43832.993284208, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 99 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:05.400579+00:00", + "monotonic": 43838.0076475, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 102 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:10.422157+00:00", + "monotonic": 43843.0292365, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 105 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:15.442075+00:00", + "monotonic": 43848.049173416, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 108 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:20.452042+00:00", + "monotonic": 43853.05914025, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 111 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:25.461182+00:00", + "monotonic": 43858.068280916, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 111 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:30.480197+00:00", + "monotonic": 43863.087333625, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 114 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:35.504075+00:00", + "monotonic": 43868.111188291, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 117 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:40.521486+00:00", + "monotonic": 43873.129961791, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 120 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:35:55.348285+00:00", + "monotonic": 43878.158763833, + "phase": "sustained", + "counts": { + "ok": 477, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:36:00.359177+00:00", + "monotonic": 43883.173501041, + "phase": "sustained_recovery", + "counts": { + "ok": 480, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:36:05.367876+00:00", + "monotonic": 43888.184996, + "phase": "sustained_recovery", + "counts": { + "ok": 495, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnFast", + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:36:10.387240+00:00", + "monotonic": 43893.206441208, + "phase": "sustained_recovery", + "counts": { + "ok": 510, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:36:15.397936+00:00", + "monotonic": 43898.218563625, + "phase": "sustained_recovery", + "counts": { + "ok": 525, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:36:20.421727+00:00", + "monotonic": 43903.243449875, + "phase": "sustained_recovery", + "counts": { + "ok": 540, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:37:48.510428+00:00", + "monotonic": 43908.257572375, + "phase": "sustained_recovery", + "counts": { + "ok": 555, + "failed": 123 + }, + "firing": [ + "MessengerApiBurnSlow" + ] + }, + { + "time": "2026-11-05T19:37:53.534744+00:00", + "monotonic": 43913.282484708, + "phase": "sustained_recovery", + "counts": { + "ok": 570, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:37:58.549296+00:00", + "monotonic": 43918.29743975, + "phase": "sustained_recovery", + "counts": { + "ok": 585, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:03.567430+00:00", + "monotonic": 43923.315891, + "phase": "sustained_recovery", + "counts": { + "ok": 600, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:08.593041+00:00", + "monotonic": 43928.341731291, + "phase": "sustained_recovery", + "counts": { + "ok": 615, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:13.607305+00:00", + "monotonic": 43933.356177, + "phase": "sustained_recovery", + "counts": { + "ok": 630, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:18.617266+00:00", + "monotonic": 43938.366246166, + "phase": "sustained_recovery", + "counts": { + "ok": 642, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:23.636630+00:00", + "monotonic": 43943.385724875, + "phase": "sustained_recovery", + "counts": { + "ok": 657, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:28.654169+00:00", + "monotonic": 43948.403359125, + "phase": "sustained_recovery", + "counts": { + "ok": 672, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:33.670193+00:00", + "monotonic": 43953.419418, + "phase": "sustained_recovery", + "counts": { + "ok": 687, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:38.676034+00:00", + "monotonic": 43958.425318541, + "phase": "sustained_recovery", + "counts": { + "ok": 702, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:43.699279+00:00", + "monotonic": 43963.448615416, + "phase": "sustained_recovery", + "counts": { + "ok": 717, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:48.718747+00:00", + "monotonic": 43968.468122083, + "phase": "sustained_recovery", + "counts": { + "ok": 732, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:53.742289+00:00", + "monotonic": 43973.491697375, + "phase": "sustained_recovery", + "counts": { + "ok": 747, + "failed": 123 + }, + "firing": [] + }, + { + "time": "2026-11-05T19:38:58.757203+00:00", + "monotonic": 43978.50662725, + "phase": "sustained_recovery", + "counts": { + "ok": 762, + "failed": 123 + }, + "firing": [] + } + ], + "end_time": "2026-11-05T19:39:02.820853+00:00", + "final_counts": { + "ok": 774, + "failed": 123 + } +} diff --git a/evidence/slo-ready-incident.json b/evidence/slo-ready-incident.json new file mode 100644 index 0000000..5eff503 --- /dev/null +++ b/evidence/slo-ready-incident.json @@ -0,0 +1,211 @@ +{ + "samples": [ + { + "time": "2026-11-06T06:18:43.857552+00:00", + "monotonic": 49295.73000975, + "phase": "baseline", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:18:49.195942+00:00", + "monotonic": 49301.068345333, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:18:54.211236+00:00", + "monotonic": 49306.083585125, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:18:59.238528+00:00", + "monotonic": 49311.110847333, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:04.276851+00:00", + "monotonic": 49316.149107833, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:09.316299+00:00", + "monotonic": 49321.18853025, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:14.361014+00:00", + "monotonic": 49326.233190833, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:19.399292+00:00", + "monotonic": 49331.271419, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:24.439389+00:00", + "monotonic": 49336.31146675, + "phase": "worker_stopped", + "firing": [], + "eligible": 9.0, + "bad": 4.0 + }, + { + "time": "2026-11-06T06:19:29.469853+00:00", + "monotonic": 49341.341864875, + "phase": "worker_stopped", + "firing": [ + "MessengerReadyBurnFast", + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:19:35.732760+00:00", + "monotonic": 49347.604713666, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnFast", + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:19:40.766904+00:00", + "monotonic": 49352.638829583, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnFast", + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:19:45.800827+00:00", + "monotonic": 49357.672704333, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:19:50.839444+00:00", + "monotonic": 49362.711278166, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:19:55.882108+00:00", + "monotonic": 49367.753864791, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:00.935125+00:00", + "monotonic": 49372.806871, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:05.976123+00:00", + "monotonic": 49377.847798625, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:11.006201+00:00", + "monotonic": 49382.877811166, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:16.034665+00:00", + "monotonic": 49387.906272875, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:21.073601+00:00", + "monotonic": 49392.945128916, + "phase": "recovery", + "firing": [ + "MessengerReadyBurnSlow" + ], + "eligible": 17.0, + "bad": 12.0 + }, + { + "time": "2026-11-06T06:20:26.112334+00:00", + "monotonic": 49397.983810916, + "phase": "recovery", + "firing": [], + "eligible": 17.0, + "bad": 12.0 + } + ], + "jobs": 8, + "accepted_at": { + "time": "2026-11-06T06:18:49.190891+00:00", + "monotonic": 49301.063291333 + }, + "worker_started": { + "time": "2026-11-06T06:19:31.951591+00:00", + "monotonic": 49343.823643916 + }, + "all_ready": { + "time": "2026-11-06T06:19:35.725614+00:00", + "monotonic": 49347.597564333 + }, + "result": "PASS" +} diff --git a/evidence/slo-track.md b/evidence/slo-track.md new file mode 100644 index 0000000..a24838f --- /dev/null +++ b/evidence/slo-track.md @@ -0,0 +1,34 @@ +# Трек 2: SLO и обнаружение инцидентов + +## Гипотеза и методика + +Гипотеза: при контролируемой деградации многооконные burn-rate alerts обнаружат ускоренный расход бюджета; короткое окно позволит снять сигнал после прекращения воздействия. Это гипотеза об учебной конфигурации, а не утверждение о любой нагрузке. + +Цели, формулы, ограничения SLI и команды диагностики: [runbook](../docs/slo-runbook.md). Оба SLO имеют целевое значение 99% на скользящем окне 24 часа. Пары окон и пороги намеренно сокращены для локального испытания: fast — 20 секунд и 1 минута при burn >28,8; slow — 1 и 5 минут при burn >14,4. В коротком окне нужно не менее 5 событий. Правила и панели версионируются в Git. + +Испытания на существующем локальном стенде Docker Compose. API: три клиентских потока создавали синтетические сообщения, каждый делал паузу 1 секунду между завершившимися запросами; до воздействия — 60 секунд baseline. На время воздействия таблица `users` блокировалась транзакцией на 75 и 180 секунд, между опытами было 100 секунд восстановления. Это воспроизводимая искусственная блокировка, а не реальный пользовательский трафик. Каждые примерно 5 секунд сценарий запрашивал firing alerts через Grafana/Prometheus и сохранял монотонное время. Начало — момент, когда скрипт увидел lock, конец — возврат транзакции. Эти точки и опрос имеют собственную задержку; полученные длительности — наблюдательные оценки, не точные времена переключения Prometheus. + +Исходные агрегаты и временные отметки: [slo-incidents.json](slo-incidents.json). Пересчёт: `python3 student-tests/slo_analyze.py` → [slo-analysis.json](slo-analysis.json). Ошибок опроса не зафиксировано. В ходе длительного опыта наблюдался скачок системных часов UTC: разность некоторых соседних UTC-отметок не равна разности монотонных отметок. Длительности ниже рассчитаны по `monotonic`; скачок также мог повлиять на временные окна Prometheus, поэтому эксперимент следует повторить на системе со стабильными часами. + +## Результаты API + +| Воздействие | Наблюдаемая длительность блокировки | Fast: первое firing / снятие после конца | Slow: первое firing / снятие после конца | +| --- | ---: | ---: | ---: | +| Короткое | 75,033 с | 55,088 с / 15,181 с | 80,179 с / 15,181 с | +| Длительное | 180,134 с | 50,278 с / 10,648 с | 90,428 с / 30,724 с | + +В коротком сценарии slow впервые появился уже через 5,145 с после окончания воздействия и исчез вместе с fast. По строгой классификации «блокировка уже завершилась — система восстановлена» зафиксирована одна новая тревога вне воздействия; по смыслу окна это запоздалый сигнал о предыдущем расходе бюджета. При длительном сценарии оба сигнала впервые появились во время блокировки. За один baseline получено 13 проб опроса и 0 проб с burn alert: наблюдаемых ложных срабатываний на этом коротком интервале нет, но данных недостаточно для оценки долгосрочной частоты ложных тревог. + +Разность клиентских накопленных счётчиков между первой и последней пробами фазы: baseline 179 успешных / 0 ошибок; короткая блокировка 0 / 33; длительная 0 / 87. Они не включают полные пограничные интервалы и могут включать timeout; это не числитель HTTP 5xx SLI. Срабатывания рассчитаны Prometheus по серверным метрикам. В Loki найден синтетический HTTP 503 с trace `47caf6293f35aabf09f71f307ed860a3`, где span `postgres.user_for_token` занял 5,004 с: это проверка пути диагностики в runbook. Проверка выполнена автором сценария; прохождение другим студентом пока не зафиксировано. + +## Проверка SLO вложений + +`python3 student-tests/slo_ready_incident.py` убедился, что незавершённых задач нет, остановил worker, принял восемь синтетических вложений и дождался alert. Затем worker запущен, все вложения достигли ready. Исходные измерения: [slo-ready-incident.json](slo-ready-incident.json). + +До воздействия счётчики matured/плохих заданий были 9/4. В первой пробе firing — 17/12: прирост обоих счётчиков равен 8, то есть все восемь заданий попали в знаменатель и нарушили 30-секундный срок. Fast и slow стали firing через 40,279 с после последнего принятия. Все задания были ready через 3,774 с после команды восстановления worker. Fast исчез через 13,849 с, slow — через 54,160 с после команды запуска. Значения опросные, включая задержку запуска Docker и опроса. При снятии slow новых заданий не поступало: условие минимального числа событий перестало выполняться. Это не доказывает, что 24-часовой SLO снова выполнен; факт просрочки остаётся в счётчиках. + +## Дополнительная проверка правил и ограничения + +`promtool test rules` на [burn_rules.test.yaml](../student-tests/burn_rules.test.yaml) проверил нормальную нагрузку без burn alerts, тяжёлый краткий всплеск с последующим снятием fast, устойчивую 20%-ную долю ошибок с firing slow без fast, а также поведение при малом числе событий и fast alert просроченных вложений. Это синтетические ряды, не замена эксперименту с реальными данными. + +Границы: API SLI не включает ошибки LB до приложения. Счётчики готовности вычисляются из состояний PostgreSQL раз в цикл outbox; при недоступном outbox данные устаревают, а события во время разрыва наблюдения могут не войти в `increase` после перезапуска процесса. Начало и конец срока фиксируются внутри DB-транзакций, поэтому приближённо описывают пользовательские границы durable acceptance и ready. Возможные manual replay/редактирование БД, смена или удаление заданий могут нарушить монотонность DB-счётчиков; учебный API не удаляет задания. Нет оценки ложных срабатываний за длительный период или проверки runbook другим студентом. Ошибки, произошедшие до восстановления, учитываются в бюджетном окне до истечения окна и могут вызвать задержанный alert. diff --git a/infra/grafana/dashboards/messenger.json b/infra/grafana/dashboards/messenger.json index 05cb19a..57e8548 100644 --- a/infra/grafana/dashboards/messenger.json +++ b/infra/grafana/dashboards/messenger.json @@ -60,7 +60,7 @@ "targets": [ { "refId": "A", - "expr": "(sum(rate(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[1m])) or vector(0)) / clamp_min(sum(rate(messenger_http_requests_total{route!~\"/health/.*\"}[1m])),0.001)", + "expr": "(sum(rate(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[1m])) or vector(0)) / clamp_min(sum(rate(messenger_http_requests_total{route!~\"/health/.*\"}[1m])),0.001) and sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[1m])) > 0", "legendFormat": "{{service_name}} {{outcome}}" } ] @@ -428,10 +428,116 @@ "targets": [ { "refId": "A", - "expr": "1 - (sum(increase(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[24h])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[24h])),1)", + "expr": "1 - (sum(increase(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[24h])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[24h])),1) and sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[24h])) > 0", "legendFormat": "SLI" } ] + }, + { + "id": 15, + "title": "API SLO burn rate (budget 1%)", + "type": "timeseries", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 56 + }, + "fieldConfig": { + "defaults": { + "unit": "short" + }, + "overrides": [] + }, + "targets": [ + { + "refId": "A", + "expr": "(((sum(increase(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[20s])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[20s])), 1)) / 0.01) and sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[20s])) > 0", + "legendFormat": "burn 20s" + }, + { + "refId": "B", + "expr": "(((sum(increase(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[1m])), 1)) / 0.01) and sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[1m])) > 0", + "legendFormat": "burn 1m" + }, + { + "refId": "C", + "expr": "(((sum(increase(messenger_http_requests_total{status_class=\"5xx\",route!~\"/health/.*\"}[5m])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[5m])), 1)) / 0.01) and sum(increase(messenger_http_requests_total{route!~\"/health/.*\"}[5m])) > 0", + "legendFormat": "burn 5m" + } + ] + }, + { + "id": 16, + "title": "READY SLO burn rate (budget 1%)", + "type": "timeseries", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 56 + }, + "fieldConfig": { + "defaults": { + "unit": "short" + }, + "overrides": [] + }, + "targets": [ + { + "refId": "A", + "expr": "(((sum(increase(messenger_slo_ready_bad_total{service_name=\"messenger-outbox\"}[20s])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[20s])), 1)) / 0.01) and sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[20s])) > 0", + "legendFormat": "burn 20s" + }, + { + "refId": "B", + "expr": "(((sum(increase(messenger_slo_ready_bad_total{service_name=\"messenger-outbox\"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[1m])), 1)) / 0.01) and sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[1m])) > 0", + "legendFormat": "burn 1m" + }, + { + "refId": "C", + "expr": "(((sum(increase(messenger_slo_ready_bad_total{service_name=\"messenger-outbox\"}[5m])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[5m])), 1)) / 0.01) and sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[5m])) > 0", + "legendFormat": "burn 5m" + } + ] + }, + { + "id": 17, + "title": "Accepted jobs ready within 30 s — 24h (matured cohort)", + "type": "timeseries", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 64 + }, + "fieldConfig": { + "defaults": { + "unit": "percentunit", + "min": 0, + "max": 1 + }, + "overrides": [] + }, + "targets": [ + { + "refId": "A", + "expr": "1 - ((sum(increase(messenger_slo_ready_bad_total{service_name=\"messenger-outbox\"}[24h])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[24h])), 1)) and sum(increase(messenger_slo_ready_eligible_total{service_name=\"messenger-outbox\"}[24h])) > 0", + "legendFormat": "ready SLI" + } + ] } ] } diff --git a/infra/prometheus/alerts.yaml b/infra/prometheus/alerts.yaml index 3bcc613..d7a700b 100644 --- a/infra/prometheus/alerts.yaml +++ b/infra/prometheus/alerts.yaml @@ -11,3 +11,19 @@ groups: for: 15s labels: {severity: warning} annotations: {summary: 'Oldest queued job exceeds 30 seconds', runbook: 'Check worker health, busy/capacity, broker and consumer traces.'} + - alert: MessengerApiBurnFast + expr: '((sum(increase(messenger_http_requests_total{status_class="5xx",route!~"/health/.*"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~"/health/.*"}[1m])), 1)) > 28.8 * 0.01 and ((sum(increase(messenger_http_requests_total{status_class="5xx",route!~"/health/.*"}[20s])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~"/health/.*"}[20s])), 1)) > 28.8 * 0.01 and sum(increase(messenger_http_requests_total{route!~"/health/.*"}[20s])) >= 5' + labels: {severity: critical, slo: api, burn: fast} + annotations: {summary: 'api SLO fast burn', runbook: 'See docs/slo-runbook.md'} + - alert: MessengerApiBurnSlow + expr: '((sum(increase(messenger_http_requests_total{status_class="5xx",route!~"/health/.*"}[5m])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~"/health/.*"}[5m])), 1)) > 14.4 * 0.01 and ((sum(increase(messenger_http_requests_total{status_class="5xx",route!~"/health/.*"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_http_requests_total{route!~"/health/.*"}[1m])), 1)) > 14.4 * 0.01 and sum(increase(messenger_http_requests_total{route!~"/health/.*"}[1m])) >= 5' + labels: {severity: warning, slo: api, burn: slow} + annotations: {summary: 'api SLO slow burn', runbook: 'See docs/slo-runbook.md'} + - alert: MessengerReadyBurnFast + expr: '((sum(increase(messenger_slo_ready_bad_total{service_name="messenger-outbox"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[1m])), 1)) > 28.8 * 0.01 and ((sum(increase(messenger_slo_ready_bad_total{service_name="messenger-outbox"}[20s])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[20s])), 1)) > 28.8 * 0.01 and sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[20s])) >= 5' + labels: {severity: critical, slo: ready, burn: fast} + annotations: {summary: 'ready SLO fast burn', runbook: 'See docs/slo-runbook.md'} + - alert: MessengerReadyBurnSlow + expr: '((sum(increase(messenger_slo_ready_bad_total{service_name="messenger-outbox"}[5m])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[5m])), 1)) > 14.4 * 0.01 and ((sum(increase(messenger_slo_ready_bad_total{service_name="messenger-outbox"}[1m])) or vector(0)) / clamp_min(sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[1m])), 1)) > 14.4 * 0.01 and sum(increase(messenger_slo_ready_eligible_total{service_name="messenger-outbox"}[1m])) >= 5' + labels: {severity: warning, slo: ready, burn: slow} + annotations: {summary: 'ready SLO slow burn', runbook: 'See docs/slo-runbook.md'} diff --git a/src/outbox.py b/src/outbox.py index 6e8e3d0..79522aa 100644 --- a/src/outbox.py +++ b/src/outbox.py @@ -22,12 +22,22 @@ async def run() -> None: while True: try: await store.schedule_due_jobs(int(os.environ.get('JOB_MAX_ATTEMPTS', '5'))) - queue = await store.pool.fetchrow("SELECT count(*) AS depth, COALESCE(EXTRACT(EPOCH FROM now()-min(created_at)), 0)::float8 AS age FROM attachment_jobs WHERE status='queued'") - tel.state.update(queue_depth=queue['depth'], queue_age=queue['age']) for event in await store.due_outbox_events(): context = event['trace_context'] await publish(event["payload"], json.loads(context) if isinstance(context, str) else context) await store.mark_outbox_published(event["id"]) + try: + queue = await store.pool.fetchrow("SELECT count(*) AS depth, COALESCE(EXTRACT(EPOCH FROM now()-min(created_at)), 0)::float8 AS age FROM attachment_jobs WHERE status='queued'") + slo = await store.pool.fetchrow(""" + SELECT count(*) FILTER (WHERE created_at <= now() - interval '30 seconds') AS eligible, + count(*) FILTER (WHERE created_at <= now() - interval '30 seconds' + AND (status <> 'ready' OR updated_at > created_at + interval '30 seconds')) AS bad + FROM attachment_jobs + """) + tel.state.update(queue_depth=queue['depth'], queue_age=queue['age'], + slo_ready_eligible=slo['eligible'], slo_ready_bad=slo['bad']) + except Exception: + logging.warning("queue telemetry unavailable") except Exception: logging.exception("outbox dispatch failed; durable event remains pending") await asyncio.sleep(interval) diff --git a/src/telemetry.py b/src/telemetry.py index 01ca0d4..c8c2969 100644 --- a/src/telemetry.py +++ b/src/telemetry.py @@ -21,9 +21,12 @@ job_duration = meter.create_histogram("messenger.job.duration", unit="s") ready_duration = meter.create_histogram("messenger.job.ready.duration", unit="s") busy = meter.create_up_down_counter("messenger.worker.busy", unit="{worker}") capacity = meter.create_up_down_counter("messenger.worker.capacity", unit="{worker}") -state = {"queue_depth": 0, "queue_age": 0, "pool_used": 0, "pool_capacity": 0, "pool_waiting": 0} +state = {"queue_depth": 0, "queue_age": 0, "pool_used": 0, "pool_capacity": 0, "pool_waiting": 0, + "slo_ready_eligible": 0, "slo_ready_bad": 0} for name, unit in (("queue_depth", "{job}"), ("queue_age", "s"), ("pool_used", "{connection}"), ("pool_capacity", "{connection}"), ("pool_waiting", "{request}")): meter.create_observable_gauge("messenger." + name, callbacks=[lambda options, key=name: [metrics.Observation(state[key])]], unit=unit) +for name in ("slo_ready_eligible", "slo_ready_bad"): + meter.create_observable_counter("messenger." + name, callbacks=[lambda options, key=name: [metrics.Observation(state[key])]], unit="{job}") def process_cpu(options): usage = resource.getrusage(resource.RUSAGE_SELF) diff --git a/student-tests/burn_rules.test.yaml b/student-tests/burn_rules.test.yaml new file mode 100644 index 0000000..7b25538 --- /dev/null +++ b/student-tests/burn_rules.test.yaml @@ -0,0 +1,83 @@ +rule_files: + - /workspace/infra/prometheus/alerts.yaml +evaluation_interval: 5s +tests: + - name: healthy + interval: 5s + input_series: + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="2xx"}' + values: '0+100x80' + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="5xx"}' + values: '0+0x80' + - series: 'messenger_slo_ready_eligible_total{service_name="messenger-outbox"}' + values: '0+100x80' + - series: 'messenger_slo_ready_bad_total{service_name="messenger-outbox"}' + values: '0+0x80' + alert_rule_test: + - {eval_time: 5m, alertname: MessengerApiBurnFast, exp_alerts: []} + - {eval_time: 5m, alertname: MessengerApiBurnSlow, exp_alerts: []} + - {eval_time: 5m, alertname: MessengerReadyBurnFast, exp_alerts: []} + - {eval_time: 5m, alertname: MessengerReadyBurnSlow, exp_alerts: []} + - name: brief severe spike and recovery + interval: 5s + input_series: + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="2xx"}' + values: '0+100x12 1200+0x8 1200+100x60' + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="5xx"}' + values: '0+0x12 0+100x8 800+0x60' + alert_rule_test: + - eval_time: 1m30s + alertname: MessengerApiBurnFast + exp_alerts: + - exp_labels: {severity: critical, slo: api, burn: fast} + exp_annotations: {summary: 'api SLO fast burn', runbook: 'See docs/slo-runbook.md'} + - {eval_time: 3m, alertname: MessengerApiBurnFast, exp_alerts: []} + - name: sustained moderate degradation + interval: 5s + input_series: + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="2xx"}' + values: '0+80x80' + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="5xx"}' + values: '0+20x80' + - series: 'messenger_slo_ready_eligible_total{service_name="messenger-outbox"}' + values: '0+100x80' + - series: 'messenger_slo_ready_bad_total{service_name="messenger-outbox"}' + values: '0+20x80' + alert_rule_test: + - {eval_time: 5m, alertname: MessengerApiBurnFast, exp_alerts: []} + - {eval_time: 5m, alertname: MessengerReadyBurnFast, exp_alerts: []} + - eval_time: 5m + alertname: MessengerApiBurnSlow + exp_alerts: + - exp_labels: {severity: warning, slo: api, burn: slow} + exp_annotations: {summary: 'api SLO slow burn', runbook: 'See docs/slo-runbook.md'} + - eval_time: 5m + alertname: MessengerReadyBurnSlow + exp_alerts: + - exp_labels: {severity: warning, slo: ready, burn: slow} + exp_annotations: {summary: 'ready SLO slow burn', runbook: 'See docs/slo-runbook.md'} + - name: low-volume guard + interval: 5s + input_series: + - series: 'messenger_http_requests_total{route="/api/v1/users",status_class="5xx"}' + values: '0+1x80' + - series: 'messenger_slo_ready_eligible_total{service_name="messenger-outbox"}' + values: '0+1x80' + - series: 'messenger_slo_ready_bad_total{service_name="messenger-outbox"}' + values: '0+1x80' + alert_rule_test: + - {eval_time: 5m, alertname: MessengerApiBurnFast, exp_alerts: []} + - {eval_time: 5m, alertname: MessengerReadyBurnFast, exp_alerts: []} + - name: late ready events fast burn + interval: 5s + input_series: + - series: 'messenger_slo_ready_eligible_total{service_name="messenger-outbox"}' + values: '0+100x30' + - series: 'messenger_slo_ready_bad_total{service_name="messenger-outbox"}' + values: '0+100x30' + alert_rule_test: + - eval_time: 1m + alertname: MessengerReadyBurnFast + exp_alerts: + - exp_labels: {severity: critical, slo: ready, burn: fast} + exp_annotations: {summary: 'ready SLO fast burn', runbook: 'See docs/slo-runbook.md'} diff --git a/student-tests/slo_analyze.py b/student-tests/slo_analyze.py new file mode 100644 index 0000000..e4dfb87 --- /dev/null +++ b/student-tests/slo_analyze.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +"""Summarize observed alert transitions; sampling bounds detection precision.""" +import json +from pathlib import Path + +root = Path(__file__).resolve().parents[1] +data = json.loads((root / 'evidence/slo-incidents.json').read_text()) +samples = sorted((s for s in data['samples'] if 'firing' in s), key=lambda s: s['monotonic']) +alerts = ['MessengerApiBurnFast', 'MessengerApiBurnSlow'] +output = {'sampling_interval_seconds': 5, 'monitor_errors': sum('monitor_error' in s for s in data['samples']), 'phases': {}} +base = [s for s in samples if s['phase'] == 'baseline'] +output['baseline'] = {'samples': len(base), 'samples_with_burn_alert': sum(bool(s['firing']) for s in base), 'scope': 'one observed healthy baseline, not a long-term false-positive rate'} +for name, period in data['periods'].items(): + start, end = period['lock_observed']['monotonic'], period['command_completed']['monotonic'] + active = [s for s in samples if start <= s['monotonic'] <= end] + recovery = [s for s in samples if s['monotonic'] > end and s['phase'] == name + '_recovery'] + previous = [s for s in samples if s['monotonic'] < start] + row = {'observed_lock_seconds': round(end-start, 3), 'alerts': {}} + for alert in alerts: + before = bool(previous and alert in previous[-1]['firing']) + hits = [s for s in active + recovery if alert in s['firing']] + clear = [s for s in recovery if hits and s['monotonic'] > hits[0]['monotonic'] and alert not in s['firing']] + row['alerts'][alert] = {'active_before_lock': before, + 'first_firing': hits[0]['time'] if hits else None, + 'first_firing_after_incident': bool(hits and hits[0]['monotonic'] > end), + 'detection_seconds': round(hits[0]['monotonic']-start, 3) if hits and not before else None, + 'first_clear': clear[0]['time'] if hits and clear else None, + 'recovery_seconds': round(clear[0]['monotonic']-end, 3) if hits and clear else None} + output['phases'][name] = row +path = root / 'evidence/slo-analysis.json' +path.write_text(json.dumps(output, ensure_ascii=False, indent=2) + '\n') +print(json.dumps(output, ensure_ascii=False, indent=2)) diff --git a/student-tests/slo_incidents.py b/student-tests/slo_incidents.py new file mode 100644 index 0000000..241c504 --- /dev/null +++ b/student-tests/slo_incidents.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""Run two bounded DB-lock incidents against the local Compose project. + +Creates synthetic data, records only aggregate counts/alert states, and releases +all locks on exit. Run on the isolated lab6 stack, never a shared database. +""" +import base64 +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +import json +from pathlib import Path +import subprocess +import sys +import threading +import time +import urllib.parse +import urllib.request + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client, Failure + +OUTPUT = ROOT / 'evidence' / 'slo-incidents.json' +STOP = threading.Event() +LOCK = threading.Lock() +COUNTS = {'ok': 0, 'failed': 0} +SCENARIO = {'phase': 'bootstrap'} +SAMPLES = [] +AUTH = 'Basic ' + base64.b64encode(('admin:' + (ROOT / 'secrets/grafana_password').read_text().strip()).encode()).decode() + +def utc(): return datetime.now(timezone.utc).isoformat() + +def get(path, params=None): + url = 'http://127.0.0.1:3000/api/datasources/proxy/uid/prometheus/api/v1/' + path + if params: url += '?' + urllib.parse.urlencode(params) + with urllib.request.urlopen(urllib.request.Request(url, headers={'Authorization': AUTH}), timeout=5) as response: + result = json.load(response) + if result.get('status') != 'success': raise RuntimeError('Prometheus query failed') + return result['data'] + +def monitor(): + while not STOP.is_set(): + try: + alerts = get('alerts')['alerts'] + firing = sorted(a['labels']['alertname'] for a in alerts if a['state'] == 'firing' and 'Burn' in a['labels']['alertname']) + with LOCK: sample = {'time': utc(), 'monotonic': time.monotonic(), 'phase': SCENARIO['phase'], 'counts': dict(COUNTS), 'firing': firing} + SAMPLES.append(sample) + except Exception as error: + SAMPLES.append({'time': utc(), 'monotonic': time.monotonic(), 'phase': SCENARIO['phase'], 'monitor_error': type(error).__name__}) + STOP.wait(5) + +def worker(actor, chat): + client = Client(timeout=9) + while not STOP.is_set(): + try: + client.message(actor, chat, 'synthetic SLO experiment') + outcome = 'ok' + except Failure: + outcome = 'failed' + with LOCK: COUNTS[outcome] += 1 + STOP.wait(1) + +def phase(name): + with LOCK: SCENARIO['phase'] = name + print(utc(), name, flush=True) + +def db_is_locked(): + result = subprocess.run(['docker','compose','exec','-T','postgres','psql','-U','messenger','-d','messenger','-Atc', + "SELECT EXISTS (SELECT 1 FROM pg_locks WHERE relation='users'::regclass AND mode='AccessExclusiveLock' AND granted)"], + cwd=ROOT, capture_output=True, text=True, timeout=10, check=True) + return result.stdout.strip() == 't' + +def incident(name, seconds): + cmd = ['docker','compose','exec','-T','postgres','psql','-U','messenger','-d','messenger','-c', + f'BEGIN; LOCK TABLE users IN ACCESS EXCLUSIVE MODE; SELECT pg_sleep({seconds}); COMMIT;'] + start_command = {'time': utc(), 'monotonic': time.monotonic()} + proc = subprocess.Popen(cmd, cwd=ROOT, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) + try: + deadline = time.monotonic() + 15 + while time.monotonic() < deadline: + if proc.poll() is not None: raise RuntimeError('DB lock command ended early') + if db_is_locked(): break + time.sleep(.5) + else: raise RuntimeError('DB lock was not observed') + phase(name) + start = {'time': utc(), 'monotonic': time.monotonic(), 'command_started': start_command} + code = proc.wait(timeout=seconds+20) + if code: raise RuntimeError('DB lock command failed') + end = {'time': utc(), 'monotonic': time.monotonic()} + phase(name + '_recovery') + return {'lock_observed': start, 'command_completed': end} + finally: + if proc.poll() is None: + proc.terminate() + try: proc.wait(timeout=5) + except subprocess.TimeoutExpired: proc.kill(); proc.wait() + +def main(): + client = Client(timeout=9) + actor, _, _, chat = client.bootstrap() + result = {'description': 'controlled DB table lock; three synthetic clients; 5s alert sampling', 'periods': {}, 'samples': SAMPLES} + monitor_thread = threading.Thread(target=monitor, daemon=True); monitor_thread.start() + try: + with ThreadPoolExecutor(max_workers=3) as pool: + futures = [pool.submit(worker, actor, chat) for _ in range(3)] + phase('baseline'); time.sleep(60) + result['periods']['burst'] = incident('burst', 75) + time.sleep(100) + result['periods']['sustained'] = incident('sustained', 180) + time.sleep(100) + phase('complete') + STOP.set() + for future in futures: future.result(timeout=15) + finally: + STOP.set(); monitor_thread.join(timeout=10) + result['end_time'] = utc() + result['final_counts'] = COUNTS + OUTPUT.write_text(json.dumps(result, ensure_ascii=False, indent=2) + '\n') + print('Aggregate evidence:', OUTPUT, flush=True) + +if __name__ == '__main__': main() diff --git a/student-tests/slo_ready_incident.py b/student-tests/slo_ready_incident.py new file mode 100644 index 0000000..c816668 --- /dev/null +++ b/student-tests/slo_ready_incident.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 +"""Stop only this project's idle worker, submit 8 jobs, verify ready SLO.""" +import base64 +from datetime import datetime, timezone +import json +from pathlib import Path +import subprocess +import sys +import time +import urllib.parse +import urllib.request + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client + +secret = (ROOT / 'secrets/grafana_password').read_text().strip() +auth = 'Basic ' + base64.b64encode(('admin:' + secret).encode()).decode() +def utc(): return datetime.now(timezone.utc).isoformat() +def prom(path, query=None): + url = 'http://127.0.0.1:3000/api/datasources/proxy/uid/prometheus/api/v1/' + path + if query is not None: url += '?' + urllib.parse.urlencode({'query': query}) + with urllib.request.urlopen(urllib.request.Request(url, headers={'Authorization': auth}), timeout=5) as r: return json.load(r)['data'] +def metric(name): + result = prom('query', name + '{service_name="messenger-outbox"}')['result'] + return float(result[0]['value'][1]) if result else None +def sample(phase): + alerts = prom('alerts')['alerts'] + return {'time': utc(), 'monotonic': time.monotonic(), 'phase': phase, + 'firing': sorted(a['labels']['alertname'] for a in alerts if a['state']=='firing' and a['labels']['alertname'].startswith('MessengerReadyBurn')), + 'eligible': metric('messenger_slo_ready_eligible_total'), 'bad': metric('messenger_slo_ready_bad_total')} +def docker(*args): subprocess.run(['docker','compose',*args], cwd=ROOT, check=True, stdout=subprocess.DEVNULL) +def run(): + status = subprocess.run(['docker','compose','exec','-T','postgres','psql','-U','messenger','-d','messenger','-Atc', + "SELECT count(*) FROM attachment_jobs WHERE status IN ('queued','processing')"], cwd=ROOT, check=True, capture_output=True, text=True) + if int(status.stdout.strip()): raise RuntimeError('Pending jobs exist; refusing to stop worker') + client=Client(); actor,_,_,chat=client.bootstrap(); samples=[]; out={'samples':samples,'jobs':8} + worker_stopped=False + try: + samples.append(sample('baseline')) + docker('stop','-t','5','worker'); worker_stopped=True + accepted=[] + for _ in range(8): accepted.append(client.attachment(actor,chat)[0]) + out['accepted_at']={'time':utc(),'monotonic':time.monotonic()} + print('8 synthetic jobs accepted; waiting for burn alert', flush=True) + deadline=time.monotonic()+100 + while time.monotonic()