add level 5

This commit is contained in:
Матвей
2026-11-06 09:39:53 +03:00
parent 45c7aa0085
commit c885462c04
15 changed files with 1966 additions and 8 deletions
+10 -2
View File
@@ -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.
+1 -1
View File
@@ -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.
+41
View File
@@ -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.
+53
View File
@@ -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"
}
}
File diff suppressed because it is too large Load Diff
+211
View File
@@ -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"
}
+34
View File
@@ -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.
+108 -2
View File
@@ -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"
}
]
}
]
}
+16
View File
@@ -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'}
+12 -2
View File
@@ -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)
+4 -1
View File
@@ -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)
+83
View File
@@ -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'}
+32
View File
@@ -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))
+121
View File
@@ -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()
+70
View File
@@ -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()<deadline:
s=sample('worker_stopped'); samples.append(s)
if 'MessengerReadyBurnFast' in s['firing']: break
time.sleep(5)
else: raise RuntimeError('Ready fast burn did not fire in 100 seconds')
docker('start','worker'); worker_stopped=False
out['worker_started']={'time':utc(),'monotonic':time.monotonic()}
for att in accepted: client.wait_ready(actor,att,wait_seconds=90)
out['all_ready']={'time':utc(),'monotonic':time.monotonic()}
print('all jobs ready; waiting for alert to clear', flush=True)
deadline=time.monotonic()+100
while time.monotonic()<deadline:
s=sample('recovery');samples.append(s)
if not s['firing']: break
time.sleep(5)
else: raise RuntimeError('Ready burn alert did not clear in 100 seconds')
out['result']='PASS'
finally:
if worker_stopped:
try: docker('start','worker')
except Exception: out['worker_restore_failed']=True
(ROOT/'evidence/slo-ready-incident.json').write_text(json.dumps(out,ensure_ascii=False,indent=2)+'\n')
print('PASS: ready SLO incident; evidence/slo-ready-incident.json',flush=True)
if __name__=='__main__':run()