ЛР 6 — БПИ2303 — Лазарев — на 3 #35

Closed
zemiles wants to merge 2 commits from zemiles/mtusi2026lab6:solution/bpi2303-lazarev into main
116 changed files with 22733 additions and 39 deletions
+100 -10
View File
@@ -1,30 +1,120 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# scripts/init-secrets.sh делает это сам и создаёт файлы в secrets/ (Docker secrets).
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# Пароль БД НЕ задаётся здесь: он в файле secrets/postgres_password (Docker secret),
# в контейнерах виден как /run/secrets/postgres_password (POSTGRES_PASSWORD_FILE).
# Вместо DATABASE_URL_FILE из skeleton используется POSTGRES_* + POSTGRES_PASSWORD_FILE;
# приложение понимает и DATABASE_URL_FILE (см. REPORT.md).
POSTGRES_DB=messenger
POSTGRES_USER=messenger
# Сессии хранятся в PostgreSQL (lab2), Redis/Valkey не используется:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
DB_POOL_SIZE=10
# Graceful shutdown реплики: пауза с ready=503 и лимит на дообслуживание запросов.
DRAIN_SECONDS=3
SHUTDOWN_TIMEOUT_SECONDS=10
LB_PORT=8080
APP_VERSION=1
# Защита от OOM при шторме входов: одновременных scrypt на реплику и ожидание слота (с).
PASSWORD_HASH_CONCURRENCY=2
PASSWORD_HASH_WAIT_SECONDS=0.5
# Readiness: фоновый пинг БД (с) и сколько секунд без успешного пинга реплика ещё «готова».
DB_HEALTH_INTERVAL_SECONDS=1
READY_STALE_SECONDS=3
# Попыток POST /auth/sessions за 10 с с одного IP на LB (сверх — 429).
LOGIN_RATE_LIMIT=20
# --- Lab4: S3 (SeaweedFS) и вложения ---
# S3 API SeaweedFS слушает 8333 (не 9000, как у MinIO); наружу не публикуется.
S3_ENDPOINT=http://s3:8333
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
# Ключи API (права только Read+Write на bucket). Значения — в secrets/, здесь только пути.
# У worker свой ключ (s3_worker_*), у janitor — свой (s3_janitor_*).
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_api_access_key
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_api_secret_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
# Весь приём тела upload, с; одновременных загрузок и JPEG-декодирований на реплику.
UPLOAD_TIMEOUT_SECONDS=60
# Общий срок приёма JSON-тела (до 1 MiB), с; оба срока не обойти медленной передачей (аудит F03).
JSON_BODY_TIMEOUT_SECONDS=10
UPLOAD_CONCURRENCY=8
DECODE_CONCURRENCY=1
# Lab5 (аудит F02): проверка JPEG в подпроцессе — лимит его адресного пространства (MiB),
# CPU-времени (с) и общего времени (с). Progressive JPEG 40 Мпикс 4:4:4 требует ~250 MiB.
JPEG_PROBE_MEMORY_MB=384
JPEG_PROBE_CPU_SECONDS=10
JPEG_PROBE_TIMEOUT_SECONDS=15
# Одновременных S3 PUT на реплику (~20 MiB RAM каждый), остальные ждут в очереди.
S3_PUT_CONCURRENCY=3
S3_CONNECT_TIMEOUT_SECONDS=2
# < timeout server 10s у LB: на зависший S3 API сам отвечает 503, а не LB 504.
S3_READ_TIMEOUT_SECONDS=5
# Janitor: возраст, после которого pending-строка/объект без строки считаются брошенными, и период обхода.
ATTACHMENT_GRACE_SECONDS=3600
JANITOR_INTERVAL_SECONDS=300
# Только для эксперимента отказов (student-tests/consistency_faults.py). В обычной работе 0.
FAULT_INJECTION=0
# --- Lab5: брокер, worker, задания ---
# Брокер RabbitMQ 4.1 (service broker). URL с паролем — в secrets/broker_<relay|worker|ops>_url,
# у каждого сервиса свой пользователь; здесь только путь (переопределяется в compose по сервису).
BROKER_URL_FILE=/run/secrets/broker_worker_url
# Реплик worker и потоков-потребителей в каждой (prefetch 1 на поток).
WORKER_REPLICAS=2
WORKER_CONCURRENCY=2
WORKER_PREFETCH=1
# Попыток на задание; таймаут одной обработки (с); аренда и её продление (heartbeat = lease/3).
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
JOB_LEASE_SECONDS=30
# Backoff между попытками: min(MAX, BASE*2^(n-1)), равномерно в [d/2, d] (equal jitter).
JOB_RETRY_BASE_SECONDS=2
JOB_RETRY_MAX_SECONDS=60
PIPELINE_VERSION=1
# Лимиты подпроцесса преобразования: адресное пространство (MiB) и CPU-время (с).
TRANSFORM_MEMORY_LIMIT_MB=768
TRANSFORM_CPU_SECONDS=30
# Сколько хранить staging failed-заданий (для replay), с.
STAGING_RETENTION_SECONDS=86400
# Relay: опрос outbox без NOTIFY (с), период reaper (с), повторная публикация «застрявших» queued (с).
RELAY_POLL_SECONDS=1
REAPER_INTERVAL_SECONDS=5
JOB_REDRIVE_AFTER_SECONDS=900
OUTBOX_RETENTION_SECONDS=86400
# Только для экспериментов отказов. В обычной работе пусто/0.
RELAY_FAULT=
WORKER_FAULT_INJECTION=0
# Длительность «долгой» обработки для fault-slow.png (только при WORKER_FAULT_INJECTION=1), с.
FAULT_SLOW_SECONDS=20
# --- Lab6: наблюдаемость (OpenTelemetry -> Collector -> Prometheus / Loki / Tempo -> Grafana) ---
# service.name задаётся в compose на сервис: messenger-api, messenger-worker, messenger-relay,
# messenger-janitor (OTEL_SERVICE_NAME из skeleton здесь — значение по умолчанию для API).
OTEL_SERVICE_NAME=messenger-api
# Worker must set a distinct service.name.
OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
# Справочно: в compose задано жёстко deployment.environment.name=${APP_ENV} (см. REPORT.md).
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
# true — полностью выключить экспорт телеметрии (no-op SDK), JSON-логи в stdout остаются.
OTEL_SDK_DISABLED=false
# Сэмплирование трасс (parentbased_always_on | parentbased_traceidratio + ARG).
OTEL_TRACES_SAMPLER=parentbased_always_on
OTEL_TRACES_SAMPLER_ARG=1.0
# Период экспорта метрик (мс), таймаут одного экспорта (с), лимиты очередей SDK (spans / log records).
OTEL_METRIC_EXPORT_INTERVAL=10000
OTEL_EXPORTER_OTLP_TIMEOUT_SECONDS=5
OTEL_BSP_MAX_QUEUE_SIZE=2048
OTEL_BLRP_MAX_QUEUE_SIZE=2048
# Собственные метрики SDK о потерях/ошибках экспорта (otel_sdk_*).
OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED=true
# Длительность учебной точки X-Fault-Inject: slow-handler (только при FAULT_INJECTION=1), с.
FAULT_SLOW_HANDLER_SECONDS=1.5
# Grafana только на 127.0.0.1; пароль admin — secrets/grafana_admin_password (init-secrets.sh).
GRAFANA_PORT=3000
+14 -14
View File
@@ -1,18 +1,18 @@
## Лабораторная 6
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Лазарев Юрий Сергеевич, БПИ2303
Целевая оценка (3/4/5): 3
Трек 5, если заявлен: не заявлен
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: перенесена реализация lab5 (API ×2 за HAProxy, PostgreSQL, SeaweedFS S3, RabbitMQ, relay outbox, worker ×2, janitor) без изменения бизнес-API. Добавлены OpenTelemetry SDK в API/relay/worker/janitor (traces, metrics, logs по OTLP/HTTP), отдельный OTel Collector (memory_limiter, batch, ограниченные очереди и retry), Prometheus (метрики, alert rules), Loki (логи), Tempo (трассы), Grafana с provisioning datasources и dashboard; W3C trace context API → outbox → RabbitMQ → worker (parent-child, включая retry); SLI/SLO, 10 alert rules с unit-тестами и runbooks; разбор двух инцидентов и отказа telemetry backend.
Команды запуска из чистого clone: `./scripts/init-secrets.sh && ./scripts/check_rules.sh && docker compose --env-file .env up -d --build --wait && make check test` — подробно в REPORT.md «Запуск из чистого clone».
Результаты проверок и ссылка на REPORT.md: REPORT.md «Доказательства критериев»; stdout всех проверок — evidence/*.txt, агрегаты — evidence/*.json (полный прогон `LAB6_ONLY=1 ./student-tests/run_all.sh`).
Ограничения / известные ошибки: REPORT.md «Ограничения и следующие шаги» (один Docker-host; нет дисковой очереди Collector — потери телеметрии ограничены и считаются; Prometheus — единственная точка вычисления alerts).
Источники и использование ИИ: REPORT.md, шапка; код подготовлен с помощью ИИ-ассистента (Claude), запуск и проверки — автор.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+46
View File
@@ -0,0 +1,46 @@
# Проверка РЕАЛИЗАЦИИ (lab5 аудит F15, lab6 — телеметрия); contracts.yml проверяет только skeleton.
# Изолированный стенд Compose с одноразовыми секретами: сборка, готовность, публичный smoke,
# регрессии аудита, не требующие ручного вмешательства. Логи при ошибке, очистка всегда.
# Секреты CI не нужны: init-secrets.sh генерирует их на раннере. pull_request_target не используется.
# Ограничение: локально workflow не исполнялся (нет раннера); проверен синтаксис YAML.
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
app:
runs-on: ubuntu-latest
timeout-minutes: 40
env:
COMPOSE_PROJECT_NAME: mtusi-lab6-ci
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Secrets and config
run: ./scripts/init-secrets.sh && docker compose --env-file .env config --quiet
- name: Build and start
run: docker compose --env-file .env up -d --build --wait --wait-timeout 300
- name: Telemetry configs, alert rule unit tests, dashboard generator
run: ./scripts/check_rules.sh
- name: Public smoke (telemetry enabled)
run: make check test
- name: Lab6 signal correlation (request -> trace -> log, upload -> relay -> worker)
run: python3 student-tests/obs_correlation.py && python3 student-tests/dashboard_check.py
- name: Audit regressions (HTTP)
run: python3 student-tests/api_negative_lab5.py
- name: Variants and transform limits
run: |
docker compose --profile tools run --rm -T checks /app/student-tests/variants_check.py --base-url http://lb:8080
docker compose --profile tools run --rm -T checks /app/student-tests/transform_limits.py
- name: Worker outage and redelivery
run: python3 student-tests/worker_outage.py
- name: Outbox crash windows
run: python3 student-tests/outbox_gap.py
- name: Logs on failure
if: failure()
run: docker compose logs --no-color --tail 300
- name: Cleanup
if: always()
run: docker compose --profile tools down -v --remove-orphans
+38
View File
@@ -0,0 +1,38 @@
# Lab6: мессенджер на Python + PostgreSQL + S3 + RabbitMQ + OpenTelemetry SDK. Один образ для API-реплик, relay,
# worker, janitor, ops-CLI и job-ов migrate (схема), s3-init (bucket).
FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d
# MALLOC_ARENA_MAX=2: glibc не заводит арену на каждый поток ThreadingHTTPServer —
# освобождённые буферы upload возвращаются в общий пул, RSS не растёт с числом потоков.
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
MALLOC_ARENA_MAX=2 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
# Сначала зависимости (закреплённые версии) — слой кэшируется, пока не изменится requirements.txt.
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ /app/src/
COPY migrations/ /app/migrations/
# Временные файлы upload (безымянные O_TMPFILE): каталог в writable-слое контейнера.
# Рабочие файлы worker (staging-копия и результаты одного задания, удаляются после него).
RUN mkdir -p /tmp/uploads /tmp/work && chmod 1777 /tmp/uploads /tmp/work
ENV UPLOAD_TMP_DIR=/tmp/uploads
# Метка версии сборки (rolling update: scripts/rolling-update.sh собирает с новым значением).
ARG APP_VERSION=1
ENV APP_VERSION=${APP_VERSION}
RUN useradd --no-create-home --uid 10001 app
USER app
EXPOSE 8080
# Python-процесс — PID 1 (exec-форма), сам обрабатывает SIGTERM (graceful shutdown).
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=5s --timeout=2s --start-period=10s --retries=2 \
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
CMD ["python", "/app/src/server.py"]
+347 -15
View File
@@ -1,37 +1,369 @@
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Лазарев Юрий Сергеевич, БПИ2303
- Целевая оценка; выбранный трек 5, если нужен: **3**, трек 5 не заявлен (пункты уровня 4 тоже выполнены и задокументированы ниже)
- Commit/PR: [PR #35 — ЛР 6 — БПИ2303 — Лазарев — на 3](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab6/pulls/35); реализация `c199f66`, ветка `solution/bpi2303-lazarev`, fork [zemiles/mtusi2026lab6](https://gitea.privcloud.tech/zemiles/mtusi2026lab6).
- Использованные источники, библиотеки и помощь ИИ: всё из lab5 (Python 3.12, `psycopg[binary]==3.2.3`, `psycopg-pool==3.2.4`, `minio==7.2.20`, `urllib3==2.8.0`, `Pillow==13.0.0`, `pika==1.3.2`) и **OpenTelemetry Python** `opentelemetry-api/sdk==1.45.1`, `opentelemetry-exporter-otlp-proto-http==1.45.1`, `opentelemetry-semantic-conventions==0.66b1` (полный список транзитивных версий фактической сборки — [`evidence/pip-freeze.txt`](evidence/pip-freeze.txt)). Новые образы (полные digest — в `compose.yaml`): `otel/opentelemetry-collector-contrib:0.163.2@sha256:7f22d2a6…5849`, `prom/prometheus:v3.13.5@sha256:aafa9d69…72b9`, `grafana/loki:3.6.19@sha256:0f9cbc34…443a`, `grafana/tempo:2.10.10@sha256:12b0820f…5d38`, `grafana/grafana:12.4.14@sha256:ae509d9a…cd7`. Документация: OpenTelemetry (Collector configuration, memory_limiter, exporterhelper sending_queue/retry_on_failure, OTTL transform, context propagation, semantic conventions HTTP/DB/messaging, SDK self-observability `otel.sdk.*`), W3C Trace Context, Prometheus (OTLP receiver, histograms и `histogram_quantile`, recording/alerting rules, `promtool test rules`), Loki (OTLP ingestion, structured metadata), Tempo (TraceQL), Grafana provisioning (datasources, dashboards, derived fields, traces-to-logs). Код lab5 перенесён и доработан с помощью ИИ-ассистента (Claude); решения, запуск и проверки — автор.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Проверено: MacBook Air M3, 16 GB RAM, macOS 26.4.1; Docker Desktop 28.0.4 (VM 8 vCPU, 7.7 GiB), Compose v2.34.0; Python 3.12 на хосте только для тестов (стандартная библиотека). Порты `127.0.0.1:8080` (LB), `127.0.0.1:8404` (статистика HAProxy) и `127.0.0.1:3000` (Grafana) должны быть свободны — стенд lab5 остановить (`docker compose stop` в его каталоге).
```sh
# 0. Локальные секреты и .env (не коммитятся; значения не печатаются; повтор ничего не перезаписывает).
# Как в lab5 (БД, ключи S3, пользователи RabbitMQ) + lab6: secrets/grafana_admin_password.
./scripts/init-secrets.sh
# 1. Офлайн-проверка конфигов телеметрии теми же образами: promtool check config/rules,
# unit-тесты alert rules, otelcol validate, loki -verify-config, актуальность dashboard JSON.
./scripts/check_rules.sh
# 2. Сборка и запуск (~35 с до готовности всех 16 сервисов)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
# порядок: db, s3, broker (healthy) -> migrate, s3-init (exit 0) -> api x2, relay, worker x2, janitor -> lb;
# телеметрия стартует независимо: otel-collector, prometheus, loki, tempo -> grafana
docker compose ps # migrate и s3-init Exited (0); порты только у lb и grafana
# 3. Обязательные проверки (телеметрия включена)
make check && make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh # рестарт ВСЕХ хранилищ, в т.ч. prometheus/loki/tempo
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && ./scripts/start-all.sh
# 4. Проверки lab6 (каждая сама включает/выключает свои учебные отказы)
python3 student-tests/obs_correlation.py --retry --output evidence/obs-correlation.json # запрос->trace->лог, upload->relay->worker, retry
python3 student-tests/dashboard_check.py --output evidence/dashboard-check.json # все запросы dashboard на реальных данных
python3 student-tests/telemetry_persistence.py --output evidence/telemetry-persistence.json
python3 student-tests/incident_worker_stop.py --output evidence/incident-worker-stop.json # инцидент 1
python3 student-tests/incident_db_slow.py --output evidence/incident-db-slow.json # инцидент 2
python3 student-tests/telemetry_outage.py --output evidence/telemetry-outage.json # отказ backend/Collector
# Всё сразу с записью stdout в evidence/*.txt (.venv для make validate создаётся сам):
LAB6_ONLY=1 ./student-tests/run_all.sh # ≈ 30 мин: обязательное + lab6 + сценарий lab5 уровня 3 + load
./student-tests/run_all.sh # + регрессии lab5 (≈ 50 мин)
# 5. Grafana: http://127.0.0.1:3000, пользователь admin, пароль — в secrets/grafana_admin_password.
# Dashboard «Messenger — наблюдаемость (lab6)» (папка Messenger) — домашний, импортирован provisioning.
# Explore: Tempo (TraceQL), Loki (LogQL), Prometheus (PromQL); Alerting -> Alert rules (data source-managed).
# 6. Безопасная остановка (данные и история телеметрии остаются в volumes)
docker compose stop # или docker compose down (контейнеры удаляются, volumes остаются)
# 7. Намеренное удаление учебных данных и истории телеметрии (НЕОБРАТИМО)
docker compose down -v
```
Bootstrap и повторяемость. Как в lab5: миграции (`migrate`, учёт в `schema_migrations`), bucket (`s3-init`), топология брокера (definitions) создаются автоматически и безопасно повторяются. Новое в lab6 не требует ручных действий: datasources и dashboard Grafana — provisioning из `infra/grafana/` (UI-правки не сохраняются, `allowUiUpdates: false`), alert rules Prometheus — `infra/prometheus/rules/`, схемы хранения Loki/Tempo создаются при первом старте на пустых volumes. Dashboard JSON генерируется воспроизводимо: `python3 scripts/build_dashboard.py` (проверку «JSON = генератор» делает `check_rules.sh`).
Замечание оператору (Docker Desktop на macOS). При запуске из неинтерактивной среды `docker pull` зависал без вывода на обращении к хелперу keychain (`credsStore: desktop`). Обход без изменения пользовательских настроек: отдельный `DOCKER_CONFIG` без `credsStore` (каталог с `config.json` = `{}` и ссылкой `cli-plugins` на `~/.docker/cli-plugins`) и `DOCKER_HOST=unix://$HOME/.docker/run/docker.sock`. Публичные образы скачиваются анонимно.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
┌───────────────────────── сеть backend (internal) ─────────────────────────┐
клиент ─HTTP─> lb ─> api × 2 ──> db (PostgreSQL) <── relay ──> broker (RabbitMQ) ──> worker × 2 ──> s3
│ │ outbox.payload.traceparent ─┘ AMQP headers traceparent ─┘
│ │ │ │
└───────┴──────────── OTLP/HTTP :4318 ────────────┴───────────────────────┘
│ (сеть telemetry, internal)
otel-collector ── memory_limiter → resource → transform/scrub → batch
│ │ │
OTLP gRPC│ OTLP/HTTP│ OTLP/HTTP│ scrape: collector :8888, lb :8404/metrics,
▼ ▼ ▼ broker :15692, loki, tempo
tempo loki prometheus ◄── alert rules (firing/resolved локально)
(traces) (logs) (metrics)
└──────────┴──────────┴──> grafana (127.0.0.1:3000, provisioning)
```
| Роль | Service | Образ | Health/readiness | Volume | Сеть / порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| LB | `lb` | `haproxy:3.0.5-alpine` | проверка конфигурации; сам проверяет `/health/ready` API | — | frontend+backend+telemetry; `127.0.0.1:8080`, `:8404` (stats, `/metrics`) | нет |
| API | `api` ×2 | `mtusi-messenger:lab6` | `/health/live`, `/health/ready` (БД) | — | backend+telemetry | `postgres_password`, `s3_api_*`; брокера нет |
| Relay | `relay` | тот же | heartbeat-файл | — | backend+telemetry | `postgres_password`, `broker_relay_url` |
| Worker | `worker` ×2 | тот же | heartbeat-файл | — | backend+telemetry | `postgres_password`, `broker_worker_url`, `s3_worker_*` |
| Janitor | `janitor` | тот же | heartbeat-файл | — | backend+telemetry | `postgres_password`, `s3_janitor_*` |
| БД / S3 / брокер | `db`, `s3`, `broker` | как в lab5 | как в lab5 | `pgdata`, `s3data`, `brokerdata` | backend (broker ещё telemetry для `:15692`) | как в lab5 |
| **OTel Collector** | `otel-collector` | `otel/opentelemetry-collector-contrib:0.163.2` | нет (distroless, без shell); `up{job="otel-collector"}` | — (буфер только в памяти) | telemetry; 4318/4317/8888/13133 внутри | нет |
| **Метрики** | `prometheus` | `prom/prometheus:v3.13.5` | `/-/ready` | `promdata` (15 дней / 2 GB) | telemetry; 9090 внутри | нет |
| **Логи** | `loki` | `grafana/loki:3.6.19` | нет (distroless); `up{job="loki"}`, `/ready` | `lokidata` (WAL + chunks, 7 дней) | telemetry; 3100 внутри | нет |
| **Трассы** | `tempo` | `grafana/tempo:2.10.10` | нет (distroless); `up{job="tempo"}`, `/ready` | `tempodata` (WAL + блоки, 7 дней) | telemetry; 3200/4317 внутри | нет |
| **UI** | `grafana` | `grafana/grafana:12.4.14` | `/api/health` | `grafanadata` | telemetry + grafana-ui; `127.0.0.1:3000` | `grafana_admin_password` (secret, `GF_SECURITY_ADMIN_PASSWORD__FILE`) |
**Назначение каждого хранилища** (Grafana сама сигналы не хранит, Collector — тоже):
- **Prometheus — метрики**: числовые временные ряды с низкокардинальными labels. Отвечает на вопросы «сколько / как часто / насколько медленно / насколько заполнено»: RPS, доля 5xx, p50/p95/p99 из histogram, глубина и возраст очереди, пул БД, загрузка worker, CPU/RAM. Вычисляет recording/alert rules (firing/resolved). Приём: OTLP push от Collector (`--web.enable-otlp-receiver`) + scrape экспортёров инфраструктуры. Exemplars (`--enable-feature=exemplar-storage`) связывают точки гистограмм с trace_id.
- **Loki — логи**: события с текстом и атрибутами. Индексирует только labels потока (`service_name`, `service_instance_id`, `deployment_environment_name`), остальные атрибуты (`event`, `request_id`, `trace_id`, `span_id`, `http_route`, `job_id`, `error_type`…) — structured metadata: фильтруются, но не раздувают индекс. Отвечает «что именно произошло» для конкретного запроса/задания.
- **Tempo — трассы**: деревья spans по trace_id (хранение по trace_id в блоках, поиск TraceQL). Отвечает «где именно потрачено время / возникла ошибка» внутри запроса и через границу процессов (API → outbox → relay → RabbitMQ → worker → S3/DB).
- **OTel Collector** — получатель/обработчик/экспортёр: приём OTLP, ограничение памяти, защитная чистка атрибутов, батчи, ограниченная очередь и retry к каждому backend. Не долговременное хранилище.
- **Grafana** — интерфейс и запросы к трём источникам, связи между ними (лог → trace, span → логи, метрика-exemplar → trace).
Сети: телеметрия живёт в отдельной internal-сети `telemetry`; Grafana не имеет доступа к БД/S3/брокеру, наружу опубликована только на `127.0.0.1:3000` (сеть `grafana-ui`). OTLP, Prometheus, Loki, Tempo на хост не публикуются. Приложения не зависят от Collector в `depends_on`: недоступная телеметрия не мешает старту.
### Что перенесено из lab5 и что изменено
Перенесены без изменения бизнес-логики: `src/` (API, relay, worker, janitor, ops, transform, миграции 001–004), `Dockerfile`, `compose.yaml`, конфиги HAProxy и RabbitMQ, `scripts/`, `student-tests/` lab5, CI `app.yml`. Бизнес-API и контракт не менялись (OpenAPI lab6 отличается от lab5 только версией).
Изменения lab6:
- `src/telemetry.py` — настройка OTel SDK (traces/metrics/logs, Resource, Views с границами buckets, ограниченные очереди, общий срок `shutdown`), структурный JSON-лог с trace_id/span_id, редакция секретов, обёртки `db_operation`/`child_span`, метрики пула, CPU/RAM контейнера из cgroup, W3C inject/extract.
- `server.py` — SERVER span на запрос (`<METHOD> <шаблон маршрута>`), метрики `http.server.*`, лог `event=http.request`, заголовок `X-Trace-Id` (дополнительный, обратно совместимый), `error.type` для 5xx, spans для scrypt/приёма тела/проверки изображения, учебная точка `slow-handler`. Health-проверки HAProxy (2 в секунду) — в метриках, но без trace и INFO-лога (шум). `handle_error` сервера: штатный сброс keep-alive соединения балансировщиком больше не печатает traceback в stderr (в логах lab5 их были сотни).
- `store.py` — `InstrumentedPool` (время ожидания соединения) и `@db_operation` на каждую операцию; `objstore.py` — spans/гистограмма S3; `jobs.py` — PRODUCER span `create` и traceparent в outbox, время до ready/terminal из БД, задержка в очереди при claim; `relay.py` — PRODUCER span `send` + traceparent в теле и AMQP headers, метрики публикации и gauges очереди по PostgreSQL; `worker.py` — CONSUMER span `process` с дочерними spans, метрики заданий, загрузки и time to ready; `ops.py inspect` показывает traceparent outbox.
- Инфраструктура: `infra/otel/collector.yaml`, `infra/prometheus/{prometheus.yml,rules,tests}`, `infra/loki/loki.yaml`, `infra/tempo/tempo.yaml`, `infra/grafana/{provisioning,dashboards}`, `infra/runbooks/README.md`; HAProxy — встроенный Prometheus-экспортёр на `:8404/metrics`; `scripts/restart.sh` перезапускает и хранилища телеметрии; `scripts/check_rules.sh`, `scripts/build_dashboard.py`.
### Схема сигналов (соответствие `contracts/observability.md`)
Имена метрик — native OTel semantic conventions там, где они есть; в Prometheus они переводятся стандартной схемой OTLP-приёма (точки → `_`, единица `s` → `_seconds`, `By` → `_bytes`, монотонный счётчик → `_total`). Атрибуты метрик — только перечисленные (никаких ID, URL, filename, текста).
| Логический сигнал | Инструмент OTel → имя в Prometheus | Тип, единица | Атрибуты (labels) | Кто пишет |
| --- | --- | --- | --- | --- |
| HTTP requests (счётчик) | `http.server.request.duration` → `http_server_request_duration_seconds_count` | счётчик histogram, запросы | `http_request_method`, `http_route` (шаблон), `http_response_status_code`, `http_response_status_class`, `error_type` (только 5xx) | API |
| HTTP duration | то же → `http_server_request_duration_seconds_bucket` | histogram, **секунды**; buckets 2 мс…60 с (вкл. 3.5 и 5.5 с у таймаутов) | те же | API |
| HTTP in-flight | `http.server.active_requests` → `http_server_active_requests` | UpDownCounter, запросы | `http_request_method` | API |
| Jobs processed / failed | `messenger.jobs.processed` → `messenger_jobs_processed_total` | counter, задания | `messenger_job_type`, `messenger_job_outcome` (ready, retry, failed, duplicate, lease_lost, rejected, requeued, crashed), `error_type` (код ошибки задания) | worker |
| Job processing duration | `messenger.job.duration` → `messenger_job_duration_seconds_*` | histogram, с (claim → итог попытки) | `messenger_job_type`, `messenger_job_outcome` | worker |
| API и worker logs | OTel Logs → Loki (+ JSON stdout) | — | timestamp, severity, `service.name`, `event`, `trace_id`, `span_id` при активном span, `request_id`/`job_id`… | все процессы |
| API и worker traces | SERVER / CONSUMER / PRODUCER / CLIENT spans → Tempo | duration, status, `error.type`, `messenger.job.outcome` | — | все процессы |
| Queue depth | `messenger.jobs.count` → `messenger_jobs_count` (БД); `rabbitmq_detailed_queue_messages_ready/unacked` (брокер); `messenger.outbox.pending` | gauge, задания/сообщения | `messenger_job_status`; `queue` | relay (по PostgreSQL), RabbitMQ |
| Oldest job age | `messenger.jobs.oldest_age` → `messenger_jobs_oldest_age_seconds`; `messenger.jobs.ready_lag` → `messenger_jobs_ready_lag_seconds`; `messenger.outbox.oldest_age` | gauge, **секунды** | `messenger_job_status` | relay |
| DB pool | `db.client.connection.count{state=used|idle}`, `db.client.connection.max`, `db.client.connection.pending_requests`, `db.client.connection.timeouts`, `db.client.connection.wait_time` | gauge/counter, соединения/запросы; histogram, с | `db_client_connection_pool_name`, `db_client_connection_state` | API, janitor |
| DB operation duration | `db.client.operation.duration` → `db_client_operation_duration_seconds_*` | histogram, с | `db_system_name`, `db_operation_name`, `error_type` | API, worker, relay |
| Worker busy / capacity | `messenger.worker.busy`, `messenger.worker.capacity`, `messenger.worker.busy_time` → `messenger_worker_busy_time_seconds_total` | gauge, потоки; counter, с (utilization = rate / capacity) | — | worker |
| CPU/RAM процесса/контейнера | `container.cpu.time` → `container_cpu_time_seconds_total`, `container.cpu.limit`, `container.memory.usage`/`.limit` → `container_memory_*_bytes`, `process.memory.usage` | cgroup v2 своего контейнера (вкл. подпроцессы transform/проб JPEG) | — | все процессы приложения |
| CPU/RAM telemetry-стека | `process_resident_memory_bytes`, `process_cpu_seconds_total` (Prometheus, Loki, Tempo), `otelcol_process_memory_rss`, `otelcol_process_runtime_heap_alloc_bytes`, `rabbitmq_process_resident_memory_bytes` | gauge, байты / counter, с | `job` | scrape |
| Сквозная связь upload → publish → consume → S3/DB | W3C `traceparent`/`tracestate`: outbox payload → тело и AMQP headers сообщения | parent-child (см. ниже) | — | API → relay → worker |
| End-to-end time to ready | `messenger.attachment.time_to_ready` → `messenger_attachment_time_to_ready_seconds_*` | histogram, с; от COMMIT enqueue (`jobs.created_at`) до COMMIT ready, время БД | `messenger_job_type`, `outcome` (ready / failed) | worker |
| Задержка очереди и публикации | `messenger.job.queue_wait` (next_attempt_at → claim), `messenger.outbox.publish_delay` (available_at → confirm), `messenger.outbox.published{outcome}` | histogram, с; counter | — | worker, relay |
| S3 | `messenger.s3.operation.duration` → `messenger_s3_operation_duration_seconds_*` | histogram, с | `messenger_s3_operation`, `outcome` | API, worker, janitor |
| Потери телеметрии | SDK: `otel_sdk_processor_{span,log}_processed_total{error_type}`, `otel_sdk_exporter_{span,log}_exported_total{error_type}`, `otel_sdk_processor_span_queue_size/capacity`; Collector: `otelcol_exporter_send_failed_*`, `otelcol_exporter_enqueue_failed_*`, `otelcol_exporter_queue_size/capacity`, `otelcol_receiver_refused_*` | counter/gauge | `error_type`, `exporter` | SDK, Collector |
Resource attributes: `service.name` = `messenger-api` / `messenger-worker` / `messenger-relay` / `messenger-janitor` (в Prometheus — label `job`), `service.version` = `APP_VERSION` образа, `service.instance.id` = hostname контейнера = `X-Instance-Id` (label `instance`), `deployment.environment.name=lab`. `X-Request-Id` по-прежнему коррелирует HTTP-ошибку с логом; `X-Trace-Id` (новый заголовок) — с трассой.
Метрики Collector 0.163 публикуются без суффикса `_total` (например `otelcol_exporter_sent_spans`); в rules и dashboard для них используется `{__name__=~"otelcol_…(_total)?"}`, чтобы не зависеть от версии.
### Трассы: перенос контекста через очередь
```
API POST /api/v1/chats/{chat_id}/attachments (SERVER, root)
http.receive_body · image.validate · db create_pending_attachment · s3 PutObject (staging)
db enqueue_attachment
db jobs.enqueue
attachment.process.v1 create (PRODUCER) ── traceparent → outbox.payload (COMMIT вместе с job)
relay attachments send (PRODUCER, parent = create) ── traceparent → тело + AMQP headers, publisher confirm
worker attachments.process.v1 process (CONSUMER, parent = send)
db jobs.claim · worker.fetch_staging (s3 GetObject) · worker.transform · s3 PutObject ×4
db jobs.heartbeat · db jobs.complete · s3 DeleteObject (staging)
retry: db jobs.fail_or_retry → attachment.process.v1 create (PRODUCER, worker)
→ attachments send (relay) → attachments.process.v1 process (2-я попытка)
```
Выбрана семантика **parent-child** (а не link): у сообщения ровно один «создатель», и upload, все попытки и их результат удобно видеть одним деревом. Разрыв во времени между `send` и `process` в трассе и есть ожидание в очереди (в инциденте 1 — 120 с). Фоновые переходы без трассы (reaper истёкших аренд, redrive, replay оператора) берут traceparent последней строки outbox этого job — цепочка не рвётся. Внешний `traceparent` от клиента API не принимает (новый root на каждый запрос): публичная точка входа не должна позволять клиенту подменять trace_id или выключать сэмплирование флагом. Сэмплер — `parentbased_always_on` (100 % на учебной нагрузке; `OTEL_TRACES_SAMPLER/ARG` меняют его без пересборки).
### Логи
Каждая запись — JSON в stdout (`docker compose logs`) и OTLP-запись в Loki с одинаковыми полями: `timestamp`, `severity`, `service.name`, `service.instance.id`, `event` (стабильное имя: `http.request`, `db.unavailable`, `job.claimed`, `job.completed`, `job.retry_scheduled`, `job.failed`, `worker.started/draining/stopped`, `outbox.published`, `broker.unavailable`, `fault.injected`, …), `trace_id`/`span_id` (из активного span), технические атрибуты (`request_id`, `http.route`, `http.response.status_code`, `duration_ms`, `error.type`, `job_id`, `attachment_id`, `attempt`). В Loki: `{service_name="messenger-api"} | event="http.request" | request_id="<X-Request-Id>"`, у записи — ссылка «Trace в Tempo» (derived field по structured metadata `trace_id`). Логи самого OTel SDK в OTLP не отправляются (иначе ошибки экспорта при недоступном Collector порождали бы новые записи в той же очереди), только в stdout.
### Что не попадает в телеметрию
Пароли, `Authorization`, session token, тела сообщений, байты и имена файлов (filename — только в query, query не логируется и не пишется в spans), signed URL, credentials брокера/S3. Меры: код их не пишет (`url.path`/query не записываются, только шаблон маршрута; в S3 spans — server-assigned ключ объекта без filename); `telemetry.redact()` вычищает `Bearer/Basic …`, `token=`, `password=`, `user:pass@` из текста логов; в Collector `transform/scrub` удаляет атрибуты `*password*|*secret*|*token*|*authorization*`, `url.query`, `http.request.header.*`. Технические ID синтетических данных (`request_id`, `job_id`, `attachment_id`) есть в логах и spans — они нужны для связи upload ↔ job и ответа клиенту ↔ лог; в labels метрик их нет. Проверка: `obs_correlation.py` ищет в Loki (`|= …`) и в JSON трасс пароль, токен, текст сообщения и уникальный filename — 0 вхождений; у метрик `job=~"messenger-.+"` нет labels `user_id/chat_id/message_id/attachment_id/request_id/job_id/url/filename/text` и нет значений-UUID.
### Collector: ограниченная буферизация
| Механизм | Настройка | Поведение при недоступном backend |
| --- | --- | --- |
| `memory_limiter` (первый процессор) | `limit_mib 190`, `spike_limit_mib 40`, check 1 s; `GOMEMLIMIT=200MiB`; лимит контейнера 256 MiB | выше мягкого предела (150 MiB) receiver отвечает ошибкой, SDK отбрасывает/повторяет — нет OOM |
| `batch` | 512…1024 записей или 1 s | — |
| `sending_queue` у каждого экспортёра | в памяти, `queue_size` 100 батчей (traces, logs) / 50 (metrics), 2 consumers | заполняется до capacity, дальше `sending queue is full` → `otelcol_exporter_enqueue_failed_*` |
| `retry_on_failure` | 1 s → 10 s, `max_elapsed_time 60 s` | дольше 60 s → `Dropping data` → `otelcol_exporter_send_failed_*` |
| SDK приложения | `BatchSpanProcessor`/`BatchLogRecordProcessor` `max_queue_size 2048`, экспорт 5 s таймаут, общий `shutdown` 3 s | Collector недоступен → батч отбрасывается после ошибки экспорта (`otel_sdk_exporter_*_exported{error_type="ConnectionError"}`), при переполнении очереди — `queue_full`; бизнес-поток не ждёт |
Устойчивой (дисковой) очереди Collector нет намеренно: телеметрия — не источник истины, а неограниченный буфер опаснее потерь; потери считаются и видны на dashboard и в alert `MessengerTelemetryExportFailing`.
### SLI/SLO и alert rules
SLI считаются по бизнес-запросам API: все маршруты, кроме `/health/*` и `unmatched`. Числитель ошибок — только **5xx** (отказ сервера); 4xx (неверный пароль, 404, 409, 413) — корректные ответы на ошибку клиента и бюджет не расходуют.
| SLI | Формула (PromQL) | SLO, окно |
| --- | --- | --- |
| Доступность | `1 - sum(increase(…_count{5xx}[7d])) / sum(increase(…_count[7d]))` → `messenger:slo_availability:ratio_7d` | 99.5 %, скользящие 7 дней; бюджет 0.5 % (`messenger:slo_availability:error_budget_remaining_7d`) |
| Задержка | доля запросов ≤ 0.5 s (bucket `le="0.5"`), без upload, регистрации и входа (scrypt по замыслу) → `messenger:slo_latency:ratio_7d` | 99 %, 7 дней |
| Time to ready | доля вложений ready ≤ 30 s после COMMIT enqueue (bucket `le="30"`) → `messenger:slo_time_to_ready:ratio_7d` | 99 %, 7 дней |
| Alert | Условие | Окно / порог / for | Проверен |
| --- | --- | --- | --- |
| `MessengerHighErrorRate{source=api}` | доля 5xx API > 5 % и > 0.1 rps | rate 2m, `for: 1m` | promtool + инцидент 2 |
| `MessengerHighErrorRate{source=lb}` | доля 5xx на HAProxy `fe_api` > 5 % (нет ready-реплик — до API не доходит) | rate 2m, `for: 1m` | инцидент 2 |
| `MessengerQueueLagGrowing` | `max(messenger_jobs_ready_lag_seconds) > 30` и `deriv(...[2m:15s]) >= 0` | `for: 1m` | promtool + инцидент 1 |
| `MessengerOutboxStuck` | старейший неопубликованный outbox > 30 s | `for: 1m` | — |
| `MessengerWorkerSaturated` | utilization worker > 90 % | rate 2m, `for: 5m` | — |
| `MessengerDbSlow` | p95 `db.client.operation.duration` API > 250 ms | rate 2m, `for: 1m` | promtool + инцидент 2 |
| `MessengerDbPoolSaturated` | среднее ожидающих соединение > 1 | avg 1m, `for: 1m` | — |
| `MessengerApiLatencyHigh` | p95 бизнес-запросов > 1 s | rate 5m, `for: 2m` | инцидент 2 (pending) |
| `MessengerTelemetryExportFailing` | рост send_failed/enqueue_failed Collector | rate 2m, `for: 1m` | отказ telemetry |
| `MessengerTelemetryBackendDown` | `up{job=~"otel-collector|loki|tempo"} == 0` | `for: 1m` | отказ telemetry |
У каждого alert — `summary`, `description`, `runbook_url` → [`infra/runbooks/README.md`](infra/runbooks/README.md) (условие, смысл, шаги диагностики метрика → трасса → лог, действия). Unit-тесты: [`infra/prometheus/tests/messenger.test.yml`](infra/prometheus/tests/messenger.test.yml) — для ошибок, lag и медленной БД проверяется отсутствие alert до отказа, firing с точными labels/annotations и resolved после восстановления; 5xx на `/health/ready` alert не поднимают.
### Dashboard
[`infra/grafana/dashboards/messenger.json`](infra/grafana/dashboards/messenger.json) (uid `messenger-overview`, 56 панелей; импортируется provisioning, генератор `scripts/build_dashboard.py`). Ключевые запросы и единицы:
| Панель | Запрос | Единица |
| --- | --- | --- |
| RPS по маршруту | `sum by (http_route) (rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m]))` | запросы/с |
| Доля 5xx: API и LB | `messenger:http_error_ratio:rate2m`, `messenger:lb_error_ratio:rate2m` | доля (0–1) |
| Задержка API p50/p95/p99 | `histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{…}[1m])))` + exemplars | секунды |
| Задания по исходу | `sum by (messenger_job_outcome) (increase(messenger_jobs_processed_total[1m]))` | задания/мин |
| Длительность job / time to ready p50/p95/p99 | `histogram_quantile(q, sum by (le) (rate(messenger_job_duration_seconds_bucket{…}[5m])))`, то же для `messenger_attachment_time_to_ready_seconds_bucket` | секунды |
| Глубина очереди | `messenger_jobs_count{status=~"queued|processing"}`, `messenger_outbox_pending`, `rabbitmq_detailed_queue_messages_ready/unacked`, DLQ | задания/сообщения |
| Возраст старейшего задания | `messenger_jobs_oldest_age_seconds`, `messenger_jobs_ready_lag_seconds`, `messenger_outbox_oldest_age_seconds` | секунды |
| Saturation worker | `sum(rate(messenger_worker_busy_time_seconds_total[1m])) / sum(messenger_worker_capacity)` | доля |
| Пул БД | `db_client_connection_count{state}`, `db_client_connection_max`, `db_client_connection_pending_requests`, p95 `db_client_connection_wait_time_seconds` | соединения / запросы / с |
| Операции БД p95 | `histogram_quantile(0.95, sum by (le, db_operation_name) (rate(db_client_operation_duration_seconds_bucket[1m])))` | секунды |
| CPU / RAM контейнеров | `rate(container_cpu_time_seconds_total[1m])` (/ `container_cpu_limit`), `container_memory_usage_bytes` (/ `container_memory_limit_bytes`) | ядра, доля, байты |
| Конвейер телеметрии | принято/отправлено/потеряно Collector, очередь экспортёров, потери SDK | записи/с, батчи |
| Логи и трассы | Loki WARN/ERROR, HTTP 5xx; Tempo: трассы заданий, медленные > 1 s, с ошибкой | — |
Перцентили считаются только из histogram и только после суммирования buckets всех реплик (`sum by (le)`), не из средних и не усреднением p95 реплик.
### Соответствие `.env.example`
| Переменная skeleton | Реализация |
| --- | --- |
| всё до `STAGING_RETENTION_SECONDS` | как в lab5 (см. `.env.example`: `POSTGRES_*` + `POSTGRES_PASSWORD_FILE`, `BROKER_URL_FILE` на сервис, `S3_ENDPOINT=http://s3:8333` …) |
| `OTEL_SERVICE_NAME=messenger-api` | значение по умолчанию; в compose задаётся на сервис: `messenger-api`, `messenger-worker`, `messenger-relay`, `messenger-janitor` |
| `OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318`, `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` | как есть (OTLP/HTTP protobuf, стандартные переменные SDK) |
| `OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab` | в compose задано **жёстко** `deployment.environment.name=${APP_ENV}`: Docker CLI сам передаёт compose-плагину `OTEL_RESOURCE_ATTRIBUTES=docker.cli.cobra.command_path=…`, и при интерполяции из окружения этот атрибут попадал в `target_info` всех сервисов |
| добавлены | `OTEL_SDK_DISABLED` (выключить экспорт), `OTEL_TRACES_SAMPLER(_ARG)`, `OTEL_METRIC_EXPORT_INTERVAL`, `OTEL_EXPORTER_OTLP_TIMEOUT_SECONDS`, `OTEL_BSP_MAX_QUEUE_SIZE`, `OTEL_BLRP_MAX_QUEUE_SIZE`, `OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED` (метрики потерь SDK), `OTEL_TRACE_HEALTH` (по умолчанию 0), `FAULT_SLOW_HANDLER_SECONDS` (учебная точка, только при `FAULT_INJECTION=1`), `GRAFANA_PORT` |
## Доказательства критериев
Прогон 14.11.2026 на стенде из раздела «Запуск» (лимиты контейнеров — `compose.yaml`), командой `LAB6_ONLY=1 ./student-tests/run_all.sh`: 12/14 с первого раза; `dashboard-check` и `telemetry-outage` упали из‑за ошибок **самих проверок** (нет прогрева перед запросами `rate(...[1m])` сразу после пересоздания worker; потери SDK считались через `increase()` по ряду, который появляется только после возврата Collector) — проверки исправлены и перезапущены, их stdout в `evidence/*.txt` — от повторного прогона. Первая строка каждого `*.txt` — UTC-время и команда, последняя — `exit=`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke при включённой телеметрии | `make check`, `make validate`, `make test` | PASS (lab6 профиль: 202 → ready, thumbnail JPEG) | `evidence/check.txt`, `validate.txt`, `smoke.txt` |
| 3: минимум lab5 сохранён | `make test-persistence`, `make test-failover`, `worker_outage.py` | PASS; рестарт всех 16 сервисов (`StartedAt` в `containers-*`); failover: 130 записей, 0 ошибок, восстановление 4.4 с; worker остановлен → 202 → рестарт API и брокера → ready, повторная доставка — no-op | `persistence.txt`, `containers-{before,after}-restart.txt`, `failover.txt`, `worker-outage.*` |
| 3: Collector, три хранилища и Grafana в общем стенде; конфиги и provisioning в Git | `compose.yaml`, `infra/*`; `scripts/check_rules.sh` | promtool config/rules SUCCESS, unit-тесты alerts SUCCESS, `otelcol validate` OK, `loki -verify-config` OK, dashboard = генератор; все scrape-цели `up` | `telemetry-config.txt` |
| 3: persistent volumes сохраняют историю | `telemetry_persistence.py` (через `scripts/restart.sh` — рестарт db, s3, broker, prometheus, loki, tempo, collector, api, …) | после рестарта тот же trace (4 spans), тот же лог по request_id и **то же историческое значение** счётчика в момент t1 (12385); dashboard provisioned | `telemetry-persistence.*` |
| 3: API и worker отдают OTLP; RPS/errors/duration API, jobs ok/failed и duration worker | `dashboard_check.py` | dashboard `messenger-overview` provisioned (папка Messenger), datasources Prometheus/Loki/Tempo health OK, 56 панелей — 0 ошибок запросов, все ключевые — с данными | `dashboard-check.*` |
| 3: импортируемый dashboard | `infra/grafana/dashboards/messenger.json` + provisioning | импортируется при старте, `allowUiUpdates: false` | `dashboard-check.json` |
| 3: структурные логи с trace_id/span_id, низкокардинальные атрибуты | `obs_correlation.py` | лог `event=http.request` найден в Loki по `request_id`, его `trace_id`/`span_id` = SERVER span ответа (`X-Trace-Id`); labels метрик — только перечисленные в схеме, ни одного значения-UUID | `obs-correlation.json` |
| 3: контролируемый запрос → trace и лог; job → worker trace и лог | `obs_correlation.py` | сообщение: trace из 4 spans (`db get_session_user`, `get_chat_for`, `add_message`); upload: лог worker `job.claimed`, `job.completed` с тем же trace_id и `job_id` | `obs-correlation.json`, `obs-correlation.trees.txt` |
| 3: секреты, тела, изображения не в telemetry | `obs_correlation.py` | пароль, токен, текст сообщения, уникальный filename: 0 вхождений в Loki и в JSON трасс; `scripts/scan_secrets.py`: значения `secrets/` ни в одном файле репозитория | `obs-correlation.json` |
| 3: объяснено назначение каждого хранилища | REPORT «Архитектура» | — | — |
| 4: W3C trace context API → broker → worker, producer/consumer, цепочка до S3/DB включая retry | `obs_correlation.py --retry` | одна трасса из 26 spans трёх сервисов: `create` (PRODUCER, API) → `send` (PRODUCER, relay, parent = create) → `process` (CONSUMER, worker, parent = send) → s3 PutObject ×4, db jobs.complete, s3 DeleteObject; traceparent outbox = trace; retry (`fault-transient-1.png`): попытки `retry` → `ready` в той же трассе, 2-я публикация — child от `create` worker-а, пауза 1.01 с | `obs-correlation.trees.txt` |
| 4: p50/p95/p99 из histogram, доля ошибок, queue depth/возраст, DB pool, saturation worker; запросы и единицы | dashboard; REPORT «Dashboard», «Схема сигналов» | — (запросы проверены `dashboard_check.py`) | `dashboard-check.json` |
| 4: SLI/SLO и окно; alert rules для error rate и queue lag; проверены искусственным отказом | `infra/prometheus/rules`, `promtool test rules`; инциденты 1 и 2 | `MessengerQueueLagGrowing`: pending → firing через 107 с после остановки worker, resolved через 81 с после запуска; `MessengerHighErrorRate` (api и lb) и `MessengerDbSlow`: firing через 156/171 с после блокировки, resolved через 50/35 с после снятия | `incident-worker-stop.json`, `incident-db-slow.json` (ряд `ALERTS`) |
| 4: Collector memory limiter/batch, ограниченная буферизация; остановка telemetry-хранилища не ломает сообщения и не даёт бесконечного роста RAM | `telemetry_outage.py` | см. «Отказ telemetry backend» ниже: 5xx = 0 во всех фазах, очередь экспортёров упёрлась в 100 = capacity, потери посчитаны, RSS API +15 MiB и вернулся, Collector ≤ 136 MiB (лимит 256) | `telemetry-outage.*` |
| 4: два инцидента с шагами диагностики | инциденты 1, 2 | ниже | `incident-*.json` |
| Нагрузка при включённой телеметрии | `tests/load.py --duration 30 --concurrency 4` | 14173 успешных POST, 0 ошибок, 471 rps (closed-loop) | `load.*` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Общее: стенд из раздела «Запуск», 1 прогон каждого сценария (не статистика, а воспроизводимая методика — скрипты в `student-tests/`). Нагрузка — `student-tests/traffic.py`: closed-loop, 4 потока, цикл «история чата (GET) + сообщение (POST с Idempotency-Key)» с паузой 0.2 с, в инцидентах 1 и 3 каждый 4-й цикл — upload PNG 64×48; ≈ 40 успешных rps, из них ≈ 4 upload/с. Перед замером 40–45 с базовой линии. Диагностика ниже ведётся **только по сохранённым наблюдениям** (ряды Prometheus, трассы Tempo, логи Loki, `pg_stat_activity`), которые скрипт складывает в evidence.
Нагрузка без отказов (`tests/load.py`, 30 с, 4 потока, только POST сообщений): 14173 успешных, 0 ошибок, 471 rps; p50 4.8 мс, p95 37.6 мс, p99 56.3 мс (только успешные; closed-loop с coordinated omission). Телеметрия включена (100 % трасс).
### Инцидент 1: остановлены все worker
Воздействие: `docker compose stop worker` (обе реплики, SIGTERM — текущие задания доработаны) на 127 с под нагрузкой, затем `docker compose up worker`. Файл: `evidence/incident-worker-stop.json`.
| t, с от остановки | Наблюдение (источник) |
| --- | --- |
| 0 | Loki `{service_name="messenger-worker"} \| event=~"worker.*"`: `worker.draining` → `worker.stopped` у обоих instance через 1.1 с |
| 0…127 | API: 4952 запроса, **0 ошибок**, p95 20 мс — приём не зависит от worker (202 queued) |
| 45 | `MessengerQueueLagGrowing` pending (ready lag > 30 с и растёт) |
| 105 | **firing**: ready lag 105 с, queued в БД 456, RabbitMQ ready 455 (одно и то же видно по источнику истины и по брокеру — сообщения доходят, нет потребителей) |
| 127 | worker запущены (`worker.started` в Loki) |
| 127…287 | разбор: throughput **≈ 475 заданий/мин (7.9/с)** при утилизации потребителей **0.41** и CPU worker ≈ 0.5 ядра из 1.0; time to ready p95 до 220 с |
| 208 | alert **resolved** (lag 62 с и убывает — система восстанавливается) |
| 287 | backlog разобран (ready lag < 5 с); все вложения эксперимента — `ready`, потерь нет |
Шаги диагностики: (1) alert/«Ready lag» и «Глубина очереди» — растёт backlog, при этом 5xx нет → проблема в фоновой обработке, а не в API; (2) «Saturation worker» — `messenger_worker_capacity` пропал, utilization 0 → потребителей нет; (3) логи worker — штатная остановка (`worker.stopped`), а не crash; (4) трасса upload из окна отказа (`ops inspect` → traceparent → Tempo): между `attachments send` (relay, сразу после 202) и `attachments.process.v1 process` разрыв **97.5 с**, сама обработка 239 мс; атрибут `messenger.job.queue_wait_s=97.47` — время ушло на ожидание в очереди, а не на обработку. Причина: нет работающих worker. Восстановление: запуск worker.
Находка по наблюдениям (вторичная причина медленного восстановления): при разборе backlog worker заняты только на 41 %, CPU наполовину свободен, а пропускная способность ровно 8 заданий/с = 4 потребителя × 2/с. Это значит, что каждый потребитель тратит ≈ 0.5 с на задание, хотя обработка (span `process`) длится ≈ 0.2 с. Причина в коде lab5 `Consumer.run_job`: цикл `while not future.done(): conn.process_data_events(time_limit=0.5)` после завершения задания досиживал полный `time_limit`. Исправление: по завершении future — пустой `add_callback_threadsafe`, который будит цикл AMQP сразу (`src/worker.py`). Замер до/после — `student-tests/drain_bench.py` (ниже).
### Инцидент 2: медленная БД (долгая блокировка) против медленного кода обработчика
Воздействие: отдельная сессия psql (как «забытая» миграция) выполняет `LOCK TABLE sessions IN ACCESS EXCLUSIVE MODE` и держит блокировку 196 с; затем `pg_terminate_backend`. API на время теста пересоздан с `FAULT_INJECTION=1` — это только включает точку `X-Fault-Inject: slow-handler` для эталонных запросов «медленного кода». Файл: `evidence/incident-db-slow.json`.
| t, с от блокировки | Наблюдение (источник) |
| --- | --- |
| 0…196 | клиент: 160 запросов, 152 ответа **503**, ≈ 5 с каждый; `pg_stat_activity`: 4 активных сессии `wait_event_type=Lock / relation` + держатель `PgSleep` |
| 95 | pending `MessengerHighErrorRate{source=api}` и `{source=lb}` (LB лишь пропускает 503 приложения: обе реплики остаются UP, readiness = `SELECT 1` отдельным соединением не блокируется) |
| 156 | **firing** error rate: доля 5xx = 1.0, `error_type=db_unavailable` (≈ 0.8 rps) |
| 171 | **firing** `MessengerDbSlow`: p95 `db.client.operation.duration` = **5.475 с**, вся задержка в одной операции — `get_session_user`; пул: 11 соединений used |
| 196 | блокировка снята |
| +35 / +50 | resolved `MessengerDbSlow` / `MessengerHighErrorRate` (очистились 2-минутные окна); после — 0 ошибок, p95 24 мс |
Как отличить медленную БД от медленного обработчика (одинаково «медленный HTTP» в метрике `http.server.request.duration`):
```
медленный КОД (X-Fault-Inject: slow-handler): медленная БД (блокировка sessions):
GET /api/v1/chats/{chat_id}/messages 1516.0 ms SERVER POST /api/v1/chats/{chat_id}/messages 5006.0 ms SERVER ERROR
db get_session_user 0.7 ms CLIENT db get_session_user 5004.7 ms CLIENT ERROR
db get_chat_for 0.4 ms CLIENT (error.type=db_unavailable, QueryCanceled по statement_timeout 5 с)
handler.compute 1505.3 ms INTERNAL
db list_messages 6.2 ms CLIENT обычный запрос: SERVER 6.9 ms, db spans 2.2 + 1.3 + 1.8 ms
```
В трассе медленного кода db spans суммарно 7 мс, а время в INTERNAL span обработчика; в трассе БД 99.97 % времени запроса — CLIENT span `db get_session_user`. В метриках: при медленном коде растёт только `http.server.request.duration` маршрута, при медленной БД — ещё и `db.client.operation.duration{db_operation_name="get_session_user"}`, пул и `error_type=db_unavailable`. Логи: 152 записи `event=db.unavailable` (`QueryCanceled`) с trace_id — по любой из них Grafana открывает трассу. Шаги диагностики: alert error rate → панель «5xx по причине» (`db_unavailable`) → «Операции БД p95 по операции» (одна операция) → трасса ошибки (db span = всё время) → `pg_stat_activity` (Lock) → держатель блокировки (самая старая транзакция) → `pg_terminate_backend`. Ограничение измерения: closed-loop клиенты при 5-секундных ответах сами снижают RPS (≈ 0.8 rps вместо 35), поэтому доля 5xx в 2-минутном окне перерастает 5 % только через ≈ 80 с; при open-loop трафике alert сработал бы быстрее. Здесь же видно, почему нужны bucket-границы у таймаутов: до добавления 5.5 с p95 по интерполяции показывал 9.75 с вместо ≈ 5 с.
### Отказ telemetry backend и самого Collector (`evidence/telemetry-outage.json`)
Под той же нагрузкой: A — 40 с базовой линии; B — `docker compose stop tempo loki` на 120 с; C — запуск, 40 с; D — `docker compose stop otel-collector` на 90 с; E — запуск, 45 с.
| Фаза | API (клиент) | Память (docker stats) | Что происходит с телеметрией |
| --- | --- | --- | --- |
| A | 0 ошибок, ≈ 40 rps | API 45 MiB, worker 47, Collector 78 | норма |
| B: Tempo+Loki down | **0 ошибок**, p95 ≈ 19 мс (как в A) | Collector до 125 MiB (лимит 256; Go heap ≤ 100.5 MiB) | очереди `otlp_grpc/tempo` и `otlp_http/loki` выросли до **100 = capacity**; дальше `sending queue is full`: отброшено 11379 spans и 1140 log records, ещё 540 spans / 119 записей — `no more retries left` (retry > 60 с) — из 43087 spans / 8807 записей, принятых за B+C; метрики в Prometheus шли без потерь; alerts `MessengerTelemetryBackendDown{job=loki|tempo}` firing, `MessengerTelemetryExportFailing` pending→firing |
| C | 0 ошибок | Collector возвращается к норме | очереди разгружены (свежие данные снова пишутся) |
| D: Collector down | **0 ошибок** | API 45 → 57.5 MiB, worker до 68 MiB — и не растут дальше | SDK: экспорт падает `ConnectionError`, батч отбрасывается: потеряно 23518 spans и 4828 log records (`otel_sdk_exporter_*_exported_total{error_type="ConnectionError"}`); переполнения очередей нет (`queue_full` = 0) — они освобождаются быстрее, чем наполняются; `MessengerTelemetryBackendDown{job=otel-collector}` firing |
| E | 0 ошибок | память API 52 MiB | экспорт возобновился, cumulative-счётчики SDK донесли число потерь |
Итог: бизнес-путь от телеметрии не зависит (5xx = 0 во всех фазах), память всех процессов ограничена (буферы ограничены по числу элементов), потери не скрыты — их число есть в метриках и на панелях «Конвейер телеметрии». Ограничение: пока лежит Collector, метрики приложения тоже не доходят — потери SDK видны только после восстановления (счётчики cumulative). Нюанс измерения: `otelcol_process_memory_rss` (≈ 225 MiB) включает file-backed страницы 250-мегабайтного бинарника и не совпадает с учётом cgroup; ограничение памяти подтверждают heap и `docker stats`.
### Исправление, найденное по наблюдениям: пропускная способность worker (`evidence/drain-bench-{before,after}.json`)
Гипотеза из инцидента 1: потребитель простаивает ≈ 0.3 с после каждого задания из-за `process_data_events(time_limit=0.5)`. Методика `student-tests/drain_bench.py`: worker остановлены, принимаются 240 PNG 64×48, worker запускаются, засекается время до `ready` всех 240 (по БД).
| | Разбор 240 заданий | Throughput | CPU worker (пик, сумма) |
| --- | --- | --- | --- |
| до (lab5 `run_job`) | 26.2 с | 9.2 заданий/с | 1.14 ядра |
| после (`add_callback_threadsafe` по завершении) | **11.0 с** | **21.9 заданий/с** (×2.4) | 1.20 ядра |
Один прогон на каждую версию, разница больше шума (ожидаемый предел до исправления — 4 × 2 = 8/с совпал с наблюдением в инциденте 1). Вывод: не хватало не ресурсов, а «пробуждения» цикла AMQP; теперь потолок — CPU transform (лимит worker 1 CPU). Попутно найдено: после пересоздания контейнеров OTLP-ряды старых реплик ещё 5 мин видны в `sum(messenger_worker_capacity)` (у bench «до/после» utilization поэтому не сравнивается); в dashboard и alert теперь `sum(last_over_time(messenger_worker_capacity[30s]))` — только живые реплики.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановить все worker на 127 с | 202 продолжаются, растёт возраст заданий, alert lag | 0 ошибок API; firing через 107 с; трасса: 97.5 с в очереди | alert resolved через 81 с после запуска, backlog — через 160 с (до исправления worker); потерь нет, все ready |
| Блокировка `sessions` 196 с | 503 по statement_timeout, alert ошибок и медленной БД, БД видна в трассе | 95 % 503; firing 156/171 с; db span 5004.7 мс из 5006 | resolved 35–50 с после снятия; данные не потеряны (запросы отклонены честным 503) |
| Tempo+Loki down 120 с | API не страдает, очередь Collector ограничена, потери считаются | 0 ошибок, очередь 100/100, отброшено ≈ 12 тыс. spans | сразу после запуска; потеря телеметрии за окно > 60 с |
| Collector down 90 с | API не страдает, RAM SDK ограничена | 0 ошибок, RSS API +13 MiB и стабильно | сразу; потеряно 23.5 тыс. spans / 4.8 тыс. логов, посчитано SDK |
| Рестарт всех хранилищ (данных и телеметрии) | история сохраняется | тот же trace, лог, значение метрики в прошлом | ≈ 40 с до готовности; потерь нет |
Все прогоны сделаны на рабочем стенде (volumes созданы с нуля при первом запуске lab6, затем код дорабатывался), а не в отдельном чистом clone итогового коммита — репозиторий ещё не опубликован; перед PR стоит повторить `LAB6_ONLY=1 ./student-tests/run_all.sh` в чистом clone.
## Вопросы защиты
- **Чем лог, метрика и trace отвечают на разные вопросы об одном инциденте?** Метрика — агрегат во времени: «есть ли проблема, насколько она велика и когда началась» (5xx = 95 %, p95 БД 5 s, lag 130 s), дёшево хранится и годится для alert. Trace — один конкретный запрос/задание целиком: «где именно потрачено время» (5006 мс из 5008 — в `db get_session_user`; 120 с между `send` и `process`). Лог — дискретное событие с подробностями: «что произошло и с каким объектом» (`event=db.unavailable`, `QueryCanceled`, `request_id`, `job_id`). Связь между ними — `trace_id` в логе и exemplar в метрике.
- **Почему chat_id в labels может исчерпать хранилище?** Каждое уникальное сочетание labels — отдельный временной ряд со своим индексом и чанками в памяти. Число чатов растёт неограниченно, и умноженное на маршруты/статусы/buckets histogram (×20) даёт миллионы рядов: память и индекс Prometheus растут линейно, запросы замедляются, в итоге OOM или отказ приёма. Для конкретного чата есть логи и трассы; в метриках — только ограниченные перечисления.
- **Как очередь переносит причинную связь между процессами?** Контекст W3C (`traceparent` = версия-trace_id-span_id-флаги) сериализуется в данные сообщения: API пишет его в payload outbox в той же транзакции, что и задание; relay извлекает его, открывает span `send` дочерним и кладёт свой контекст в тело и AMQP headers; worker извлекает и открывает `process` дочерним от `send`. Так upload, публикация и обработка (и retry) — одна трасса, хотя процессы и время разные.
- **Почему среднее latency не заменяет p99 и почему нельзя усреднять p99 реплик?** Среднее скрывает хвост: при 99 % запросов по 10 мс и 1 % по 5 s среднее ~60 мс, а каждый сотый пользователь ждёт 5 s. Перцентиль нелинеен: p99 двух реплик с разной нагрузкой и распределением не равен среднему их p99 (реплика с 1 % трафика и плохим p99 исказит среднее в любую сторону). Правильно — сложить buckets histogram всех реплик (`sum by (le)`) и считать `histogram_quantile` по общему распределению; точность ограничена границами buckets (поэтому добавлены 3.5 и 5.5 s рядом с таймаутами).
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Выдерживается: остановка worker (задания копятся в PostgreSQL/quorum-очереди и дорабатываются), долгая блокировка/медленная БД (честные 503 вместо зависаний, alert и диагностика), недоступность Tempo/Loki и самого Collector (бизнес-путь не меняется, память ограничена, потери посчитаны), перезапуск всех хранилищ с volumes (история метрик, логов и трасс сохраняется). Всё, что выдерживала lab5 (отказ реплики API, рестарт брокера/S3, crash-окна outbox), сохранено.
Не выдерживается / учебные упрощения:
- **Один Docker-host и по одному экземпляру Prometheus, Loki, Tempo, Collector.** Потеря host или volume теряет историю; нет репликации и удалённого хранения. Если упал сам Prometheus — alerts не вычисляются (нет «мониторинга мониторинга» и Alertmanager с внешней доставкой — по заданию не требуется).
- **Потери телеметрии при длительной недоступности backend — осознанные.** Очередь Collector только в памяти (100 батчей, retry 60 с), SDK — 2048 записей; дольше — данные отбрасываются (считаются). Дисковая очередь (`file_storage` + persistent sending_queue) уменьшила бы потери ценой диска и сложности — не реализовано.
- **Сэмплирование 100 %** (`parentbased_always_on`) подходит учебной нагрузке; цена наблюдаемости и tail-based sampling (трек 1) не исследовались.
- **Gauges очереди считает relay** запросом к PostgreSQL раз в 10 с: при остановленном relay они пропадают (backlog тогда виден по RabbitMQ и `MessengerOutboxStuck` не вычислится — это ограничение, а не отсутствие сигнала: остаётся `up`/healthcheck relay в `docker compose ps`). Несколько relay дадут одинаковые ряды — dashboard использует `max`.
- **Время обнаружения зависит от модели нагрузки.** В инциденте 2 генератор closed-loop: при 5-секундных ответах клиенты сами снижают RPS, и доля ошибок в 2-минутном окне перерастает 5 % только через ~80 с (coordinated omission). Реальный open-loop трафик дал бы более быстрое срабатывание; многооконные burn-rate alerts (трек 2) не реализованы.
- **CPU/RAM PostgreSQL, SeaweedFS** не собираются (нет postgres_exporter/cAdvisor — последний требует доступа к Docker socket); для них есть healthcheck и `docker stats` в evidence. CPU/RAM процессов приложения — из cgroup своего контейнера, telemetry-стека — их собственные метрики.
- **RSS Collector** (`otelcol_process_memory_rss`) включает file-backed страницы 250-мегабайтного бинарника и выше, чем учёт cgroup; ограничение памяти подтверждается heap (`otelcol_process_runtime_heap_alloc_bytes`) и `docker stats`.
- **Внешний traceparent клиента не принимается** (безопасность публичной точки входа); сквозная трасса начинается в API. HAProxy spans не создаёт (в образе нет OpenTelemetry-фильтра) — его вклад виден по метрикам `haproxy_*`.
Следующие шаги: дисковая очередь Collector или второй Collector-шлюз; burn-rate SLO alerts на нескольких окнах; postgres_exporter для БД (connections, locks, replication); Alertmanager с маршрутизацией; tail-based sampling (сохранять все ошибки и медленные трассы при 10 % обычных).
+556
View File
@@ -0,0 +1,556 @@
# Lab6 = lab5 + наблюдаемость.
# HAProxy -> API x N (по умолчанию 2) -> PostgreSQL (данные, сессии, вложения, jobs, outbox)
# -> SeaweedFS S3 (staging/ и attachments/, приватный bucket)
# relay: outbox (PostgreSQL) -> RabbitMQ (quorum queue, publisher confirms) + reaper аренд
# worker x N: RabbitMQ -> staging -> transform (thumbnail/crop/optimized) -> S3 + PostgreSQL
# telemetry: API/relay/worker/janitor --OTLP/HTTP--> otel-collector --> Prometheus (metrics)
# --> Loki (logs)
# --> Tempo (traces)
# Prometheus также снимает метрики Collector, HAProxy, RabbitMQ, Loki, Tempo;
# Grafana (127.0.0.1:3000) — provisioning datasources/dashboard из infra/grafana.
# Запуск: ./scripts/init-secrets.sh && docker compose --env-file .env up -d --build --wait
name: mtusi-lab6
# Один образ на восемь сервисов. Собирает его ТОЛЬКО migrate (первый job стенда), остальные
# используют готовый тег: параллельная сборка одного тега несколькими сервисами давала
# «image ... already exists» на пустом Docker.
x-app-image: &app-image
image: mtusi-messenger:lab6
pull_policy: never
# Lab6: OpenTelemetry SDK приложений. Экспорт асинхронный, очереди ограничены: недоступный
# Collector не ломает запросы (теряется только телеметрия). OTEL_SDK_DISABLED=true — выключить.
x-otel-env: &otel-env
OTEL_SDK_DISABLED: ${OTEL_SDK_DISABLED:-false}
OTEL_EXPORTER_OTLP_ENDPOINT: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://otel-collector:4318}
OTEL_EXPORTER_OTLP_PROTOCOL: ${OTEL_EXPORTER_OTLP_PROTOCOL:-http/protobuf}
# Не интерполируется из окружения хоста: Docker CLI сам передаёт compose-плагину
# OTEL_RESOURCE_ATTRIBUTES=docker.cli.cobra.command_path=... (он попадал в target_info).
OTEL_RESOURCE_ATTRIBUTES: deployment.environment.name=${APP_ENV:-lab}
OTEL_TRACES_SAMPLER: ${OTEL_TRACES_SAMPLER:-parentbased_always_on}
OTEL_TRACES_SAMPLER_ARG: ${OTEL_TRACES_SAMPLER_ARG:-1.0}
OTEL_METRIC_EXPORT_INTERVAL: ${OTEL_METRIC_EXPORT_INTERVAL:-10000}
OTEL_EXPORTER_OTLP_TIMEOUT_SECONDS: ${OTEL_EXPORTER_OTLP_TIMEOUT_SECONDS:-5}
OTEL_BSP_MAX_QUEUE_SIZE: ${OTEL_BSP_MAX_QUEUE_SIZE:-2048}
OTEL_BLRP_MAX_QUEUE_SIZE: ${OTEL_BLRP_MAX_QUEUE_SIZE:-2048}
# Собственные метрики SDK: otel.sdk.processor.*.processed{error.type=queue_full} (потери в
# процессе), otel.sdk.exporter.*.exported{error.type} (ошибки экспорта), размер очереди.
OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED: ${OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED:-true}
x-db-env: &db-env
POSTGRES_HOST: db
POSTGRES_PORT: "5432"
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
x-s3-env: &s3-env
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:8333}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_CONNECT_TIMEOUT_SECONDS: ${S3_CONNECT_TIMEOUT_SECONDS:-2}
S3_READ_TIMEOUT_SECONDS: ${S3_READ_TIMEOUT_SECONDS:-5}
x-job-env: &job-env
PIPELINE_VERSION: ${PIPELINE_VERSION:-1}
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:-60}
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:-30}
JOB_RETRY_BASE_SECONDS: ${JOB_RETRY_BASE_SECONDS:-2}
JOB_RETRY_MAX_SECONDS: ${JOB_RETRY_MAX_SECONDS:-60}
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
services:
db:
image: postgres:16.4-alpine@sha256:5660c2cbfea50c7a9127d17dc4e48543eedd3d7a41a595a2dfa572471e37e64c
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
networks: [backend]
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$${POSTGRES_USER}\" -d \"$${POSTGRES_DB}\""]
interval: 2s
timeout: 3s
retries: 30
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.0", memory: 512M}
# S3 (как в lab4): master/volume/filer только на 127.0.0.1 контейнера, наружу — S3 API :8333.
s3:
image: chrislusf/seaweedfs:4.50@sha256:c2658820e763294a9e9de7b36c81e59b879e3459148351aee4e31a126ca64860
command:
- server
- -dir=/data
- -ip=127.0.0.1
- -ip.bind=127.0.0.1
- -master.volumeSizeLimitMB=1024
- -master.electionTimeout=2s
- -volume.preStopSeconds=2
- -volume.max=0
- -s3
- -s3.ip.bind=0.0.0.0
- -s3.port=8333
- -s3.config=/run/secrets/s3_identities.json
- -s3.iam=false
- -s3.port.iceberg=0
- -s3.port.lance=0
- -s3.concurrentUploadLimitMB=64
- -filer.concurrentUploadLimitMB=64
- -volume.concurrentUploadLimitMB=64
- -s3.cacheCapacityMB=16
- -s3.readerCacheSizeMB=32
secrets: [s3_identities.json]
environment:
GOMEMLIMIT: 512MiB
volumes:
- s3data:/data
networks: [backend]
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8333/healthz && curl -sf -m 2 -X PUT --data-binary ok http://127.0.0.1:8888/.healthcheck/probe -o /dev/null"]
interval: 5s
start_interval: 1s
timeout: 3s
retries: 3
start_period: 60s
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.0", memory: 768M}
# Брокер: RabbitMQ 4.1, quorum-очередь (durable, Raft-журнал на диске), publisher confirms.
# Топология и пользователи — из definitions (secret). Порты на хост не публикуются.
broker:
image: rabbitmq:4.1.4-alpine@sha256:b736d649308e1b3e1a116c3f36986b605ee3d03e88f10166be2900083d2e63f2
hostname: broker # имя узла rabbit@broker неизменно -> данные volume находятся после пересоздания
volumes:
- brokerdata:/var/lib/rabbitmq
- ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/conf.d/90-lab5.conf:ro
secrets:
- source: rabbitmq_definitions.json
target: /run/secrets/rabbitmq_definitions.json
# telemetry: Prometheus снимает rabbitmq_prometheus (:15692) — глубина очередей брокера.
networks: [backend, telemetry]
restart: unless-stopped
healthcheck:
# Узел запущен, нет алармов памяти/диска, и рабочая очередь объявлена.
test: ["CMD-SHELL", "rabbitmq-diagnostics -q check_running && rabbitmq-diagnostics -q check_local_alarms && rabbitmqctl -q -p messenger list_queues name | grep -q attachments.process.v1"]
interval: 10s
start_interval: 2s
timeout: 15s
retries: 5
start_period: 60s
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.0", memory: 512M}
migrate:
<<: *app-image
build:
context: .
args:
APP_VERSION: ${APP_VERSION:-1}
# Собрать, если образа нет; пересборка — явно (`build` или `up --build`).
pull_policy: missing
command: ["python", "/app/src/migrate.py"]
environment:
<<: *db-env
secrets: [postgres_password]
networks: [backend]
healthcheck: {disable: true}
restart: "no"
depends_on:
db: {condition: service_healthy}
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
s3-init:
<<: *app-image
command: ["python", "/app/src/s3_bootstrap.py"]
environment:
<<: *s3-env
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_admin_access_key
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_admin_secret_key
secrets: [s3_admin_access_key, s3_admin_secret_key]
networks: [backend]
healthcheck: {disable: true}
restart: "no"
depends_on:
s3: {condition: service_healthy}
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
api:
<<: *app-image
expose: ["8080"]
environment:
<<: [*db-env, *s3-env, *job-env, *otel-env]
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DB_POOL_SIZE: ${DB_POOL_SIZE:-10}
DRAIN_SECONDS: ${DRAIN_SECONDS:-3}
SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-10}
PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-2}
PASSWORD_HASH_WAIT_SECONDS: ${PASSWORD_HASH_WAIT_SECONDS:-0.5}
DB_HEALTH_INTERVAL_SECONDS: ${DB_HEALTH_INTERVAL_SECONDS:-1}
READY_STALE_SECONDS: ${READY_STALE_SECONDS:-3}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_api_access_key
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_api_secret_key
UPLOAD_TIMEOUT_SECONDS: ${UPLOAD_TIMEOUT_SECONDS:-60}
JSON_BODY_TIMEOUT_SECONDS: ${JSON_BODY_TIMEOUT_SECONDS:-10}
UPLOAD_CONCURRENCY: ${UPLOAD_CONCURRENCY:-8}
# Проверка JPEG — в подпроцессе src/jpeg_probe.py (аудит F02): progressive JPEG 40 Мпикс
# 4:4:4 требует до ~250 MiB. Одна проба за раз + её лимит адресного пространства.
DECODE_CONCURRENCY: ${DECODE_CONCURRENCY:-1}
JPEG_PROBE_MEMORY_MB: ${JPEG_PROBE_MEMORY_MB:-384}
JPEG_PROBE_CPU_SECONDS: ${JPEG_PROBE_CPU_SECONDS:-10}
JPEG_PROBE_TIMEOUT_SECONDS: ${JPEG_PROBE_TIMEOUT_SECONDS:-15}
S3_PUT_CONCURRENCY: ${S3_PUT_CONCURRENCY:-3}
FAULT_INJECTION: ${FAULT_INJECTION:-0}
FAULT_SLOW_HANDLER_SECONDS: ${FAULT_SLOW_HANDLER_SECONDS:-1.5}
OTEL_SERVICE_NAME: messenger-api
# У API НЕТ доступа к брокеру: задание пишется в outbox PostgreSQL.
secrets: [postgres_password, s3_api_access_key, s3_api_secret_key]
networks: [backend, telemetry]
restart: unless-stopped
stop_grace_period: 20s
depends_on:
db: {condition: service_healthy}
migrate: {condition: service_completed_successfully}
s3-init: {condition: service_completed_successfully}
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: {cpus: "0.5", memory: 512M} # ~100 MiB upload+S3 PUT + проба JPEG до ~260 MiB + запас
# Outbox relay + reaper аренд (src/relay.py). Можно масштабировать: SKIP LOCKED + advisory lock.
relay:
<<: *app-image
command: ["python", "/app/src/relay.py"]
environment:
<<: [*db-env, *job-env, *otel-env]
SERVICE_NAME: relay
BROKER_URL_FILE: /run/secrets/broker_relay_url
RELAY_POLL_SECONDS: ${RELAY_POLL_SECONDS:-1}
REAPER_INTERVAL_SECONDS: ${REAPER_INTERVAL_SECONDS:-5}
JOB_REDRIVE_AFTER_SECONDS: ${JOB_REDRIVE_AFTER_SECONDS:-900}
OUTBOX_RETENTION_SECONDS: ${OUTBOX_RETENTION_SECONDS:-86400}
RELAY_FAULT: ${RELAY_FAULT:-}
OTEL_SERVICE_NAME: messenger-relay
secrets: [postgres_password, broker_relay_url]
networks: [backend, telemetry]
healthcheck:
test: ["CMD", "python", "-c", "import os,sys,time; sys.exit(0 if time.time() - os.path.getmtime('/tmp/relay.heartbeat') < 30 else 1)"]
interval: 10s
timeout: 3s
retries: 3
start_period: 30s
restart: unless-stopped
stop_grace_period: 15s
depends_on:
migrate: {condition: service_completed_successfully}
broker: {condition: service_healthy}
deploy:
resources:
limits: {cpus: "0.25", memory: 128M}
# Worker (src/worker.py): WORKER_CONCURRENCY потоков x prefetch 1 на контейнер.
worker:
<<: *app-image
command: ["python", "/app/src/worker.py"]
environment:
<<: [*db-env, *s3-env, *job-env, *otel-env]
SERVICE_NAME: worker
BROKER_URL_FILE: /run/secrets/broker_worker_url
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_worker_access_key
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_worker_secret_key
# Чтение 10 MiB из staging и запись результатов: дольше, чем upload-таймауты API.
S3_READ_TIMEOUT_SECONDS: ${WORKER_S3_READ_TIMEOUT_SECONDS:-10}
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-2}
WORKER_PREFETCH: ${WORKER_PREFETCH:-1}
TRANSFORM_MEMORY_LIMIT_MB: ${TRANSFORM_MEMORY_LIMIT_MB:-768}
TRANSFORM_CPU_SECONDS: ${TRANSFORM_CPU_SECONDS:-30}
WORKER_TMP_DIR: /tmp/work
WORKER_FAULT_INJECTION: ${WORKER_FAULT_INJECTION:-0}
FAULT_SLOW_SECONDS: ${FAULT_SLOW_SECONDS:-20}
OTEL_SERVICE_NAME: messenger-worker
secrets: [postgres_password, broker_worker_url, s3_worker_access_key, s3_worker_secret_key]
networks: [backend, telemetry]
healthcheck:
test: ["CMD", "python", "-c", "import os,sys,time; sys.exit(0 if time.time() - os.path.getmtime('/tmp/worker.heartbeat') < 30 else 1)"]
interval: 10s
timeout: 3s
retries: 3
start_period: 30s
restart: unless-stopped
# SIGTERM: потребители дорабатывают текущее задание (<= JOB_TIMEOUT 60 с) и выходят.
stop_grace_period: 75s
depends_on:
migrate: {condition: service_completed_successfully}
s3-init: {condition: service_completed_successfully}
broker: {condition: service_healthy}
deploy:
replicas: ${WORKER_REPLICAS:-2}
resources:
limits: {cpus: "1.0", memory: 1G}
janitor:
<<: *app-image
command: ["python", "/app/src/janitor.py"]
environment:
<<: [*db-env, *s3-env, *otel-env]
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_janitor_access_key
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_janitor_secret_key
ATTACHMENT_GRACE_SECONDS: ${ATTACHMENT_GRACE_SECONDS:-3600}
JANITOR_INTERVAL_SECONDS: ${JANITOR_INTERVAL_SECONDS:-300}
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:-86400}
OTEL_SERVICE_NAME: messenger-janitor
secrets: [postgres_password, s3_janitor_access_key, s3_janitor_secret_key]
networks: [backend, telemetry]
healthcheck:
test: ["CMD", "python", "-c", "import os,sys,time; sys.exit(0 if time.time() - os.path.getmtime('/tmp/janitor.heartbeat') < 90 else 1)"]
interval: 15s
timeout: 3s
retries: 2
start_period: 20s
restart: unless-stopped
depends_on:
migrate: {condition: service_completed_successfully}
s3-init: {condition: service_completed_successfully}
deploy:
resources:
limits: {cpus: "0.25", memory: 128M}
lb:
image: haproxy:3.0.5-alpine@sha256:43a2591a6a62a41dd22edb4452880e9c70de489fbd7c54ffb52d035cccbfe949
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
environment:
LOGIN_RATE_LIMIT: ${LOGIN_RATE_LIMIT:-20}
ports:
- "127.0.0.1:${LB_PORT:-8080}:8080"
- "127.0.0.1:8404:8404"
# telemetry: Prometheus снимает встроенный экспортёр HAProxy (:8404/metrics).
networks: [frontend, backend, telemetry]
restart: unless-stopped
healthcheck:
test: ["CMD", "haproxy", "-c", "-q", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
interval: 10s
timeout: 3s
retries: 3
depends_on:
api: {condition: service_started}
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
# Операторский CLI (не часть стенда): docker compose --profile tools run --rm ops <команда>
# inspect / failed / replay / dlq. Ключ S3 janitor (List, без чтения), брокер — пользователь ops.
ops:
<<: *app-image
profiles: [tools]
entrypoint: ["python", "/app/src/ops.py"]
environment:
<<: [*db-env, *s3-env, *job-env]
SERVICE_NAME: ops
BROKER_URL_FILE: /run/secrets/broker_ops_url
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_janitor_access_key
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_janitor_secret_key
secrets: [postgres_password, broker_ops_url, s3_janitor_access_key, s3_janitor_secret_key]
networks: [backend]
healthcheck: {disable: true}
restart: "no"
# Проверки внутри backend-сети (Pillow для попиксельной проверки вариантов, права S3).
checks:
<<: *app-image
profiles: [tools]
entrypoint: ["python"]
environment:
<<: *s3-env
volumes:
- ./student-tests:/app/student-tests:ro
- ./tests:/app/tests:ro
- ./contracts:/app/contracts:ro
- ./lab.json:/app/lab.json:ro
- ./evidence:/app/evidence
secrets: [s3_api_access_key, s3_api_secret_key, s3_worker_access_key, s3_worker_secret_key,
s3_janitor_access_key, s3_janitor_secret_key]
networks: [backend, telemetry]
healthcheck: {disable: true}
restart: "no"
user: "0"
# ===================================================================== lab6: телеметрия
# Collector: получатель/обработчик/экспортёр, не хранилище (буфер в памяти ограничен).
# Без healthcheck: образ distroless (нет shell); доступность видна по up{job="otel-collector"}.
otel-collector:
image: otel/opentelemetry-collector-contrib:0.163.2@sha256:7f22d2a6748110ffb6a59bc0df448bccbf501cdb667d610ede4c61d3863d5849
command: ["--config=/etc/otelcol/collector.yaml"]
volumes:
- ./infra/otel/collector.yaml:/etc/otelcol/collector.yaml:ro
environment:
GOMEMLIMIT: 200MiB
networks: [telemetry]
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
# Метрики: Prometheus TSDB (volume promdata), приём OTLP push + scrape; alert rules.
prometheus:
image: prom/prometheus:v3.13.5@sha256:aafa9d694e6a883c02db516d9f6e5b84e14195f49a2a6456a4cca815edda72b9
command:
- --config.file=/etc/prometheus/prometheus.yml
- --storage.tsdb.path=/prometheus
- --storage.tsdb.retention.time=15d
- --storage.tsdb.retention.size=2GB
- --web.enable-otlp-receiver
- --enable-feature=exemplar-storage
- --web.listen-address=:9090
volumes:
- ./infra/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
- ./infra/prometheus/rules:/etc/prometheus/rules:ro
- promdata:/prometheus
networks: [telemetry]
restart: unless-stopped
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9090/-/ready"]
interval: 10s
start_interval: 2s
timeout: 3s
retries: 5
start_period: 30s
deploy:
resources:
limits: {cpus: "0.5", memory: 512M}
# Логи: Loki (volume lokidata), нативный OTLP. Образ distroless (нет shell) — без Docker
# healthcheck; готовность: up{job="loki"} в Prometheus и scripts/wait-telemetry.sh (/ready).
loki:
image: grafana/loki:3.6.19@sha256:0f9cbc340cbe33ee498e654075034336962057db072f57b37f253e14d476443a
command: ["-config.file=/etc/loki/loki.yaml"]
volumes:
- ./infra/loki/loki.yaml:/etc/loki/loki.yaml:ro
- lokidata:/loki
networks: [telemetry]
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.5", memory: 512M}
# Трассы: Tempo (volume tempodata). Distroless, как Loki: готовность — up{job="tempo"}, /ready.
tempo:
image: grafana/tempo:2.10.10@sha256:12b0820f13ffa10ce956b6e9acc3b03f3cffded99109be6cc09d106fe56e5d38
command: ["-config.file=/etc/tempo/tempo.yaml"]
volumes:
- ./infra/tempo/tempo.yaml:/etc/tempo/tempo.yaml:ro
- tempodata:/var/tempo
networks: [telemetry]
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.5", memory: 512M}
# Интерфейс: Grafana (только 127.0.0.1:3000). Пароль admin — Docker secret.
grafana:
image: grafana/grafana:12.4.14@sha256:ae509d9ae8c1021ca32ec370a9ca975d40165eda9fccd1e1102d317ff8787cd7
environment:
GF_SECURITY_ADMIN_USER: admin
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password
GF_USERS_ALLOW_SIGN_UP: "false"
GF_AUTH_ANONYMOUS_ENABLED: "false"
GF_ANALYTICS_REPORTING_ENABLED: "false"
GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES: "false"
GF_NEWS_NEWS_FEED_ENABLED: "false"
GF_PLUGINS_PREINSTALL_DISABLED: "true"
GF_DASHBOARDS_DEFAULT_HOME_DASHBOARD_PATH: /var/lib/grafana/dashboards/messenger.json
secrets: [grafana_admin_password]
volumes:
- ./infra/grafana/provisioning:/etc/grafana/provisioning:ro
- ./infra/grafana/dashboards:/var/lib/grafana/dashboards:ro
- grafanadata:/var/lib/grafana
ports:
- "127.0.0.1:${GRAFANA_PORT:-3000}:3000"
networks: [telemetry, grafana-ui]
restart: unless-stopped
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:3000/api/health"]
interval: 10s
start_interval: 2s
timeout: 3s
retries: 6
start_period: 60s
depends_on:
prometheus: {condition: service_started}
loki: {condition: service_started}
tempo: {condition: service_started}
deploy:
resources:
limits: {cpus: "0.5", memory: 384M}
secrets:
grafana_admin_password:
file: ./secrets/grafana_admin_password
postgres_password:
file: ./secrets/postgres_password
s3_identities.json:
file: ./secrets/s3_identities.json
s3_admin_access_key:
file: ./secrets/s3_admin_access_key
s3_admin_secret_key:
file: ./secrets/s3_admin_secret_key
s3_api_access_key:
file: ./secrets/s3_api_access_key
s3_api_secret_key:
file: ./secrets/s3_api_secret_key
s3_worker_access_key:
file: ./secrets/s3_worker_access_key
s3_worker_secret_key:
file: ./secrets/s3_worker_secret_key
s3_janitor_access_key:
file: ./secrets/s3_janitor_access_key
s3_janitor_secret_key:
file: ./secrets/s3_janitor_secret_key
rabbitmq_definitions.json:
file: ./secrets/rabbitmq_definitions.json
broker_relay_url:
file: ./secrets/broker_relay_url
broker_worker_url:
file: ./secrets/broker_worker_url
broker_ops_url:
file: ./secrets/broker_ops_url
networks:
frontend: {}
backend:
internal: true
# Lab6: сеть телеметрии изолирована от данных (Grafana не видит БД/S3/секреты приложений).
telemetry:
internal: true
# Только для публикации Grafana на 127.0.0.1.
grafana-ui: {}
volumes:
pgdata: {}
s3data: {}
brokerdata: {}
promdata: {}
lokidata: {}
tempodata: {}
grafanadata: {}
+23
View File
@@ -3,3 +3,26 @@
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
## Содержимое (lab6, БПИ2303 Лазарев)
Получено на стенде из REPORT.md (MacBook Air M3, Docker Desktop 8 vCPU / 7.7 GiB, лимиты контейнеров —
`compose.yaml`) командой `LAB6_ONLY=1 ./student-tests/run_all.sh`; у каждого `*.txt` первая строка —
UTC-время и команда, последняя — код возврата. Токены, пароли и тексты сообщений не сохраняются.
| Файл | Что доказывает |
| --- | --- |
| `check.txt`, `validate.txt`, `smoke.txt` | `make check`, `make validate`, `make test` при включённой телеметрии |
| `telemetry-config.txt` | `scripts/check_rules.sh`: promtool check config/rules, unit-тесты alerts, otelcol validate, loki verify, dashboard = генератор |
| `persistence.txt`, `containers-before/after-restart.txt` | `make test-persistence` (рестарт всех хранилищ, вкл. Prometheus/Loki/Tempo) и реальные `StartedAt` |
| `failover.txt` | `make test-failover` |
| `worker-outage.*` | сценарий защиты lab5 уровня 3 (регрессия) |
| `obs-correlation.*`, `obs-correlation.trees.txt` | запрос → trace → лог; upload → relay → worker одной трассой (дерево spans); retry в той же трассе; нет утечек и ID-labels |
| `dashboard-check.*` | dashboard provisioned, все 56 панелей выполняют запросы, ключевые — с данными |
| `telemetry-persistence.*` | trace, лог и историческое значение метрики после рестарта всех хранилищ |
| `incident-worker-stop.*` | инцидент 1: таймлайн, ряды Prometheus, ALERTS firing → resolved, трасса с ожиданием в очереди |
| `incident-db-slow.*` | инцидент 2: блокировка БД vs медленный обработчик (трассы), alerts, pg_stat_activity, логи |
| `telemetry-outage.*` | остановка Tempo+Loki и Collector под нагрузкой: 5xx = 0, RAM ограничена, потери посчитаны |
| `load.*` | `tests/load.py` 30 с × 4 потока при включённой телеметрии |
| `drain-bench-{before,after}.*` | скорость разбора 240 заданий до/после исправления цикла AMQP worker |
| `pip-freeze.txt` | фактические версии Python-пакетов образа |
+4
View File
@@ -0,0 +1,4 @@
# 2026-11-14T17:00:57Z make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
exit=0
+31
View File
@@ -0,0 +1,31 @@
# containers after persistence hook
mtusi-lab6-api-1 running
mtusi-lab6-api-2 running
mtusi-lab6-broker-1 running
mtusi-lab6-db-1 running
mtusi-lab6-grafana-1 running
mtusi-lab6-janitor-1 running
mtusi-lab6-lb-1 running
mtusi-lab6-loki-1 running
mtusi-lab6-otel-collector-1 running
mtusi-lab6-prometheus-1 running
mtusi-lab6-relay-1 running
mtusi-lab6-s3-1 running
mtusi-lab6-tempo-1 running
mtusi-lab6-worker-1 running
mtusi-lab6-worker-2 running
/mtusi-lab6-api-1 StartedAt=2026-11-14T16:49:55.032412089Z
/mtusi-lab6-api-2 StartedAt=2026-11-14T16:49:55.050545756Z
/mtusi-lab6-broker-1 StartedAt=2026-11-14T16:49:15.259657001Z
/mtusi-lab6-db-1 StartedAt=2026-11-14T16:49:14.320050542Z
/mtusi-lab6-grafana-1 StartedAt=2026-11-14T16:49:51.847435254Z
/mtusi-lab6-janitor-1 StartedAt=2026-11-14T16:50:01.768795592Z
/mtusi-lab6-lb-1 StartedAt=2026-11-14T16:49:52.039568754Z
/mtusi-lab6-loki-1 StartedAt=2026-11-14T16:49:14.718131543Z
/mtusi-lab6-otel-collector-1 StartedAt=2026-11-14T16:49:51.721316838Z
/mtusi-lab6-prometheus-1 StartedAt=2026-11-14T16:49:14.242844667Z
/mtusi-lab6-relay-1 StartedAt=2026-11-14T16:49:52.644635255Z
/mtusi-lab6-s3-1 StartedAt=2026-11-14T16:49:31.593805009Z
/mtusi-lab6-tempo-1 StartedAt=2026-11-14T16:49:14.268103542Z
/mtusi-lab6-worker-1 StartedAt=2026-11-14T16:49:53.03559063Z
/mtusi-lab6-worker-2 StartedAt=2026-11-14T16:49:53.095083172Z
+31
View File
@@ -0,0 +1,31 @@
# containers before persistence hook
mtusi-lab6-api-1 running
mtusi-lab6-api-2 running
mtusi-lab6-broker-1 running
mtusi-lab6-db-1 running
mtusi-lab6-grafana-1 running
mtusi-lab6-janitor-1 running
mtusi-lab6-lb-1 running
mtusi-lab6-loki-1 running
mtusi-lab6-otel-collector-1 running
mtusi-lab6-prometheus-1 running
mtusi-lab6-relay-1 running
mtusi-lab6-s3-1 running
mtusi-lab6-tempo-1 running
mtusi-lab6-worker-1 running
mtusi-lab6-worker-2 running
/mtusi-lab6-api-1 StartedAt=2026-11-14T16:43:00.583307384Z
/mtusi-lab6-api-2 StartedAt=2026-11-14T16:43:00.486442175Z
/mtusi-lab6-broker-1 StartedAt=2026-11-14T16:30:52.87736913Z
/mtusi-lab6-db-1 StartedAt=2026-11-14T16:30:51.784140171Z
/mtusi-lab6-grafana-1 StartedAt=2026-11-14T16:31:29.408673591Z
/mtusi-lab6-janitor-1 StartedAt=2026-11-14T16:31:39.370602721Z
/mtusi-lab6-lb-1 StartedAt=2026-11-14T16:31:29.561086425Z
/mtusi-lab6-loki-1 StartedAt=2026-11-14T16:45:53.916555047Z
/mtusi-lab6-otel-collector-1 StartedAt=2026-11-14T16:48:09.464906346Z
/mtusi-lab6-prometheus-1 StartedAt=2026-11-14T16:30:51.763339921Z
/mtusi-lab6-relay-1 StartedAt=2026-11-14T16:31:30.106400633Z
/mtusi-lab6-s3-1 StartedAt=2026-11-14T16:31:09.195494721Z
/mtusi-lab6-tempo-1 StartedAt=2026-11-14T16:45:53.916584255Z
/mtusi-lab6-worker-1 StartedAt=2026-11-14T16:34:32.878140718Z
/mtusi-lab6-worker-2 StartedAt=2026-11-14T16:34:32.959219593Z
+598
View File
@@ -0,0 +1,598 @@
{
"dashboard": {
"uid": "messenger-overview",
"title": "Messenger — наблюдаемость (lab6)",
"provisioned": true,
"folder": "Messenger",
"panels": 56
},
"datasources": [
"loki",
"prometheus",
"tempo"
],
"datasource_health": {
"prometheus": "OK",
"loki": "OK",
"tempo": "OK"
},
"panels": [
{
"panel": "RPS бизнес-запросов",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "5xx, доля (2m)",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "p95 API (5m)",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "SLO доступности, 7d",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Остаток error budget, 7d",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Time to ready p95",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Ready lag очереди",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Alerts firing",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "История alerts (pending/firing -> resolved)",
"ref": "A",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "RPS по маршруту",
"ref": "A",
"datasource": "prometheus",
"series": 9,
"ok": true
},
{
"panel": "Ответы по классу статуса",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Доля 5xx: API и LB",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Доля 5xx: API и LB",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Задержка API p50/p95/p99 (из histogram)",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Задержка API p50/p95/p99 (из histogram)",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Задержка API p50/p95/p99 (из histogram)",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "p95 по маршруту",
"ref": "A",
"datasource": "prometheus",
"series": 8,
"ok": true
},
{
"panel": "5xx по причине (error.type)",
"ref": "A",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "Запросы в обработке (saturation API)",
"ref": "A",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "HAProxy: UP-реплики и очередь LB",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "HAProxy: UP-реплики и очередь LB",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Задания по исходу (в минуту)",
"ref": "A",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "Длительность обработки job p50/p95/p99",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Длительность обработки job p50/p95/p99",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Длительность обработки job p50/p95/p99",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Time to ready p50/p95/p99",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Time to ready p50/p95/p99",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Time to ready p50/p95/p99",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Глубина очереди: PostgreSQL и RabbitMQ",
"ref": "A",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "Глубина очереди: PostgreSQL и RabbitMQ",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Глубина очереди: PostgreSQL и RabbitMQ",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Глубина очереди: PostgreSQL и RabbitMQ",
"ref": "D",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Глубина очереди: PostgreSQL и RabbitMQ",
"ref": "E",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Возраст старейшего задания и lag",
"ref": "A",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "Возраст старейшего задания и lag",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Возраст старейшего задания и lag",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Ожидание в очереди p95 (до claim)",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Ожидание в очереди p95 (до claim)",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Saturation worker: занятость потребителей",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Saturation worker: занятость потребителей",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Relay: публикации outbox",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Пул соединений API: used / idle / max",
"ref": "A",
"datasource": "prometheus",
"series": 4,
"ok": true
},
{
"panel": "Пул соединений API: used / idle / max",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Ожидающие соединение и таймауты пула",
"ref": "A",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "Ожидающие соединение и таймауты пула",
"ref": "B",
"datasource": "prometheus",
"series": 2,
"ok": true
},
{
"panel": "Ожидание соединения пула p95",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Операции БД p95 по операции (API)",
"ref": "A",
"datasource": "prometheus",
"series": 13,
"ok": true
},
{
"panel": "Операции БД worker/relay p95",
"ref": "A",
"datasource": "prometheus",
"series": 5,
"ok": true
},
{
"panel": "Ошибки операций БД",
"ref": "A",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "S3 p95 по операции",
"ref": "A",
"datasource": "prometheus",
"series": 4,
"ok": true
},
{
"panel": "S3 ошибки",
"ref": "A",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "CPU, ядер (cgroup контейнера)",
"ref": "A",
"datasource": "prometheus",
"series": 6,
"ok": true
},
{
"panel": "CPU saturation: доля лимита",
"ref": "A",
"datasource": "prometheus",
"series": 6,
"ok": true
},
{
"panel": "Память контейнеров приложений",
"ref": "A",
"datasource": "prometheus",
"series": 6,
"ok": true
},
{
"panel": "Память: доля лимита",
"ref": "A",
"datasource": "prometheus",
"series": 6,
"ok": true
},
{
"panel": "Память telemetry-стека (RSS)",
"ref": "A",
"datasource": "prometheus",
"series": 3,
"ok": true
},
{
"panel": "Память telemetry-стека (RSS)",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Память telemetry-стека (RSS)",
"ref": "C",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Память telemetry-стека (RSS)",
"ref": "D",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "CPU telemetry-стека",
"ref": "A",
"datasource": "prometheus",
"series": 3,
"ok": true
},
{
"panel": "CPU telemetry-стека",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: принято / отправлено / потеряно (spans)",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: принято / отправлено / потеряно (spans)",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: принято / отправлено / потеряно (spans)",
"ref": "C",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "Collector: принято / отправлено / потеряно (spans)",
"ref": "D",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "Collector: принято / отправлено / потеряно (spans)",
"ref": "E",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: логи",
"ref": "A",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: логи",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Collector: логи",
"ref": "C",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "Collector: логи",
"ref": "D",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "Collector: очередь экспортёров",
"ref": "A",
"datasource": "prometheus",
"series": 3,
"ok": true
},
{
"panel": "Collector: очередь экспортёров",
"ref": "B",
"datasource": "prometheus",
"series": 3,
"ok": true
},
{
"panel": "SDK приложений: потери на стороне процесса",
"ref": "A",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "SDK приложений: потери на стороне процесса",
"ref": "B",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "SDK приложений: потери на стороне процесса",
"ref": "C",
"datasource": "prometheus",
"series": 0,
"ok": true
},
{
"panel": "SDK: заполнение очереди BatchSpanProcessor",
"ref": "A",
"datasource": "prometheus",
"series": 6,
"ok": true
},
{
"panel": "SDK: заполнение очереди BatchSpanProcessor",
"ref": "B",
"datasource": "prometheus",
"series": 1,
"ok": true
},
{
"panel": "Логи WARN/ERROR приложений (Loki)",
"ref": "A",
"datasource": "loki",
"lines": 20,
"ok": true
},
{
"panel": "HTTP 5xx (event=http.request)",
"ref": "A",
"datasource": "loki",
"lines": 20,
"ok": true
},
{
"panel": "Последние трассы обработки заданий (Tempo)",
"ref": "A",
"datasource": "tempo",
"traces": 5,
"ok": true
},
{
"panel": "Медленные запросы API > 1 s (Tempo)",
"ref": "A",
"datasource": "tempo",
"traces": 5,
"ok": true
},
{
"panel": "Трассы с ошибкой (Tempo)",
"ref": "A",
"datasource": "tempo",
"traces": 5,
"ok": true
}
],
"query_errors": [],
"empty_required_panels": [],
"pass": true
}
+86
View File
@@ -0,0 +1,86 @@
# 2026-11-14T16:51:33Z python3 student-tests/dashboard_check.py --output evidence/dashboard-check.json
warmup: {'requests': 574, 'ok': 574, 'codes': {'200': 246, '201': 246, '202': 82}, 'error_ratio_5xx': 0.0, 'ok_rps': 14.3, 'p50_ms': 8.4, 'p95_ms': 22.0, 'p99_ms': 58.4}
ok RPS бизнес-запросов prometheus 1
ok 5xx, доля (2m) prometheus 1
ok p95 API (5m) prometheus 1
ok SLO доступности, 7d prometheus 1
ok Остаток error budget, 7d prometheus 1
ok Time to ready p95 prometheus 1
ok Ready lag очереди prometheus 1
ok Alerts firing prometheus 1
ok История alerts (pending/firing -> resolved) prometheus 0
ok RPS по маршруту prometheus 9
ok Ответы по классу статуса prometheus 1
ok Доля 5xx: API и LB prometheus 1
ok Доля 5xx: API и LB prometheus 1
ok Задержка API p50/p95/p99 (из histogram) prometheus 1
ok Задержка API p50/p95/p99 (из histogram) prometheus 1
ok Задержка API p50/p95/p99 (из histogram) prometheus 1
ok p95 по маршруту prometheus 8
ok 5xx по причине (error.type) prometheus 0
ok Запросы в обработке (saturation API) prometheus 2
ok HAProxy: UP-реплики и очередь LB prometheus 1
ok HAProxy: UP-реплики и очередь LB prometheus 1
ok Задания по исходу (в минуту) prometheus 2
ok Длительность обработки job p50/p95/p99 prometheus 1
ok Длительность обработки job p50/p95/p99 prometheus 1
ok Длительность обработки job p50/p95/p99 prometheus 1
ok Time to ready p50/p95/p99 prometheus 1
ok Time to ready p50/p95/p99 prometheus 1
ok Time to ready p50/p95/p99 prometheus 1
ok Глубина очереди: PostgreSQL и RabbitMQ prometheus 2
ok Глубина очереди: PostgreSQL и RabbitMQ prometheus 1
ok Глубина очереди: PostgreSQL и RabbitMQ prometheus 1
ok Глубина очереди: PostgreSQL и RabbitMQ prometheus 1
ok Глубина очереди: PostgreSQL и RabbitMQ prometheus 1
ok Возраст старейшего задания и lag prometheus 2
ok Возраст старейшего задания и lag prometheus 1
ok Возраст старейшего задания и lag prometheus 1
ok Ожидание в очереди p95 (до claim) prometheus 1
ok Ожидание в очереди p95 (до claim) prometheus 1
ok Saturation worker: занятость потребителей prometheus 1
ok Saturation worker: занятость потребителей prometheus 1
ok Relay: публикации outbox prometheus 1
ok Пул соединений API: used / idle / max prometheus 4
ok Пул соединений API: used / idle / max prometheus 1
ok Ожидающие соединение и таймауты пула prometheus 2
ok Ожидающие соединение и таймауты пула prometheus 2
ok Ожидание соединения пула p95 prometheus 1
ok Операции БД p95 по операции (API) prometheus 13
ok Операции БД worker/relay p95 prometheus 5
ok Ошибки операций БД prometheus 0
ok S3 p95 по операции prometheus 4
ok S3 ошибки prometheus 0
ok CPU, ядер (cgroup контейнера) prometheus 6
ok CPU saturation: доля лимита prometheus 6
ok Память контейнеров приложений prometheus 6
ok Память: доля лимита prometheus 6
ok Память telemetry-стека (RSS) prometheus 3
ok Память telemetry-стека (RSS) prometheus 1
ok Память telemetry-стека (RSS) prometheus 1
ok Память telemetry-стека (RSS) prometheus 1
ok CPU telemetry-стека prometheus 3
ok CPU telemetry-стека prometheus 1
ok Collector: принято / отправлено / потеряно (spans) prometheus 1
ok Collector: принято / отправлено / потеряно (spans) prometheus 1
ok Collector: принято / отправлено / потеряно (spans) prometheus 0
ok Collector: принято / отправлено / потеряно (spans) prometheus 0
ok Collector: принято / отправлено / потеряно (spans) prometheus 1
ok Collector: логи prometheus 1
ok Collector: логи prometheus 1
ok Collector: логи prometheus 0
ok Collector: логи prometheus 0
ok Collector: очередь экспортёров prometheus 3
ok Collector: очередь экспортёров prometheus 3
ok SDK приложений: потери на стороне процесса prometheus 0
ok SDK приложений: потери на стороне процесса prometheus 0
ok SDK приложений: потери на стороне процесса prometheus 0
ok SDK: заполнение очереди BatchSpanProcessor prometheus 6
ok SDK: заполнение очереди BatchSpanProcessor prometheus 1
ok Логи WARN/ERROR приложений (Loki) loki 20
ok HTTP 5xx (event=http.request) loki 20
ok Последние трассы обработки заданий (Tempo) tempo 5
ok Медленные запросы API > 1 s (Tempo) tempo 5
ok Трассы с ошибкой (Tempo) tempo 5
{"dashboard": {"uid": "messenger-overview", "title": "Messenger — наблюдаемость (lab6)", "provisioned": true, "folder": "Messenger", "panels": 56}, "datasource_health": {"prometheus": "OK", "loki": "OK", "tempo": "OK"}, "query_errors": [], "empty_required_panels": [], "pass": true}
exit=0
+32
View File
@@ -0,0 +1,32 @@
{
"scenario": "worker drain benchmark (after-fix)",
"date_utc": "2026-11-14T17:00:28+00:00",
"steps": [
{
"t": 2.78,
"utc": "16:59:46.305",
"step": "backlog created with workers stopped",
"uploads": 240
},
{
"t": 44.66,
"utc": "17:00:28.179",
"step": "drained",
"uploads": 240,
"drain_seconds_after_workers_up": 11.0,
"jobs_per_second_wallclock": 21.89,
"workers_x_concurrency": 8.0,
"utilization_peak_1m": 0.213,
"job_duration_p50_s": NaN,
"worker_cpu_cores_peak": 1.197
}
],
"label": "after-fix",
"uploads": 240,
"drain_seconds_after_workers_up": 11.0,
"jobs_per_second_wallclock": 21.89,
"workers_x_concurrency": 8.0,
"utilization_peak_1m": 0.213,
"job_duration_p50_s": NaN,
"worker_cpu_cores_peak": 1.197
}
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-14T16:59:43Z python3 student-tests/drain_bench.py --count 240 --label after-fix --output evidence/drain-bench-after.json
[ 2.78s] backlog created with workers stopped {"uploads": 240}
[ 44.66s] drained {"uploads": 240, "drain_seconds_after_workers_up": 11.0, "jobs_per_second_wallclock": 21.89, "workers_x_concurrency": 8.0, "utilization_peak_1m": 0.213, "job_duration_p50_s": NaN, "worker_cpu_cores_peak": 1.197}
PASS: after-fix drained 240 jobs in 11.0s (21.9 jobs/s)
exit=0
+32
View File
@@ -0,0 +1,32 @@
{
"scenario": "worker drain benchmark (before-fix)",
"date_utc": "2026-11-14T16:59:32+00:00",
"steps": [
{
"t": 3.65,
"utc": "16:58:35.204",
"step": "backlog created with workers stopped",
"uploads": 240
},
{
"t": 60.81,
"utc": "16:59:32.366",
"step": "drained",
"uploads": 240,
"drain_seconds_after_workers_up": 26.2,
"jobs_per_second_wallclock": 9.18,
"workers_x_concurrency": 4.0,
"utilization_peak_1m": 0.473,
"job_duration_p50_s": 0.222,
"worker_cpu_cores_peak": 1.136
}
],
"label": "before-fix",
"uploads": 240,
"drain_seconds_after_workers_up": 26.2,
"jobs_per_second_wallclock": 9.18,
"workers_x_concurrency": 4.0,
"utilization_peak_1m": 0.473,
"job_duration_p50_s": 0.222,
"worker_cpu_cores_peak": 1.136
}
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-14T16:58:31Z python3 student-tests/drain_bench.py --count 240 --label before-fix --output evidence/drain-bench-before.json
[ 3.65s] backlog created with workers stopped {"uploads": 240}
[ 60.81s] drained {"uploads": 240, "drain_seconds_after_workers_up": 26.2, "jobs_per_second_wallclock": 9.18, "workers_x_concurrency": 4.0, "utilization_peak_1m": 0.473, "job_duration_p50_s": 0.222, "worker_cpu_cores_peak": 1.136}
PASS: before-fix drained 240 jobs in 26.2s (9.2 jobs/s)
exit=0
+6
View File
@@ -0,0 +1,6 @@
# 2026-11-14T16:50:02Z make test-failover ACTION_SCRIPT=scripts/stop-one.sh
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 130, "failed_attempts": 0, "first_recovery_seconds": 4.398}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
File diff suppressed because it is too large Load Diff
+25
View File
@@ -0,0 +1,25 @@
# 2026-11-14T16:37:30Z python3 student-tests/incident_db_slow.py --output evidence/incident-db-slow.json
[ 16.03s] api recreated with FAULT_INJECTION=1 (slow-handler only by header)
[ 23.35s] reference: slow handler trace {"trace_id": "c54c8f2d29db3b326c2730d9ff66d84a", "server_ms": 1515.951, "handler_compute_ms": 1505.253, "db_spans_total_ms": 7.3}
[ 23.35s] alerts before experiment {"states": {}}
[ 63.37s] baseline {"db_p95_s": 0.004413773502610202, "requests": 1218, "ok": 1218, "codes": {"200": 609, "201": 609}, "error_ratio_5xx": 0.0, "ok_rps": 35.1, "p50_ms": 10.9, "p95_ms": 23.0, "p99_ms": 36.7}
[ 63.37s] FAULT: LOCK TABLE sessions IN ACCESS EXCLUSIVE MODE held by a separate session
[ 83.55s] pg_stat_activity during incident {"active_by_wait": [["Lock", "relation", 4], ["Timeout", "PgSleep", 1]]}
[ 158.86s] alert MessengerHighErrorRate{source=api} -> pending
[ 158.86s] alert MessengerHighErrorRate{source=lb} -> pending
[ 173.92s] alert MessengerDbSlow -> pending
[ 219.08s] alert MessengerHighErrorRate{source=api} -> firing
[ 219.08s] alert MessengerHighErrorRate{source=lb} -> firing
[ 234.13s] alert MessengerDbSlow -> firing
[ 239.17s] alerts firing {"detect_s": {"MessengerHighErrorRate{source=api}": 155.7, "MessengerHighErrorRate{source=lb}": 155.7, "MessengerDbSlow": 170.8}, "api_5xx_ratio": 1.0, "db_p95_s": 5.475, "db_p95_by_op_s": {"get_session_user": 5.475}, "pool_used": 11.0, "pool_pending": 0.0, "error_types_rps": {"db_unavailable": 0.8}, "lb_up_servers": 2.0}
[ 259.18s] client view during lock {"requests": 160, "ok": 8, "codes": {"200": 4, "201": 4, "503": 152}, "error_ratio_5xx": 0.95, "ok_rps": 0.0, "p50_ms": 11.3, "p95_ms": 11.8, "p99_ms": 11.8}
[ 259.35s] RECOVERY: lock holder terminated {"terminated": 1, "lock_s": 195.8}
[ 294.45s] alert MessengerDbSlow resolved {"after_release_s": 35.3}
[ 309.58s] alert MessengerHighErrorRate{source=api} resolved {"after_release_s": 50.4}
[ 309.58s] alert MessengerHighErrorRate{source=lb} resolved {"after_release_s": 50.4}
[ 324.58s] after recovery {"requests": 352, "ok": 352, "codes": {"200": 176, "201": 176}, "error_ratio_5xx": 0.0, "ok_rps": 35.8, "p50_ms": 10.9, "p95_ms": 24.3, "p99_ms": 46.4}
[ 324.85s] error trace during lock {"trace_id": "186875d9b7250b947e79e9e2e2d7da4c", "server_ms": 5006.021, "slowest_db_span": "db get_session_user", "slowest_db_ms": 5004.691, "db_share": 1.0, "error_type": ["db_unavailable"]}
[ 324.89s] API logs event=db.unavailable (Loki) {"count": 152, "sample_trace_id": "4003216644d91fa911f914f164ba06e6", "sample_error_type": "db_unavailable", "sample": "database unavailable request_id=0009c50ab423433eb2ad84d3acba99ec (QueryCanceled)"}
[ 335.18s] api restored with FAULT_INJECTION=0
PASS: DB lock detected {'MessengerHighErrorRate{source=api}': 155.7, 'MessengerHighErrorRate{source=lb}': 155.7, 'MessengerDbSlow': 170.8}; resolved after release {'MessengerDbSlow': 35.3, 'MessengerHighErrorRate{source=api}': 50.4, 'MessengerHighErrorRate{source=lb}': 50.4}
exit=0
File diff suppressed because it is too large Load Diff
+17
View File
@@ -0,0 +1,17 @@
# 2026-11-14T16:31:40Z python3 student-tests/incident_worker_stop.py --output evidence/incident-worker-stop.json
[ 0.48s] traffic started {"threads": 4, "think_s": 0.2, "upload_every": 4}
[ 45.49s] baseline {"requests": 1584, "ok": 1584, "codes": {"200": 704, "201": 704, "202": 176}, "error_ratio_5xx": 0.0, "ok_rps": 39.7, "p50_ms": 8.4, "p95_ms": 20.2, "p99_ms": 37.0}
[ 46.95s] FAULT: docker compose stop worker {"running": []}
[ 46.98s] alert MessengerQueueLagGrowing -> inactive
[ 92.09s] alert MessengerQueueLagGrowing -> pending
[ 152.29s] alert MessengerQueueLagGrowing -> firing
[ 152.31s] alert firing {"detect_s": 106.8, "ready_lag_s": 105.109317, "queued_jobs_db": 456.0, "rabbitmq_ready": 455.0}
[ 172.32s] API during worker outage {"requests": 4952, "ok": 4952, "codes": {"200": 2200, "201": 2200, "202": 552}, "error_ratio_5xx": 0.0, "ok_rps": 39.1, "p50_ms": 9.9, "p95_ms": 20.1, "p99_ms": 39.8}
[ 178.39s] RECOVERY: docker compose up worker {"outage_s": 126.8}
[ 253.82s] alert resolved {"after_worker_start_s": 81.5, "ready_lag_s": 62.089227}
[ 332.12s] backlog drained: ready lag < 5 s {"after_worker_start_s": 159.8, "queued_jobs_db": 20.0}
[ 350.14s] after recovery {"requests": 743, "ok": 743, "codes": {"200": 330, "201": 330, "202": 83}, "error_ratio_5xx": 0.0, "ok_rps": 41.4, "p50_ms": 5.6, "p95_ms": 14.7, "p99_ms": 29.8}
[ 350.56s] trace of an upload accepted during outage {"trace_id": "0892d3393587abe986ca6166ea70f698", "publish_to_consume_gap_s": 97.5, "process_ms": 238.965, "queue_wait_attr_s": 97.473}
[ 350.58s] worker lifecycle logs (Loki) {"events": [[0.3, "worker.draining", "ff3fb8ef2677"], [0.3, "worker.draining", "ff6ca1cafae0"], [1.1, "worker.stopped", "ff3fb8ef2677"], [1.1, "worker.stopped", "ff6ca1cafae0"], [127.8, "worker.started", "ff3fb8ef2677"], [127.8, "worker.started", "ff6ca1cafae0"]]}
PASS: worker outage detected in 107s, alert resolved 81s after restart, drained 160s after restart; API 5xx during outage 0.00%
exit=0
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 6,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.095,
"concurrency": 4,
"successful_requests": 14173,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 470.945,
"successful_latency_ms": {
"p50": 4.816,
"p95": 37.61,
"p99": 56.307
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+19
View File
@@ -0,0 +1,19 @@
# 2026-11-14T16:50:52Z python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
{
"lab": 6,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.095,
"concurrency": 4,
"successful_requests": 14173,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 470.945,
"successful_latency_ms": {
"p50": 4.816,
"p95": 37.61,
"p99": 56.307
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
exit=0
+296
View File
@@ -0,0 +1,296 @@
{
"scenario": "lab6 signal correlation: request -> trace -> log, upload -> relay -> worker",
"date_utc": "2026-11-14T17:01:26+00:00",
"steps": [
{
"t": 0.51,
"utc": "17:00:59.796",
"step": "message sent",
"request_id": "f59ccc9eae9f4e118ad806399fc7cdda",
"trace_id": "b2f0dd26b5b1e1d1410c2d357a69e36e",
"instance": "670c04e57dee"
},
{
"t": 2.6,
"utc": "17:01:01.884",
"step": "message trace in Tempo",
"spans": 4,
"server_ms": 2.281,
"db_spans": [
"db get_session_user",
"db get_chat_for",
"db add_message"
]
},
{
"t": 2.62,
"utc": "17:01:01.907",
"step": "structured API log in Loki",
"event": "http.request",
"trace_id": "b2f0dd26b5b1e1d1410c2d357a69e36e",
"span_id": "aedaa74d918d11cb",
"severity": "INFO",
"service_name": "messenger-api",
"line": "POST /api/v1/chats/{chat_id}/messages -> 201 2.2ms request_id=f59ccc9eae9f4e118ad806399fc7cdda"
},
{
"t": 2.96,
"utc": "17:01:02.251",
"step": "upload accepted and ready",
"attachment_id": "0020bba2-7684-49fc-ae0e-05e30e9ee64f",
"trace_id": "69a4cabe0565f4477758b30a0ffe8958",
"status": "ready"
},
{
"t": 6.06,
"utc": "17:01:05.352",
"step": "one trace upload -> relay -> worker",
"spans": 26,
"services": [
"messenger-api",
"messenger-relay",
"messenger-worker"
],
"job_id": "bb3deb41-b32a-4109-9056-ba8d47c280f6",
"outbox_traceparent": "00-69a4cabe0565f4477758b30a0ffe8958-c31e4d41fac37f54-03",
"process_parent_is_send": true,
"send_parent_is_create": true,
"worker_s3_puts": 4,
"api_to_worker_gap_ms": 2.4,
"process_ms": 132.022,
"outcome": "ready"
},
{
"t": 6.07,
"utc": "17:01:05.362",
"step": "worker structured logs in Loki by trace_id",
"events": [
"job.claimed",
"job.completed"
],
"job_id": "bb3deb41-b32a-4109-9056-ba8d47c280f6",
"span_id": "01c12371a60672d0",
"line": "job bb3deb41-b32a-4109-9056-ba8d47c280f6 attempt 1 -> ready in 127ms"
},
{
"t": 16.73,
"utc": "17:01:16.017",
"step": "retry chain in one trace",
"trace_id": "c44375212d405aabc788b452a755b889",
"attempts": 2,
"outcomes": [
"retry",
"ready"
],
"retry_delay_s": 1.01,
"error_type": "storage_unavailable"
},
{
"t": 23.66,
"utc": "17:01:22.948",
"step": "worker restored without fault injection"
},
{
"t": 26.97,
"utc": "17:01:26.261",
"step": "no secrets/bodies in telemetry, no ID labels in metrics",
"leaks": {
"loki:message_text": 0,
"loki:password": 0,
"loki:token": 0,
"loki:filename": 0,
"tempo:message_text": 0,
"tempo:password": 0,
"tempo:token": 0,
"tempo:filename": 0
},
"metric_labels": [
"__name__",
"db_client_connection_pool_name",
"db_client_connection_state",
"db_operation_name",
"db_system_name",
"deployment_environment_name",
"docker_cli_cobra_command_path",
"error_type",
"http_request_method",
"http_response_status_class",
"http_response_status_code",
"http_route",
"instance",
"job",
"le",
"messenger_job_outcome",
"messenger_job_status",
"messenger_job_type",
"messenger_s3_operation",
"otel_component_name",
"otel_component_type",
"otel_span_parent_origin",
"otel_span_sampling_result",
"outcome",
"server_address",
"server_port",
"service_version",
"telemetry_sdk_language",
"telemetry_sdk_name",
"telemetry_sdk_version"
]
}
],
"message_trace_tree": [
"POST /api/v1/chats/{chat_id}/messages messenger-api + 0.0ms 2.3ms SERVER",
" db get_session_user messenger-api + 0.1ms 0.4ms CLIENT",
" db get_chat_for messenger-api + 0.6ms 0.3ms CLIENT",
" db add_message messenger-api + 1.0ms 1.1ms CLIENT"
],
"message": {
"request_id": "f59ccc9eae9f4e118ad806399fc7cdda",
"trace_id": "b2f0dd26b5b1e1d1410c2d357a69e36e",
"loki_labels": [
"code_file_path",
"code_function_name",
"code_line_number",
"deployment_environment_name",
"detected_level",
"duration_ms",
"event",
"flags",
"http_request_method",
"http_response_status_code",
"http_route",
"observed_timestamp",
"request_id",
"scope_name",
"service_instance_id",
"service_name",
"service_version",
"severity_number",
"severity_text",
"span_id",
"telemetry_sdk_language",
"telemetry_sdk_name",
"telemetry_sdk_version",
"trace_id"
]
},
"upload_trace_tree": [
"POST /api/v1/chats/{chat_id}/attachments messenger-api + 0.0ms 20.2ms SERVER",
" db get_session_user messenger-api + 0.5ms 1.5ms CLIENT",
" db get_chat_for messenger-api + 2.2ms 1.4ms CLIENT",
" http.receive_body messenger-api + 4.5ms 0.5ms INTERNAL",
" image.validate messenger-api + 5.1ms 1.4ms INTERNAL",
" db create_pending_attachment messenger-api + 6.7ms 3.1ms CLIENT",
" s3 PutObject messenger-api + 10.1ms 4.1ms CLIENT",
" db enqueue_attachment messenger-api + 14.4ms 5.3ms CLIENT",
" db jobs.enqueue messenger-api + 14.8ms 3.9ms CLIENT",
" attachment.process.v1 create messenger-api + 18.3ms 0.4ms PRODUCER",
" attachments send messenger-relay + 20.5ms 2.3ms PRODUCER",
" attachments.process.v1 process messenger-worker + 22.6ms 132.0ms CONSUMER",
" db jobs.claim messenger-worker + 23.3ms 2.2ms CLIENT",
" db jobs.heartbeat messenger-worker + 26.7ms 0.2ms CLIENT",
" worker.fetch_staging messenger-worker + 27.4ms 1.6ms INTERNAL",
" s3 GetObject messenger-worker + 27.4ms 1.2ms CLIENT",
" db jobs.heartbeat messenger-worker + 29.1ms 0.2ms CLIENT",
" worker.transform messenger-worker + 29.6ms 115.5ms INTERNAL",
" db jobs.heartbeat messenger-worker + 145.3ms 0.3ms CLIENT",
" s3 PutObject messenger-worker + 146.3ms 2.5ms CLIENT",
" s3 PutObject messenger-worker + 148.9ms 0.9ms CLIENT",
" s3 PutObject messenger-worker + 149.9ms 0.8ms CLIENT",
" s3 PutObject messenger-worker + 150.8ms 0.6ms CLIENT",
" db jobs.heartbeat messenger-worker + 151.6ms 0.2ms CLIENT",
" db jobs.complete messenger-worker + 152.2ms 0.8ms CLIENT",
" s3 DeleteObject messenger-worker + 153.5ms 0.6ms CLIENT"
],
"upload": {
"attachment_id": "0020bba2-7684-49fc-ae0e-05e30e9ee64f",
"job_id": "bb3deb41-b32a-4109-9056-ba8d47c280f6",
"trace_id": "69a4cabe0565f4477758b30a0ffe8958",
"worker_log_events": [
"job.claimed",
"job.completed"
]
},
"retry_trace_tree": [
"POST /api/v1/chats/{chat_id}/attachments messenger-api + 0.0ms 15.1ms SERVER",
" db get_session_user messenger-api + 0.2ms 1.2ms CLIENT",
" db get_chat_for messenger-api + 1.6ms 1.2ms CLIENT",
" http.receive_body messenger-api + 3.1ms 0.3ms INTERNAL",
" image.validate messenger-api + 3.5ms 1.6ms INTERNAL",
" db create_pending_attachment messenger-api + 5.2ms 1.2ms CLIENT",
" s3 PutObject messenger-api + 6.6ms 4.4ms CLIENT",
" db enqueue_attachment messenger-api + 11.1ms 3.3ms CLIENT",
" db jobs.enqueue messenger-api + 11.7ms 1.6ms CLIENT",
" attachment.process.v1 create messenger-api + 13.0ms 0.3ms PRODUCER",
" attachments send messenger-relay + 15.7ms 2.9ms PRODUCER",
" attachments.process.v1 process messenger-worker + 18.8ms 14.3ms CONSUMER",
" db jobs.claim messenger-worker + 25.3ms 4.1ms CLIENT",
" db jobs.fail_or_retry messenger-worker + 30.3ms 2.1ms CLIENT",
" attachment.process.v1 create messenger-worker + 31.2ms 1.1ms PRODUCER",
" attachments send messenger-relay + 1037.8ms 2.2ms PRODUCER",
" attachments.process.v1 process messenger-worker + 1039.8ms 134.8ms CONSUMER",
" db jobs.claim messenger-worker + 1043.4ms 2.8ms CLIENT",
" db jobs.heartbeat messenger-worker + 1046.7ms 0.2ms CLIENT",
" worker.fetch_staging messenger-worker + 1047.9ms 1.7ms INTERNAL",
" s3 GetObject messenger-worker + 1048.0ms 1.4ms CLIENT",
" db jobs.heartbeat messenger-worker + 1049.8ms 0.2ms CLIENT",
" worker.transform messenger-worker + 1050.3ms 113.9ms INTERNAL",
" db jobs.heartbeat messenger-worker + 1164.4ms 0.3ms CLIENT",
" s3 PutObject messenger-worker + 1165.4ms 2.7ms CLIENT",
" s3 PutObject messenger-worker + 1168.2ms 1.1ms CLIENT",
" s3 PutObject messenger-worker + 1169.4ms 0.7ms CLIENT",
" s3 PutObject messenger-worker + 1170.2ms 0.6ms CLIENT",
" db jobs.heartbeat messenger-worker + 1171.1ms 0.3ms CLIENT",
" db jobs.complete messenger-worker + 1171.9ms 1.1ms CLIENT",
" s3 DeleteObject messenger-worker + 1173.5ms 0.6ms CLIENT"
],
"retry": {
"trace_id": "c44375212d405aabc788b452a755b889",
"outcomes": [
"retry",
"ready"
]
},
"leaks": {
"loki:message_text": 0,
"loki:password": 0,
"loki:token": 0,
"loki:filename": 0,
"tempo:message_text": 0,
"tempo:password": 0,
"tempo:token": 0,
"tempo:filename": 0
},
"metric_labels": [
"__name__",
"db_client_connection_pool_name",
"db_client_connection_state",
"db_operation_name",
"db_system_name",
"deployment_environment_name",
"docker_cli_cobra_command_path",
"error_type",
"http_request_method",
"http_response_status_class",
"http_response_status_code",
"http_route",
"instance",
"job",
"le",
"messenger_job_outcome",
"messenger_job_status",
"messenger_job_type",
"messenger_s3_operation",
"otel_component_name",
"otel_component_type",
"otel_span_parent_origin",
"otel_span_sampling_result",
"outcome",
"server_address",
"server_port",
"service_version",
"telemetry_sdk_language",
"telemetry_sdk_name",
"telemetry_sdk_version"
]
}
+66
View File
@@ -0,0 +1,66 @@
# message trace b2f0dd26b5b1e1d1410c2d357a69e36e
POST /api/v1/chats/{chat_id}/messages messenger-api + 0.0ms 2.3ms SERVER
db get_session_user messenger-api + 0.1ms 0.4ms CLIENT
db get_chat_for messenger-api + 0.6ms 0.3ms CLIENT
db add_message messenger-api + 1.0ms 1.1ms CLIENT
# upload trace 69a4cabe0565f4477758b30a0ffe8958
POST /api/v1/chats/{chat_id}/attachments messenger-api + 0.0ms 20.2ms SERVER
db get_session_user messenger-api + 0.5ms 1.5ms CLIENT
db get_chat_for messenger-api + 2.2ms 1.4ms CLIENT
http.receive_body messenger-api + 4.5ms 0.5ms INTERNAL
image.validate messenger-api + 5.1ms 1.4ms INTERNAL
db create_pending_attachment messenger-api + 6.7ms 3.1ms CLIENT
s3 PutObject messenger-api + 10.1ms 4.1ms CLIENT
db enqueue_attachment messenger-api + 14.4ms 5.3ms CLIENT
db jobs.enqueue messenger-api + 14.8ms 3.9ms CLIENT
attachment.process.v1 create messenger-api + 18.3ms 0.4ms PRODUCER
attachments send messenger-relay + 20.5ms 2.3ms PRODUCER
attachments.process.v1 process messenger-worker + 22.6ms 132.0ms CONSUMER
db jobs.claim messenger-worker + 23.3ms 2.2ms CLIENT
db jobs.heartbeat messenger-worker + 26.7ms 0.2ms CLIENT
worker.fetch_staging messenger-worker + 27.4ms 1.6ms INTERNAL
s3 GetObject messenger-worker + 27.4ms 1.2ms CLIENT
db jobs.heartbeat messenger-worker + 29.1ms 0.2ms CLIENT
worker.transform messenger-worker + 29.6ms 115.5ms INTERNAL
db jobs.heartbeat messenger-worker + 145.3ms 0.3ms CLIENT
s3 PutObject messenger-worker + 146.3ms 2.5ms CLIENT
s3 PutObject messenger-worker + 148.9ms 0.9ms CLIENT
s3 PutObject messenger-worker + 149.9ms 0.8ms CLIENT
s3 PutObject messenger-worker + 150.8ms 0.6ms CLIENT
db jobs.heartbeat messenger-worker + 151.6ms 0.2ms CLIENT
db jobs.complete messenger-worker + 152.2ms 0.8ms CLIENT
s3 DeleteObject messenger-worker + 153.5ms 0.6ms CLIENT
# retry trace c44375212d405aabc788b452a755b889
POST /api/v1/chats/{chat_id}/attachments messenger-api + 0.0ms 15.1ms SERVER
db get_session_user messenger-api + 0.2ms 1.2ms CLIENT
db get_chat_for messenger-api + 1.6ms 1.2ms CLIENT
http.receive_body messenger-api + 3.1ms 0.3ms INTERNAL
image.validate messenger-api + 3.5ms 1.6ms INTERNAL
db create_pending_attachment messenger-api + 5.2ms 1.2ms CLIENT
s3 PutObject messenger-api + 6.6ms 4.4ms CLIENT
db enqueue_attachment messenger-api + 11.1ms 3.3ms CLIENT
db jobs.enqueue messenger-api + 11.7ms 1.6ms CLIENT
attachment.process.v1 create messenger-api + 13.0ms 0.3ms PRODUCER
attachments send messenger-relay + 15.7ms 2.9ms PRODUCER
attachments.process.v1 process messenger-worker + 18.8ms 14.3ms CONSUMER
db jobs.claim messenger-worker + 25.3ms 4.1ms CLIENT
db jobs.fail_or_retry messenger-worker + 30.3ms 2.1ms CLIENT
attachment.process.v1 create messenger-worker + 31.2ms 1.1ms PRODUCER
attachments send messenger-relay + 1037.8ms 2.2ms PRODUCER
attachments.process.v1 process messenger-worker + 1039.8ms 134.8ms CONSUMER
db jobs.claim messenger-worker + 1043.4ms 2.8ms CLIENT
db jobs.heartbeat messenger-worker + 1046.7ms 0.2ms CLIENT
worker.fetch_staging messenger-worker + 1047.9ms 1.7ms INTERNAL
s3 GetObject messenger-worker + 1048.0ms 1.4ms CLIENT
db jobs.heartbeat messenger-worker + 1049.8ms 0.2ms CLIENT
worker.transform messenger-worker + 1050.3ms 113.9ms INTERNAL
db jobs.heartbeat messenger-worker + 1164.4ms 0.3ms CLIENT
s3 PutObject messenger-worker + 1165.4ms 2.7ms CLIENT
s3 PutObject messenger-worker + 1168.2ms 1.1ms CLIENT
s3 PutObject messenger-worker + 1169.4ms 0.7ms CLIENT
s3 PutObject messenger-worker + 1170.2ms 0.6ms CLIENT
db jobs.heartbeat messenger-worker + 1171.1ms 0.3ms CLIENT
db jobs.complete messenger-worker + 1171.9ms 1.1ms CLIENT
s3 DeleteObject messenger-worker + 1173.5ms 0.6ms CLIENT
+12
View File
@@ -0,0 +1,12 @@
# 2026-11-14T17:00:59Z python3 student-tests/obs_correlation.py --retry --output evidence/obs-correlation.json
[ 0.51s] message sent {"request_id": "f59ccc9eae9f4e118ad806399fc7cdda", "trace_id": "b2f0dd26b5b1e1d1410c2d357a69e36e", "instance": "670c04e57dee"}
[ 2.60s] message trace in Tempo {"spans": 4, "server_ms": 2.281, "db_spans": ["db get_session_user", "db get_chat_for", "db add_message"]}
[ 2.62s] structured API log in Loki {"event": "http.request", "trace_id": "b2f0dd26b5b1e1d1410c2d357a69e36e", "span_id": "aedaa74d918d11cb", "severity": "INFO", "service_name": "messenger-api", "line": "POST /api/v1/chats/{chat_id}/messages -> 201 2.2ms request_id=f59ccc9eae9f4e118ad806399fc7cdda"}
[ 2.96s] upload accepted and ready {"attachment_id": "0020bba2-7684-49fc-ae0e-05e30e9ee64f", "trace_id": "69a4cabe0565f4477758b30a0ffe8958", "status": "ready"}
[ 6.06s] one trace upload -> relay -> worker {"spans": 26, "services": ["messenger-api", "messenger-relay", "messenger-worker"], "job_id": "bb3deb41-b32a-4109-9056-ba8d47c280f6", "outbox_traceparent": "00-69a4cabe0565f4477758b30a0ffe8958-c31e4d41fac37f54-03", "process_parent_is_send": true, "send_parent_is_create": true, "worker_s3_puts": 4, "api_to_worker_gap_ms": 2.4, "process_ms": 132.022, "outcome": "ready"}
[ 6.07s] worker structured logs in Loki by trace_id {"events": ["job.claimed", "job.completed"], "job_id": "bb3deb41-b32a-4109-9056-ba8d47c280f6", "span_id": "01c12371a60672d0", "line": "job bb3deb41-b32a-4109-9056-ba8d47c280f6 attempt 1 -> ready in 127ms"}
[ 16.73s] retry chain in one trace {"trace_id": "c44375212d405aabc788b452a755b889", "attempts": 2, "outcomes": ["retry", "ready"], "retry_delay_s": 1.01, "error_type": "storage_unavailable"}
[ 23.66s] worker restored without fault injection
[ 26.97s] no secrets/bodies in telemetry, no ID labels in metrics {"leaks": {"loki:message_text": 0, "loki:password": 0, "loki:token": 0, "loki:filename": 0, "tempo:message_text": 0, "tempo:password": 0, "tempo:token": 0, "tempo:filename": 0}, "metric_labels": ["__name__", "db_client_connection_pool_name", "db_client_connection_state", "db_operation_name", "db_system_name", "deployment_environment_name", "docker_cli_cobra_command_path", "error_type", "http_request_method", "http_response_status_class", "http_response_status_code", "http_route", "instance", "job", "le", "messenger_job_outcome", "messenger_job_status", "messenger_job_type", "messenger_s3_operation", "otel_component_name", "otel_component_type", "otel_span_parent_origin", "otel_span_sampling_result", "outcome", "server_address", "server_port", "service_version", "telemetry_sdk_language", "telemetry_sdk_name", "telemetry_sdk_version"]}
PASS: correlation request->trace->log and upload->relay->worker incl. retry
exit=0
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-14T16:49:12Z make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
+27
View File
@@ -0,0 +1,27 @@
argon2-cffi==25.1.0
argon2-cffi-bindings==26.2.0
certifi==2026.10.23
cffi==2.1.1
charset-normalizer==3.5.2
googleapis-common-protos==1.76.0
idna==3.20
minio==7.2.20
opentelemetry-api==1.45.1
opentelemetry-exporter-http-transport==0.66b1
opentelemetry-exporter-otlp-common==0.66b1
opentelemetry-exporter-otlp-proto-common==1.45.1
opentelemetry-exporter-otlp-proto-http==1.45.1
opentelemetry-proto==1.45.1
opentelemetry-sdk==1.45.1
opentelemetry-semantic-conventions==0.66b1
pika==1.3.2
pillow==13.0.0
protobuf==7.36.2
psycopg==3.2.3
psycopg-binary==3.2.3
psycopg-pool==3.2.4
pycparser==3.12
pycryptodome==4.4.0
requests==2.34.2
typing_extensions==4.16.0
urllib3==2.8.0
+4
View File
@@ -0,0 +1,4 @@
# 2026-11-14T17:00:58Z make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab6 public API scenario; infrastructure and grading evidence remain separate.
exit=0
+19
View File
@@ -0,0 +1,19 @@
# 2026-11-14T17:00:46Z ./scripts/check_rules.sh
== promtool check config (prom/prometheus:v3.13.5@sha256:aafa9d694e6a883c02db516d9f6e5b84e14195f49a2a6456a4cca815edda72b9)
Checking /etc/prometheus/prometheus.yml
SUCCESS: 1 rule files found
SUCCESS: /etc/prometheus/prometheus.yml is valid prometheus config file syntax
Checking /etc/prometheus/rules/messenger.yml
SUCCESS: 26 rules found
== promtool test rules
SUCCESS
== otelcol validate (otel/opentelemetry-collector-contrib:0.163.2@sha256:7f22d2a6748110ffb6a59bc0df448bccbf501cdb667d610ede4c61d3863d5849)
collector config OK
== loki -verify-config (grafana/loki:3.6.19@sha256:0f9cbc340cbe33ee498e654075034336962057db072f57b37f253e14d476443a)
loki config OK
== dashboard JSON is up to date with scripts/build_dashboard.py
dashboard OK
exit=0
File diff suppressed because it is too large Load Diff
+12
View File
@@ -0,0 +1,12 @@
# 2026-11-14T16:52:15Z python3 student-tests/telemetry_outage.py --output evidence/telemetry-outage.json
[ 43.46s] phase A_baseline done {"api": {"requests": 1708, "ok": 1708, "codes": {"200": 760, "201": 760, "202": 188}, "error_ratio_5xx": 0.0, "ok_rps": 40.1, "p50_ms": 8.1, "p95_ms": 20.9, "p99_ms": 46.1}, "mem": {"api-2": {"mem_mib": 44.5, "cpu": "8.81%"}, "api-1": {"mem_mib": 44.9, "cpu": "6.60%"}, "worker-1": {"mem_mib": 42.3, "cpu": "29.01%"}, "worker-2": {"mem_mib": 46.6, "cpu": "28.02%"}, "relay-1": {"mem_mib": 34.7, "cpu": "2.16%"}, "otel-collector-1": {"mem_mib": 77.7, "cpu": "0.94%"}}, "alerts": []}
[ 167.16s] phase B_tempo_loki_down done {"api": {"requests": 4998, "ok": 4998, "codes": {"200": 2221, "201": 2221, "202": 556}, "error_ratio_5xx": 0.0, "ok_rps": 40.5, "p50_ms": 6.9, "p95_ms": 19.5, "p99_ms": 37.5}, "mem": {"api-2": {"mem_mib": 44.6, "cpu": "6.04%"}, "api-1": {"mem_mib": 45.1, "cpu": "6.28%"}, "worker-1": {"mem_mib": 55.2, "cpu": "38.06%"}, "worker-2": {"mem_mib": 42.8, "cpu": "28.94%"}, "relay-1": {"mem_mib": 34.8, "cpu": "0.97%"}, "otel-collector-1": {"mem_mib": 104.7, "cpu": "1.14%"}}, "alerts": ["MessengerTelemetryBackendDown:firing:loki", "MessengerTelemetryBackendDown:firing:tempo"]}
[ 210.50s] phase C_backends_restored done {"api": {"requests": 1730, "ok": 1730, "codes": {"200": 769, "201": 769, "202": 192}, "error_ratio_5xx": 0.0, "ok_rps": 40.0, "p50_ms": 6.8, "p95_ms": 23.9, "p99_ms": 77.3}, "mem": {"api-2": {"mem_mib": 44.7, "cpu": "4.96%"}, "api-1": {"mem_mib": 45.2, "cpu": "4.86%"}, "worker-1": {"mem_mib": 42.7, "cpu": "34.46%"}, "worker-2": {"mem_mib": 42.8, "cpu": "23.68%"}, "relay-1": {"mem_mib": 34.8, "cpu": "0.81%"}, "otel-collector-1": {"mem_mib": 125.1, "cpu": "1.15%"}}, "alerts": ["MessengerTelemetryExportFailing:pending"]}
[ 210.58s] collector-side loss while Tempo+Loki were down (increase over B+C) {"spans_send_failed": 540, "spans_queue_full": 11379, "logs_send_failed": 119, "logs_queue_full": 1140, "spans_accepted": 43087, "logs_accepted": 8807, "peak_exporter_queue": {"otlp_grpc/tempo": 100.0, "otlp_http/loki": 100.0, "otlp_http/prometheus": 0.0}, "queue_capacity": 100.0, "peak_heap_mib": 100.5}
[ 303.72s] phase D_collector_down done {"api": {"requests": 3796, "ok": 3796, "codes": {"200": 1687, "201": 1687, "202": 422}, "error_ratio_5xx": 0.0, "ok_rps": 40.9, "p50_ms": 5.8, "p95_ms": 18.2, "p99_ms": 36.1}, "mem": {"api-2": {"mem_mib": 54.7, "cpu": "6.07%"}, "api-1": {"mem_mib": 53.1, "cpu": "5.22%"}, "worker-1": {"mem_mib": 46.7, "cpu": "31.66%"}, "worker-2": {"mem_mib": 47.5, "cpu": "31.51%"}, "relay-1": {"mem_mib": 36.3, "cpu": "0.84%"}}, "alerts": ["MessengerTelemetryBackendDown:firing:otel-collector", "MessengerTelemetryExportFailing:firing"]}
[ 351.50s] phase E_collector_restored done {"api": {"requests": 1970, "ok": 1970, "codes": {"200": 876, "201": 876, "202": 218}, "error_ratio_5xx": 0.0, "ok_rps": 41.3, "p50_ms": 5.4, "p95_ms": 12.1, "p99_ms": 26.5}, "mem": {"api-2": {"mem_mib": 51.0, "cpu": "7.56%"}, "api-1": {"mem_mib": 51.5, "cpu": "6.57%"}, "worker-1": {"mem_mib": 45.9, "cpu": "33.94%"}, "worker-2": {"mem_mib": 58.0, "cpu": "29.19%"}, "relay-1": {"mem_mib": 36.2, "cpu": "1.23%"}, "otel-collector-1": {"mem_mib": 69.8, "cpu": "2.53%"}}, "alerts": []}
[ 366.60s] SDK-side loss while the Collector was down (increase over D+E) {"sdk_spans_export_failed": 23518, "sdk_logs_export_failed": 4828, "sdk_spans_queue_full": 0, "sdk_logs_queue_full": 0, "sdk_spans_processed_ok": 37545, "sdk_export_error_types": ["ConnectionError"]}
[ 366.69s] telemetry counters after recovery {"collector_spans_send_failed": 0.0, "collector_spans_enqueue_failed": 0.0, "collector_logs_send_failed": 0.0, "collector_logs_enqueue_failed": 0.0, "collector_spans_sent": 13738.0, "collector_queue_tempo": 0.0, "collector_queue_loki": 0.0, "collector_rss_mib": 231.6, "collector_heap_mib": 35.7, "sdk_spans_dropped_queue_full": 0.0, "sdk_logs_dropped_queue_full": 0.0, "sdk_span_export_failed": 23518.0, "sdk_log_export_failed": 4828.0, "sdk_spans_processed_ok": 152482.0}
[ 366.70s] verdict {"api_5xx_total": 0, "max_mem_mib": {"api": 57.5, "worker": 68.3, "relay": 36.4, "otel-collector": 125.1}, "baseline_mem_mib": {"api": 44.9, "worker": 46.6, "relay": 34.7, "otel-collector": 77.7}, "loss": {"collector_while_backends_down": {"spans_send_failed": 540, "spans_queue_full": 11379, "logs_send_failed": 119, "logs_queue_full": 1140, "spans_accepted": 43087, "logs_accepted": 8807, "peak_exporter_queue": {"otlp_grpc/tempo": 100.0, "otlp_http/loki": 100.0, "otlp_http/prometheus": 0.0}, "queue_capacity": 100.0, "peak_heap_mib": 100.5}, "sdk_while_collector_down": {"sdk_spans_export_failed": 23518, "sdk_logs_export_failed": 4828, "sdk_spans_queue_full": 0, "sdk_logs_queue_full": 0, "sdk_spans_processed_ok": 37545, "sdk_export_error_types": ["ConnectionError"]}}}
PASS: telemetry outage: API 5xx=0, max RSS {'api': 57.5, 'worker': 68.3, 'relay': 36.4, 'otel-collector': 125.1}, losses {'collector_while_backends_down': {'spans_send_failed': 540, 'spans_queue_full': 11379, 'logs_send_failed': 119, 'logs_queue_full': 1140, 'spans_accepted': 43087, 'logs_accepted': 8807, 'peak_exporter_queue': {'otlp_grpc/tempo': 100.0, 'otlp_http/loki': 100.0, 'otlp_http/prometheus': 0.0}, 'queue_capacity': 100.0, 'peak_heap_mib': 100.5}, 'sdk_while_collector_down': {'sdk_spans_export_failed': 23518, 'sdk_logs_export_failed': 4828, 'sdk_spans_queue_full': 0, 'sdk_logs_queue_full': 0, 'sdk_spans_processed_ok': 37545, 'sdk_export_error_types': ['ConnectionError']}}
exit=0
+52
View File
@@ -0,0 +1,52 @@
{
"scenario": "telemetry history survives restart of all stores",
"date_utc": "2026-11-14T16:31:40+00:00",
"steps": [
{
"t": 15.12,
"utc": "16:30:51.567",
"step": "before restart",
"trace_id": "f6af0d3aa458ee3e54003d81cbaeefca",
"spans": 4,
"request_id": "bdcc59ea886f475b8893f1e57182faf9",
"log_lines": 1,
"metric_at_t1": 13.0,
"started_at": {
"db": "2026-11-14T16:28:28.925569258Z",
"prometheus": "2026-11-14T16:28:28.894746258Z",
"loki": "2026-11-14T16:28:29.413374633Z",
"tempo": "2026-11-14T16:28:38.892159388Z",
"otel-collector": "2026-11-14T16:29:06.158626636Z",
"grafana": "2026-11-14T16:29:06.30466397Z"
}
},
{
"t": 63.59,
"utc": "16:31:40.036",
"step": "restart.sh done",
"started_at": {
"db": "2026-11-14T16:30:51.784140171Z",
"prometheus": "2026-11-14T16:30:51.763339921Z",
"loki": "2026-11-14T16:30:52.308440171Z",
"tempo": "2026-11-14T16:30:51.924479588Z",
"otel-collector": "2026-11-14T16:31:29.3025483Z",
"grafana": "2026-11-14T16:31:29.408673591Z"
},
"datasource_health": {
"prometheus": "OK",
"loki": "OK",
"tempo": "OK"
}
},
{
"t": 63.65,
"utc": "16:31:40.096",
"step": "after restart: history preserved",
"spans": 4,
"metric_at_t1": 13.0,
"log_lines": 1,
"log_trace_id": "f6af0d3aa458ee3e54003d81cbaeefca",
"dashboard_provisioned": true
}
]
}
+6
View File
@@ -0,0 +1,6 @@
# 2026-11-14T16:30:36Z python3 student-tests/telemetry_persistence.py --output evidence/telemetry-persistence.json
[ 15.12s] before restart {"trace_id": "f6af0d3aa458ee3e54003d81cbaeefca", "spans": 4, "request_id": "bdcc59ea886f475b8893f1e57182faf9", "log_lines": 1, "metric_at_t1": 13.0, "started_at": {"db": "2026-11-14T16:28:28.925569258Z", "prometheus": "2026-11-14T16:28:28.894746258Z", "loki": "2026-11-14T16:28:29.413374633Z", "tempo": "2026-11-14T16:28:38.892159388Z", "otel-collector": "2026-11-14T16:29:06.158626636Z", "grafana": "2026-11-14T16:29:06.30466397Z"}}
[ 63.59s] restart.sh done {"started_at": {"db": "2026-11-14T16:30:51.784140171Z", "prometheus": "2026-11-14T16:30:51.763339921Z", "loki": "2026-11-14T16:30:52.308440171Z", "tempo": "2026-11-14T16:30:51.924479588Z", "otel-collector": "2026-11-14T16:31:29.3025483Z", "grafana": "2026-11-14T16:31:29.408673591Z"}, "datasource_health": {"prometheus": "OK", "loki": "OK", "tempo": "OK"}}
[ 63.65s] after restart: history preserved {"spans": 4, "metric_at_t1": 13.0, "log_lines": 1, "log_trace_id": "f6af0d3aa458ee3e54003d81cbaeefca", "dashboard_provisioned": true}
PASS: trace, log and metric history survived restart of all stores
exit=0
+4
View File
@@ -0,0 +1,4 @@
# 2026-11-14T16:30:04Z make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
exit=0
+185
View File
@@ -0,0 +1,185 @@
{
"scenario": "worker outage -> restart api+broker -> worker start -> ready -> redelivery",
"date_utc": "2026-11-14T16:50:52+00:00",
"steps": [
{
"t": 1.93,
"utc": "16:50:26.742",
"step": "worker stopped",
"running": []
},
{
"t": 2.41,
"utc": "16:50:27.227",
"step": "upload while worker is down",
"http": 202,
"attachment_id": "b2c9460c-4fd5-439b-b55e-79e633aa42f9",
"status": "queued"
},
{
"t": 2.43,
"utc": "16:50:27.245",
"step": "metadata and content while queued",
"status": "queued",
"content": 409,
"thumbnail": 409,
"error_code": "conflict"
},
{
"t": 2.44,
"utc": "16:50:27.254",
"step": "messages while worker is down",
"with_queued_attachment": true,
"plain_message_id": "6957b7b8-7bc8-4576-85de-fd6cb473d8cf"
},
{
"t": 5.36,
"utc": "16:50:30.178",
"step": "job is durable in broker",
"queue": {
"messages": 1,
"messages_ready": 1,
"messages_unacknowledged": 0,
"consumers": 0
},
"outbox_published": true,
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"job_status": "queued"
},
{
"t": 14.28,
"utc": "16:50:39.091",
"step": "api restarted",
"status": "queued"
},
{
"t": 19.86,
"utc": "16:50:44.671",
"step": "broker restarted with volume",
"queue": {
"messages": 1,
"messages_ready": 1,
"messages_unacknowledged": 0,
"consumers": 0
},
"status": "queued"
},
{
"t": 25.71,
"utc": "16:50:50.521",
"step": "worker started"
},
{
"t": 25.75,
"utc": "16:50:50.564",
"step": "ready after worker start",
"variants": [
[
"thumbnail",
256,
160
],
[
"crop",
128,
128
],
[
"optimized",
320,
200
]
],
"original_sha256_ok": true,
"thumbnail_bytes": 4679
},
{
"t": 27.52,
"utc": "16:50:52.334",
"step": "redelivery of the same job is a no-op",
"events": [
"enqueued",
"claimed",
"ready",
"staging_deleted",
"duplicate_ignored"
],
"invariants": {
"variants": [
"crop",
"optimized",
"thumbnail"
],
"variants_ok": true,
"final_objects": 4,
"final_objects_ok": true,
"staging_left": false,
"job_status": "ready",
"attempt": 1
}
}
],
"attachment_id": "b2c9460c-4fd5-439b-b55e-79e633aa42f9",
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"events": [
{
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"at": "2026-11-14T16:50:27.224351Z",
"event": "enqueued",
"attempt": 1,
"actor": "api",
"detail": null
},
{
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"at": "2026-11-14T16:50:45.408651Z",
"event": "claimed",
"attempt": 1,
"actor": "ff3fb8ef2677:04bb51bc",
"detail": {
"redelivered_message_attempt": 1
}
},
{
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"at": "2026-11-14T16:50:45.550305Z",
"event": "ready",
"attempt": 1,
"actor": "ff3fb8ef2677:04bb51bc",
"detail": {
"variants": {
"crop": [
128,
128
],
"optimized": [
320,
200
],
"thumbnail": [
256,
160
]
}
}
},
{
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"at": "2026-11-14T16:50:45.552053Z",
"event": "staging_deleted",
"attempt": 1,
"actor": "ff3fb8ef2677:04bb51bc",
"detail": null
},
{
"job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887",
"at": "2026-11-14T16:50:51.314454Z",
"event": "duplicate_ignored",
"attempt": 1,
"actor": "ff3fb8ef2677:04bb51bc",
"detail": {
"status": "ready"
}
}
]
}
+13
View File
@@ -0,0 +1,13 @@
# 2026-11-14T16:50:24Z python3 student-tests/worker_outage.py --output evidence/worker-outage.json
[ 1.93s] worker stopped {"running": []}
[ 2.41s] upload while worker is down {"http": 202, "attachment_id": "b2c9460c-4fd5-439b-b55e-79e633aa42f9", "status": "queued"}
[ 2.43s] metadata and content while queued {"status": "queued", "content": 409, "thumbnail": 409, "error_code": "conflict"}
[ 2.44s] messages while worker is down {"with_queued_attachment": true, "plain_message_id": "6957b7b8-7bc8-4576-85de-fd6cb473d8cf"}
[ 5.36s] job is durable in broker {"queue": {"messages": 1, "messages_ready": 1, "messages_unacknowledged": 0, "consumers": 0}, "outbox_published": true, "job_id": "9a8648c5-8064-40ae-8f9d-f9b3208e4887", "job_status": "queued"}
[ 14.28s] api restarted {"status": "queued"}
[ 19.86s] broker restarted with volume {"queue": {"messages": 1, "messages_ready": 1, "messages_unacknowledged": 0, "consumers": 0}, "status": "queued"}
[ 25.71s] worker started
[ 25.75s] ready after worker start {"variants": [["thumbnail", 256, 160], ["crop", 128, 128], ["optimized", 320, 200]], "original_sha256_ok": true, "thumbnail_bytes": 4679}
[ 27.52s] redelivery of the same job is a no-op {"events": ["enqueued", "claimed", "ready", "staging_deleted", "duplicate_ignored"], "invariants": {"variants": ["crop", "optimized", "thumbnail"], "variants_ok": true, "final_objects": 4, "final_objects_ok": true, "staging_left": false, "job_status": "ready", "attempt": 1}}
PASS: worker outage, api+broker restart, ready, duplicate delivery no-op
exit=0
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,15 @@
# Dashboards из Git: infra/grafana/dashboards/*.json монтируются в /var/lib/grafana/dashboards.
# allowUiUpdates: false — источник истины JSON в репозитории (генератор: scripts/build_dashboard.py).
apiVersion: 1
providers:
- name: messenger
orgId: 1
folder: Messenger
folderUid: messenger
type: file
disableDeletion: true
allowUiUpdates: false
updateIntervalSeconds: 30
options:
path: /var/lib/grafana/dashboards
foldersFromFilesStructure: false
@@ -0,0 +1,76 @@
# Grafana datasources (provisioning, применяется при старте; правки в UI не сохраняются).
# Grafana — интерфейс и запросы к хранилищам, сама сигналы не хранит.
# Связи сигналов: метрика (exemplar trace_id) -> Tempo; лог (structured metadata trace_id) -> Tempo;
# span -> логи Loki того же trace_id; span -> метрики Prometheus по service.name.
# В provisioning `$` пишется как `$$` (иначе Grafana подставит переменную окружения).
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: http://prometheus:9090
isDefault: true
editable: false
jsonData:
httpMethod: POST
timeInterval: 15s
prometheusType: Prometheus
exemplarTraceIdDestinations:
- name: trace_id
datasourceUid: tempo
- name: Loki
uid: loki
type: loki
access: proxy
url: http://loki:3100
editable: false
jsonData:
maxLines: 1000
derivedFields:
- name: TraceID
matcherType: label
matcherRegex: trace_id
datasourceUid: tempo
url: "$${__value.raw}"
urlDisplayLabel: "Trace в Tempo"
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: http://tempo:3200
editable: false
jsonData:
tracesToLogsV2:
datasourceUid: loki
spanStartTimeShift: "-5m"
spanEndTimeShift: "5m"
filterByTraceID: true
filterBySpanID: false
customQuery: false
tags:
- key: service.name
value: service_name
tracesToMetrics:
datasourceUid: prometheus
spanStartTimeShift: "-10m"
spanEndTimeShift: "10m"
tags:
- key: service.name
value: job
queries:
- name: "HTTP p95 по маршруту"
query: 'histogram_quantile(0.95, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{$$__tags}[5m])))'
nodeGraph:
enabled: true
search:
hide: false
lokiSearch:
datasourceUid: loki
traceQuery:
timeShiftEnabled: true
spanStartTimeShift: "-30m"
spanEndTimeShift: "30m"
+108
View File
@@ -0,0 +1,108 @@
# Lab3/4/6: единая точка входа перед API-репликами.
#
# Lab4: upload вложений — тело идёт потоком (без http-buffer-request); для upload timeout server
# увеличен до 75 с (> UPLOAD_TIMEOUT_SECONDS=60 у API + запись в S3). Content-Length
# больше лимита API отклоняет сам, не читая тело.
#
# Обнаружение реплик: DNS Docker (127.0.0.11) отдаёт по имени сервиса `api` адреса
# ВСЕХ его контейнеров; server-template создаёт до 8 слотов и заполняет их по DNS.
# Поэтому `docker compose up --scale api=N` не требует правки конфигурации.
#
# Readiness: активная проверка GET /health/ready каждую 1 с; 2 неудачи подряд -> DOWN,
# 2 успеха -> UP. Максимальное время обнаружения отказа:
# inter(1s) + timeout check(1s) + fastinter(0.5s) + timeout check(1s) ~= 3.5 с;
# ready=503 или refused без ожидания таймаута -> ~1.5 с.
# Sticky sessions НЕ используются: balance roundrobin без cookie/stick-table для backend
# (stick-table во frontend считает только частоту входов по IP, на выбор реплики не влияет).
#
# Перегрузка: maxconn 10 на реплику (= DB_POOL_SIZE) — лишние запросы ждут в очереди LB
# (timeout queue 5s), а не плодят потоки внутри Python-процесса. Переполнение -> 503 JSON.
global
log stdout format raw local0 info
maxconn 4096
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 2s
hold other 2s
hold refused 2s
hold nx 2s
hold timeout 2s
hold obsolete 2s
accepted_payload_size 8192
defaults
mode http
log global
option httplog
option dontlognull
# Внутри одного Docker-host соединение устанавливается за доли мс: 500 мс хватает с запасом,
# а при внезапно исчезнувшей реплике запрос быстро уходит в retry на другую.
timeout connect 500ms
timeout client 30s
timeout server 10s
timeout http-request 10s
timeout http-keep-alive 5s
timeout queue 5s
timeout check 1s
# Повтор только если соединение с backend НЕ установлено (запрос точно не дошёл
# до приложения) — это безопасно даже для неидемпотентных POST. Повтор уходит
# на другую реплику (redispatch). Ответы/таймауты после отправки не повторяются.
retries 2
retry-on conn-failure
option redispatch 1
# Ошибки, которые формирует сам HAProxy (нет живых реплик, обрыв backend, timeout,
# переполнение очереди), отдаются в общем JSON-формате ошибки контракта, а не HTML.
# Ответы приложения (в т.ч. его 503) эти правила не затрагивают.
unique-id-format %[uuid()]
http-error status 400 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" lf-string '{"error":{"code":"invalid_request","message":"Неверный запрос","request_id":"%ID"}}'
http-error status 408 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" lf-string '{"error":{"code":"invalid_request","message":"Запрос не получен вовремя","request_id":"%ID"}}'
http-error status 413 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" lf-string '{"error":{"code":"payload_too_large","message":"Файл больше допустимого размера","request_id":"%ID"}}'
http-error status 429 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" hdr Retry-After "10" lf-string '{"error":{"code":"rate_limited","message":"Слишком много запросов, повторите позже","request_id":"%ID"}}'
http-error status 500 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" lf-string '{"error":{"code":"internal_error","message":"Внутренняя ошибка сервера","request_id":"%ID"}}'
http-error status 502 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" hdr Retry-After "1" lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%ID"}}'
http-error status 503 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" hdr Retry-After "1" lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%ID"}}'
http-error status 504 content-type "application/json; charset=utf-8" hdr X-Request-Id "%ID" hdr Retry-After "1" lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%ID"}}'
frontend fe_api
bind :8080
# X-Request-Id формирует само приложение; LB только пробрасывает адрес клиента.
option forwardfor
# Защита входа от перебора паролей и шторма scrypt: не более LOGIN_RATE_LIMIT
# попыток POST /auth/sessions за 10 с с одного IP, сверх — 429 rate_limited.
stick-table type ip size 100k expire 60s store http_req_rate(10s)
acl is_login method POST
acl is_login_path path /api/v1/auth/sessions
# Явно вычисляем unique-id до deny: иначе в ответе 429 request_id остаётся пустым.
http-request set-var(txn.request_id) unique-id
http-request track-sc0 src if is_login is_login_path
http-request deny deny_status 429 if is_login is_login_path { sc_http_req_rate(0) gt "${LOGIN_RATE_LIMIT}" }
# Lab4: лимит размера upload проверяет API по Content-Length ДО чтения тела (ответ 413
# с X-Instance-Id по контракту). Дублирующий deny на LB убран: его ответ без X-Instance-Id.
default_backend be_api
backend be_api
balance roundrobin
http-request set-timeout server 75s if METH_POST { path_reg ^/api/v1/chats/[^/]+/attachments$ }
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb
http-check expect status 200
# on-marked-down shutdown-sessions НЕ используется: при штатной остановке реплика ещё
# дообслуживает начатые запросы (drain), и обрыв их сессий дал бы лишние 502.
default-server maxconn 10 check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr libc,none
server-template api 8 api:8080
# Статистика LB (только на 127.0.0.1 хоста): видно, какие реплики UP/DOWN.
frontend stats
bind :8404
# Lab6: встроенный Prometheus-экспортёр HAProxy (USE_PROMEX) — снимает Prometheus по сети telemetry.
http-request use-service prometheus-exporter if { path /metrics }
stats enable
stats uri /stats
stats refresh 2s
stats show-legends
+72
View File
@@ -0,0 +1,72 @@
# Loki (grafana/loki:3.6.19) — хранилище ЛОГОВ, монолитный режим, файловая система (volume lokidata).
# Приём: нативный OTLP /otlp/v1/logs от Collector. Индексные labels — только ресурсные
# service.name, service.instance.id, deployment.environment.name (низкая кардинальность).
# Атрибуты записи (event, request_id, trace_id, span_id, http.route, ...) хранятся как
# structured metadata: по ним можно фильтровать, но они не раздувают индекс.
auth_enabled: false
server:
http_listen_port: 3100
grpc_listen_port: 9095
log_level: warn
common:
instance_addr: 127.0.0.1
path_prefix: /loki
replication_factor: 1
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
ring:
kvstore:
store: inmemory
# WAL ингестера — явно на volume: логи, ещё не сброшенные в chunks, переживают рестарт Loki.
ingester:
wal:
enabled: true
dir: /loki/wal
flush_on_shutdown: true
chunk_idle_period: 5m
max_chunk_age: 1h
schema_config:
configs:
- from: "2024-04-01"
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
allow_structured_metadata: true
retention_period: 168h
ingestion_rate_mb: 8
ingestion_burst_size_mb: 16
max_query_lookback: 168h
reject_old_samples: true
reject_old_samples_max_age: 24h
volume_enabled: true
otlp_config:
resource_attributes:
attributes_config:
- action: index_label
attributes:
- deployment.environment.name
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
pattern_ingester:
enabled: false
ruler:
enable_api: false
analytics:
reporting_enabled: false
+135
View File
@@ -0,0 +1,135 @@
# OpenTelemetry Collector (otel/opentelemetry-collector-contrib:0.163.2) — получатель, обработчик
# и экспортёр телеметрии. Долговременно ничего не хранит: буфер только в памяти и ограничен.
#
# API/relay/worker/janitor --OTLP/HTTP :4318--> receivers.otlp
# -> memory_limiter (первым: отказ приёма при давлении памяти, а не OOM)
# -> resource/lab, transform/scrub (защита в глубину от секретов в атрибутах)
# -> batch
# -> exporters: traces -> Tempo (OTLP gRPC), logs -> Loki (/otlp), metrics -> Prometheus (/api/v1/otlp)
#
# Поведение при недоступном backend: у каждого экспортёра своя ограниченная очередь
# (sending_queue.queue_size батчей, в памяти) и retry с экспоненциальной паузой до 60 с.
# Переполнение очереди или исчерпание retry = потеря данных, она считается в собственных
# метриках Collector (otelcol_exporter_enqueue_failed_*, otelcol_exporter_send_failed_*),
# которые Prometheus снимает с :8888. Приложение от этого не зависит: SDK отправляет асинхронно.
# Порты только во внутренней сети telemetry: 4318 (OTLP HTTP), 4317 (OTLP gRPC), 8888 (метрики),
# 13133 (health_check). На хост ничего не публикуется.
extensions:
health_check:
endpoint: 0.0.0.0:13133
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
max_request_body_size: 8388608 # 8 MiB на запрос экспорта
grpc:
endpoint: 0.0.0.0:4317
max_recv_msg_size_mib: 8
processors:
# Мягкий предел 150 MiB (limit - spike), жёсткий 190 MiB при лимите контейнера 256 MiB
# и GOMEMLIMIT 200MiB. Выше мягкого — receiver отвечает ошибкой (SDK повторит/отбросит).
memory_limiter:
check_interval: 1s
limit_mib: 190
spike_limit_mib: 40
resource/lab:
attributes:
- key: deployment.environment.name
value: lab
action: insert
# Атрибуты, которых в нашей телеметрии быть не должно. Код их не пишет; процессор гарантирует,
# что случайно добавленный заголовок/секрет не дойдёт до хранилищ.
transform/scrub:
error_mode: ignore
trace_statements:
- delete_key(span.attributes, "http.request.header.authorization")
- delete_key(span.attributes, "http.request.header.cookie")
- delete_key(span.attributes, "url.query")
- delete_key(span.attributes, "db.query.parameters")
- delete_matching_keys(span.attributes, "(?i).*(password|secret|token|authorization).*")
log_statements:
- delete_key(log.attributes, "http.request.header.authorization")
- delete_key(log.attributes, "url.query")
- delete_matching_keys(log.attributes, "(?i).*(password|secret|token|authorization).*")
- replace_pattern(log.body, "(?i)(bearer|basic)\\s+[A-Za-z0-9._~+/=-]{6,}", "$$1 [REDACTED]")
batch:
send_batch_size: 512
send_batch_max_size: 1024
timeout: 1s
exporters:
otlp_grpc/tempo:
endpoint: tempo:4317
tls:
insecure: true
timeout: 5s
sending_queue:
enabled: true
num_consumers: 2
queue_size: 100
retry_on_failure:
enabled: true
initial_interval: 1s
max_interval: 10s
max_elapsed_time: 60s
otlp_http/loki:
endpoint: http://loki:3100/otlp
timeout: 5s
sending_queue:
enabled: true
num_consumers: 2
queue_size: 100
retry_on_failure:
enabled: true
initial_interval: 1s
max_interval: 10s
max_elapsed_time: 60s
otlp_http/prometheus:
endpoint: http://prometheus:9090/api/v1/otlp
timeout: 5s
sending_queue:
enabled: true
num_consumers: 2
queue_size: 50
retry_on_failure:
enabled: true
initial_interval: 1s
max_interval: 10s
max_elapsed_time: 60s
service:
extensions: [health_check]
telemetry:
logs:
level: info
encoding: json
metrics:
level: normal
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
pipelines:
traces:
receivers: [otlp]
processors: [memory_limiter, resource/lab, transform/scrub, batch]
exporters: [otlp_grpc/tempo]
logs:
receivers: [otlp]
processors: [memory_limiter, resource/lab, transform/scrub, batch]
exporters: [otlp_http/loki]
metrics:
receivers: [otlp]
processors: [memory_limiter, resource/lab, batch]
exporters: [otlp_http/prometheus]
+64
View File
@@ -0,0 +1,64 @@
# Prometheus (prom/prometheus:v3.13.5) — хранилище МЕТРИК (TSDB на volume promdata, 15 дней / 2 GB).
# Источники:
# * OTLP push от Collector: /api/v1/otlp (флаг --web.enable-otlp-receiver) — метрики API,
# worker, relay, janitor. job = service.name, instance = service.instance.id (= X-Instance-Id);
# * scrape: сам Collector (:8888, потери/очереди экспортёров), HAProxy (:8404/metrics),
# RabbitMQ (rabbitmq_prometheus :15692), Loki, Tempo и сам Prometheus.
# Alert rules — rules/*.yml (локальное состояние firing/resolved, без Alertmanager:
# доставка наружу по заданию не нужна).
global:
scrape_interval: 15s
scrape_timeout: 5s
evaluation_interval: 15s
otlp:
# Ресурсные атрибуты, которые станут labels всех OTLP-метрик (низкая кардинальность).
# service.name -> job, service.instance.id -> instance (Prometheus делает сам).
promote_resource_attributes:
- service.version
- deployment.environment.name
storage:
tsdb:
# OTLP-метрики приходят push-ом от нескольких процессов: допускаем небольшой разброс времени.
out_of_order_time_window: 10m
rule_files:
- /etc/prometheus/rules/*.yml
scrape_configs:
- job_name: prometheus
static_configs:
- targets: ["localhost:9090"]
- job_name: otel-collector
static_configs:
- targets: ["otel-collector:8888"]
- job_name: haproxy
metrics_path: /metrics
static_configs:
- targets: ["lb:8404"]
# Глубина очередей брокера (ready/unacked/consumers) по vhost messenger.
- job_name: rabbitmq
metrics_path: /metrics/detailed
params:
vhost: [messenger]
family: [queue_coarse_metrics, queue_consumer_count]
static_configs:
- targets: ["broker:15692"]
# Агрегированные метрики узла RabbitMQ (память, алармы, соединения).
- job_name: rabbitmq-node
metrics_path: /metrics
static_configs:
- targets: ["broker:15692"]
- job_name: loki
static_configs:
- targets: ["loki:3100"]
- job_name: tempo
static_configs:
- targets: ["tempo:3200"]
+156
View File
@@ -0,0 +1,156 @@
# Recording и alert rules мессенджера (Prometheus 3.13). Проверка: promtool check rules,
# unit-тесты — infra/prometheus/tests/messenger.test.yml (scripts/check_rules.sh).
# Состояние alerts видно локально: Prometheus /alerts, /api/v1/alerts, ряд ALERTS{alertstate},
# Grafana -> Alerting (data source-managed) и панель «Alerts» дашборда. Доставки наружу нет.
#
# SLI (бизнес-запросы = все маршруты, кроме /health/* и unmatched):
# доступность = доля ответов не 5xx; SLO 99.5 % за 7 дней (rolling)
# задержка = доля запросов не дольше 0.5 с (без upload
# и входа/регистрации: scrypt by design); SLO 99 % за 7 дней
# time to ready = доля вложений, ready не позже 30 с после
# durable acceptance (COMMIT enqueue); SLO 99 % за 7 дней
# Числитель ошибок — только 5xx (отказ сервера). 4xx (неверный пароль, 404, 409) — корректные
# ответы на ошибку клиента и бюджет не расходуют. Error budget доступности = 0.5 % запросов.
groups:
- name: messenger-sli
interval: 15s
rules:
- record: messenger:http_requests:rate2m
expr: sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched"}[2m]))
- record: messenger:http_errors:rate2m
expr: sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched", http_response_status_class="5xx"}[2m])) or vector(0)
- record: messenger:http_error_ratio:rate2m
expr: messenger:http_errors:rate2m / messenger:http_requests:rate2m
- record: messenger:http_requests:rate5m
expr: sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched"}[5m]))
- record: messenger:http_error_ratio:rate5m
expr: (sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched", http_response_status_class="5xx"}[5m])) or vector(0)) / messenger:http_requests:rate5m
# p50/p95/p99 из buckets ВСЕХ реплик (сначала sum by le, потом quantile) — не среднее p95.
- record: messenger:http_latency_seconds:p50_5m
expr: histogram_quantile(0.50, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api", http_route!~"/health/.*|unmatched"}[5m])))
- record: messenger:http_latency_seconds:p95_5m
expr: histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api", http_route!~"/health/.*|unmatched"}[5m])))
- record: messenger:http_latency_seconds:p99_5m
expr: histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api", http_route!~"/health/.*|unmatched"}[5m])))
# Ошибки на входе (HAProxy): если упала БД, реплики не ready и LB сам отвечает 503 —
# до API такие запросы не доходят, и метрика API их не видит.
- record: messenger:lb_requests:rate2m
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="fe_api"}[2m]))
- record: messenger:lb_error_ratio:rate2m
expr: (sum(rate(haproxy_frontend_http_responses_total{proxy="fe_api", code="5xx"}[2m])) or vector(0)) / messenger:lb_requests:rate2m
- record: messenger:db_operation_seconds:p95_2m
expr: histogram_quantile(0.95, sum by (le) (rate(db_client_operation_duration_seconds_bucket{job="messenger-api"}[2m])))
- record: messenger:time_to_ready_seconds:p95_5m
expr: histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[5m])))
- name: messenger-slo
interval: 1m
rules:
- record: messenger:slo_availability:ratio_7d
expr: 1 - ((sum(increase(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched", http_response_status_class="5xx"}[7d])) or vector(0)) / sum(increase(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched"}[7d])))
- record: messenger:slo_availability:error_budget_remaining_7d
expr: 1 - (1 - messenger:slo_availability:ratio_7d) / (1 - 0.995)
- record: messenger:slo_latency:ratio_7d
expr: sum(increase(http_server_request_duration_seconds_bucket{job="messenger-api", le="0.5", http_route!~"/health/.*|unmatched|/api/v1/chats/\\{chat_id\\}/attachments|/api/v1/users|/api/v1/auth/sessions"}[7d])) / sum(increase(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health/.*|unmatched|/api/v1/chats/\\{chat_id\\}/attachments|/api/v1/users|/api/v1/auth/sessions"}[7d]))
- record: messenger:slo_time_to_ready:ratio_7d
expr: sum(increase(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready", le="30"}[7d])) / sum(increase(messenger_attachment_time_to_ready_seconds_count{outcome="ready"}[7d]))
- name: messenger-alerts
interval: 15s
rules:
- alert: MessengerHighErrorRate
# Окно 2 м, порог 5 % 5xx, минимум 0.1 запроса/с (не будить на единичной ошибке ночью), for 1m.
expr: messenger:http_error_ratio:rate2m > 0.05 and on() messenger:http_requests:rate2m > 0.1
for: 1m
labels:
severity: page
source: api
annotations:
summary: "API: {{ $value | humanizePercentage }} ответов 5xx за 2 минуты"
description: "Доля 5xx среди бизнес-запросов (без /health) выше 5 % дольше минуты. Error budget SLO 99.5 % расходуется в ~10 раз быстрее допустимого."
runbook_url: "infra/runbooks/README.md#messengerhigherrorrate"
- alert: MessengerHighErrorRate
expr: messenger:lb_error_ratio:rate2m > 0.05 and on() messenger:lb_requests:rate2m > 0.1
for: 1m
labels:
severity: page
source: lb
annotations:
summary: "LB: {{ $value | humanizePercentage }} ответов 5xx за 2 минуты"
description: "HAProxy отвечает 5xx (вероятно, нет ready-реплик: проверьте /health/ready и БД)."
runbook_url: "infra/runbooks/README.md#messengerhigherrorrate"
- alert: MessengerQueueLagGrowing
# Самое старое «созревшее» задание ждёт worker дольше 30 с, и ожидание не уменьшается.
expr: max(messenger_jobs_ready_lag_seconds) > 30 and on() deriv(max(messenger_jobs_ready_lag_seconds)[2m:15s]) >= 0
for: 1m
labels:
severity: page
annotations:
summary: "Очередь обработки вложений растёт: старейшее задание ждёт {{ $value | humanizeDuration }}"
description: "messenger_jobs_ready_lag_seconds > 30 с дольше минуты. Вероятно, worker остановлены/перегружены или брокер недоступен."
runbook_url: "infra/runbooks/README.md#messengerqueuelaggrowing"
- alert: MessengerOutboxStuck
expr: max(messenger_outbox_oldest_age_seconds) > 30
for: 1m
labels:
severity: page
annotations:
summary: "Outbox не публикуется {{ $value | humanizeDuration }}"
description: "Задания приняты (COMMIT), но relay не может опубликовать их в RabbitMQ."
runbook_url: "infra/runbooks/README.md#messengeroutboxstuck"
- alert: MessengerWorkerSaturated
# last_over_time[30s]: только живые реплики (ряды остановленных контейнеров видны ещё 5 мин).
expr: sum(rate(messenger_worker_busy_time_seconds_total[2m])) / sum(last_over_time(messenger_worker_capacity[30s])) > 0.9
for: 5m
labels:
severity: warning
annotations:
summary: "Worker заняты на {{ $value | humanizePercentage }} дольше 5 минут"
runbook_url: "infra/runbooks/README.md#messengerworkersaturated"
- alert: MessengerDbSlow
# p95 логической операции БД в API выше 250 мс (норма — единицы мс).
expr: messenger:db_operation_seconds:p95_2m > 0.25
for: 1m
labels:
severity: page
annotations:
summary: "PostgreSQL медленная: p95 операции {{ $value | humanizeDuration }}"
description: "Задержка в spans/гистограмме db.client.operation.duration, а не в коде обработчика. Проверьте блокировки и ресурсы БД."
runbook_url: "infra/runbooks/README.md#messengerdbslow"
- alert: MessengerDbPoolSaturated
expr: max(avg_over_time(db_client_connection_pending_requests{job="messenger-api"}[1m])) > 1
for: 1m
labels:
severity: warning
annotations:
summary: "Пул соединений API исчерпан: в среднем {{ $value }} запросов ждут соединение"
runbook_url: "infra/runbooks/README.md#messengerdbpoolsaturated"
- alert: MessengerApiLatencyHigh
expr: messenger:http_latency_seconds:p95_5m > 1
for: 2m
labels:
severity: warning
annotations:
summary: "p95 бизнес-запросов API {{ $value | humanizeDuration }}"
runbook_url: "infra/runbooks/README.md#messengerapilatencyhigh"
- alert: MessengerTelemetryExportFailing
# Collector не смог отправить/поставить в очередь данные в backend: телеметрия теряется.
# Collector 0.163 публикует счётчики без суффикса _total — regex по __name__ покрывает оба варианта.
expr: sum(rate({__name__=~"otelcol_exporter_send_failed_spans(_total)?"}[2m]) or vector(0)) + sum(rate({__name__=~"otelcol_exporter_send_failed_log_records(_total)?"}[2m]) or vector(0)) + sum(rate({__name__=~"otelcol_exporter_enqueue_failed_spans(_total)?"}[2m]) or vector(0)) + sum(rate({__name__=~"otelcol_exporter_enqueue_failed_log_records(_total)?"}[2m]) or vector(0)) > 0
for: 1m
labels:
severity: warning
annotations:
summary: "Collector теряет телеметрию ({{ $value | printf \"%.1f\" }} записей/с)"
runbook_url: "infra/runbooks/README.md#messengertelemetryexportfailing"
- alert: MessengerTelemetryBackendDown
expr: up{job=~"otel-collector|loki|tempo"} == 0
for: 1m
labels:
severity: warning
annotations:
summary: "Telemetry backend {{ $labels.job }} недоступен"
runbook_url: "infra/runbooks/README.md#messengertelemetrybackenddown"
+82
View File
@@ -0,0 +1,82 @@
# Unit-тесты alert rules: promtool test rules (запуск — scripts/check_rules.sh, в контейнере
# prom/prometheus той же версии, что и стенд). Синтетические ряды с шагом 15 с.
rule_files:
- ../rules/messenger.yml
evaluation_interval: 15s
tests:
# 1) Высокая доля 5xx в API: 4 rps успешных, с t=165 с ещё ~0.67 rps 5xx (≈14 %).
- interval: 15s
input_series:
- series: 'http_server_request_duration_seconds_count{job="messenger-api", instance="a", http_route="/api/v1/chats/{chat_id}/messages", http_response_status_class="2xx"}'
values: '0+60x60'
- series: 'http_server_request_duration_seconds_count{job="messenger-api", instance="a", http_route="/api/v1/chats/{chat_id}/messages", http_response_status_class="5xx"}'
values: '0x10 10+10x20 310x29'
# health не входит в SLI: тысячи 5xx /health/ready не должны поднимать alert.
- series: 'http_server_request_duration_seconds_count{job="messenger-api", instance="a", http_route="/health/ready", http_response_status_class="5xx"}'
values: '0+1000x60'
alert_rule_test:
- eval_time: 2m
alertname: MessengerHighErrorRate
exp_alerts: []
- eval_time: 5m
alertname: MessengerHighErrorRate
exp_alerts:
- exp_labels:
severity: page
source: api
exp_annotations:
summary: "API: 14.29% ответов 5xx за 2 минуты"
description: "Доля 5xx среди бизнес-запросов (без /health) выше 5 % дольше минуты. Error budget SLO 99.5 % расходуется в ~10 раз быстрее допустимого."
runbook_url: "infra/runbooks/README.md#messengerhigherrorrate"
# 5xx прекратились в t=465 с: через 2-минутное окно alert снят (resolved).
- eval_time: 12m
alertname: MessengerHighErrorRate
exp_alerts: []
# 2) Worker остановлен: возраст старейшего созревшего задания растёт с t=135 с, после
# восстановления (t=330 с) — 0.
- interval: 15s
input_series:
- series: 'messenger_jobs_ready_lag_seconds{job="messenger-relay", instance="r"}'
values: '0x8 15+15x12 0x30'
alert_rule_test:
- eval_time: 2m
alertname: MessengerQueueLagGrowing
exp_alerts: []
- eval_time: 5m
alertname: MessengerQueueLagGrowing
exp_alerts:
- exp_labels:
severity: page
exp_annotations:
summary: "Очередь обработки вложений растёт: старейшее задание ждёт 3m 0s"
description: "messenger_jobs_ready_lag_seconds > 30 с дольше минуты. Вероятно, worker остановлены/перегружены или брокер недоступен."
runbook_url: "infra/runbooks/README.md#messengerqueuelaggrowing"
- eval_time: 9m
alertname: MessengerQueueLagGrowing
exp_alerts: []
# 3) Медленная БД: все операции попадают в bucket 1 с (p95 ≈ 0.95 с) с t=150 с.
- interval: 15s
input_series:
- series: 'db_client_operation_duration_seconds_bucket{job="messenger-api", instance="a", le="0.01"}'
values: '0+100x10 1000x30'
- series: 'db_client_operation_duration_seconds_bucket{job="messenger-api", instance="a", le="1"}'
values: '0+100x10 1000+100x30'
- series: 'db_client_operation_duration_seconds_bucket{job="messenger-api", instance="a", le="+Inf"}'
values: '0+100x10 1000+100x30'
alert_rule_test:
- eval_time: 2m
alertname: MessengerDbSlow
exp_alerts: []
- eval_time: 6m
alertname: MessengerDbSlow
exp_alerts:
- exp_labels:
severity: page
exp_annotations:
summary: "PostgreSQL медленная: p95 операции 950.5ms"
description: "Задержка в spans/гистограмме db.client.operation.duration, а не в коде обработчика. Проверьте блокировки и ресурсы БД."
runbook_url: "infra/runbooks/README.md#messengerdbslow"
+16
View File
@@ -0,0 +1,16 @@
# RabbitMQ 4.1 для lab5. Топология и пользователи — из definitions (Docker secret,
# генерирует scripts/init-secrets.sh): exchange attachments -> quorum-очередь
# attachments.process.v1 (DLX attachments.dlx -> attachments.dlq).
load_definitions = /run/secrets/rabbitmq_definitions.json
# guest (если создан) пускается только с localhost внутри контейнера.
loopback_users.guest = true
listeners.tcp.default = 5672
# Защита брокера от переполнения памяти/диска: при достижении порога publishers блокируются
# (relay ждёт, задания копятся в outbox PostgreSQL — работа не теряется).
vm_memory_high_watermark.relative = 0.6
disk_free_limit.absolute = 256MB
# Неподтверждённое сообщение дольше 30 мин -> канал закрывается, сообщение возвращается.
consumer_timeout = 1800000
log.console = true
log.console.level = info
log.file = false
+128
View File
@@ -0,0 +1,128 @@
# Runbooks alerts мессенджера (lab6)
Alerts вычисляет Prometheus (`infra/prometheus/rules/messenger.yml`), состояние видно локально:
Grafana → дашборд «Messenger — наблюдаемость (lab6)» (панели «Alerts firing» и «История alerts»),
Grafana → Alerting → Alert rules (data source-managed), либо запросом `ALERTS{alertstate="firing"}`.
Доставки наружу нет (Alertmanager не используется — по заданию достаточно firing/resolved).
Общий порядок диагностики (метрика → трасса → лог):
1. **Метрика** отвечает «что и насколько плохо»: какая доля ошибок, какой перцентиль, где насыщение.
2. **Трасса** отвечает «где именно тратится время/возникает ошибка»: какой span длинный/с ошибкой —
код обработчика, БД, S3, ожидание в очереди (разрыв между `attachments send` и `process`).
3. **Лог** отвечает «что конкретно произошло»: `event`, `error.type`, `request_id`, `job_id`,
и по `trace_id` ведёт обратно в трассу (в Grafana — ссылка «Trace в Tempo» у записи Loki).
Команды ниже выполняются из корня репозитория. Доступ к Grafana: <http://127.0.0.1:3000>,
пользователь `admin`, пароль в `secrets/grafana_admin_password` (не печатать в отчёты).
---
## MessengerHighErrorRate
**Условие:** доля 5xx среди бизнес-запросов API (без `/health/*` и `unmatched`) за 2 мин > 5 % при
≥ 0.1 запроса/с, `for: 1m` (`source=api`). Вторая копия (`source=lb`) — то же по HAProxy `fe_api`:
если реплики не ready, 503 отдаёт сам LB, и до API запросы не доходят.
**Смысл для SLO:** при 5 % ошибок бюджет 0.5 % (SLO 99.5 % / 7 дней) расходуется в 10 раз быстрее.
**Диагностика:**
1. Панель «5xx по причине (error.type)»: `db_unavailable`/`db_pool_timeout` → БД (см. MessengerDbSlow),
`storage_unavailable` → S3, `overloaded` → лимиты слотов (scrypt/upload), `internal_error` → баг.
PromQL: `sum by (error_type, http_route) (rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_class="5xx"}[1m]))`.
2. `source=lb` и API почти без трафика → `haproxy_backend_active_servers{proxy="be_api"}`; если 0 —
реплики не ready: `docker compose ps api`, `curl -s localhost:8080/health/ready`, затем БД.
3. Трасса ошибки: Grafana → Explore → Tempo → TraceQL
`{ resource.service.name = "messenger-api" && kind = server && status = error }`; длинный
`db <операция>` с ошибкой — БД; длинный `s3 *` — S3; ошибки без длинных дочерних spans — код.
4. Логи: Loki `{service_name="messenger-api"} | event="http.request" | http_response_status_code >= 500`
или `| event="db.unavailable"`; X-Request-Id из ответа клиента → `| request_id="<id>"`.
**Действия:** устранить причину по error.type (БД/S3/перегрузка); при баге — откатить версию
(`scripts/rolling-update.sh <прежняя версия>`). Resolved — когда 2-минутное окно очистится от 5xx.
## MessengerQueueLagGrowing
**Условие:** `max(messenger_jobs_ready_lag_seconds) > 30` и производная за 2 мин ≥ 0, `for: 1m`.
`ready_lag` — сколько ждёт worker самое старое задание, которому уже пора выполняться
(PostgreSQL `jobs`: `status='queued' AND next_attempt_at <= now()`), т. е. backlog по источнику
истины, а не по брокеру. Alert снимается, когда lag перестал расти (идёт дренаж) или < 30 с.
**Диагностика:**
1. Панель «Saturation worker»: utilization 0 и нет `messenger_worker_capacity` → worker не работают
(`docker compose ps worker`, логи `{service_name="messenger-worker"} | event=~"worker.*"`).
Utilization ≈ 1.0 → worker живы, но не успевают (ёмкость `WORKER_REPLICAS × WORKER_CONCURRENCY`).
2. «Глубина очереди»: RabbitMQ ready растёт вместе с jobs queued → сообщения доходят, нет потребителей;
outbox pending растёт → не работает relay/брокер (см. MessengerOutboxStuck).
3. Трасса задания из окна: в трассе upload разрыв между `attachments send` (relay) и
`attachments.process.v1 process` (worker) = время в очереди; атрибут `messenger.job.queue_wait_s`.
4. `docker compose --profile tools run --rm ops inspect <attachment_id>` — состояние и traceparent.
**Действия:** `./scripts/start-worker.sh` (или `docker compose up -d worker`); при насыщении —
`docker compose up -d --scale worker=N` / `WORKER_CONCURRENCY`. Проверить, что backlog убывает
(«Возраст старейшего задания» → 0) и alert resolved. Задания не теряются: они в quorum-очереди и в БД.
## MessengerOutboxStuck
**Условие:** старейшая созревшая неопубликованная строка outbox старше 30 с, `for: 1m`.
**Диагностика:** `docker compose ps relay broker`; логи `{service_name="messenger-relay"} |
event=~"broker.*|db.error"`; панель «Relay: публикации outbox» (outcome=failed, error.type);
алармы памяти/диска RabbitMQ (`rabbitmq_alarms_*`). **Действия:** восстановить broker/relay;
relay опубликует накопленное само (transactional outbox), дубли гасит worker по `jobs`.
## MessengerWorkerSaturated
**Условие:** `sum(rate(messenger_worker_busy_time_seconds_total[2m])) / sum(messenger_worker_capacity) > 0.9`, `for: 5m`.
**Смысл:** все потоки worker заняты — новые задания копятся (предвестник MessengerQueueLagGrowing).
**Действия:** масштабировать worker; проверить «Длительность обработки job p95» и CPU worker
(«CPU saturation: доля лимита»): рост длительности при CPU у лимита → нужен CPU, а не реплики.
## MessengerDbSlow
**Условие:** p95 `db.client.operation.duration` API за 2 мин > 250 мс, `for: 1m` (норма — единицы мс).
**Диагностика (отличить БД от кода):**
1. «Операции БД p95 по операции»: какая операция медленная (`get_session_user` — сессии, т. е.
почти все запросы; `add_message` — блокировка строки чата и т. п.).
2. Трасса медленного запроса: длинный CLIENT span `db <операция>` (и `db.client.connection.wait_time_ms`
в атрибутах) → время в БД. Если длинный SERVER span, а db spans короткие — проблема в коде
обработчика (пример: `handler.compute` при `X-Fault-Inject: slow-handler`, CPU scrypt `security.*`).
3. В БД: `docker compose exec -T db sh -c 'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "SELECT pid, wait_event_type, wait_event, state, now()-xact_start AS xact, left(query,60) FROM pg_stat_activity WHERE datname=current_database() ORDER BY xact DESC NULLS LAST"'`
— `wait_event_type=Lock` у многих сессий → блокировка; найти держателя (самая старая транзакция).
**Действия:** снять держателя блокировки (`SELECT pg_terminate_backend(<pid>)`) или дождаться/отменить
долгую миграцию; при нехватке ресурсов — CPU/IO БД. После снятия p95 возвращается за окно 2 мин.
## MessengerDbPoolSaturated
**Условие:** в среднем за 1 мин > 1 запроса ждут соединение пула API, `for: 1m`.
**Смысл:** соединения заняты (медленная БД или слишком мало `DB_POOL_SIZE`); дальше — PoolTimeout (3 с) и 503.
**Действия:** как MessengerDbSlow; если БД быстрая, а пул мал — увеличить `DB_POOL_SIZE`
(и `maxconn` в HAProxy соразмерно).
## MessengerApiLatencyHigh
**Условие:** p95 бизнес-запросов API (все реплики, из buckets) за 5 мин > 1 с, `for: 2m`.
**Диагностика:** «p95 по маршруту» → маршрут; exemplars на панели задержки → трасса; дальше как
MessengerDbSlow (БД или код). Upload и вход дольше по природе (приём 10 MiB, scrypt).
## MessengerTelemetryExportFailing
**Условие:** Collector отбрасывает данные: рост `otelcol_exporter_send_failed_*` (retry исчерпан)
или `otelcol_exporter_enqueue_failed_*` (очередь экспортёра полна), `for: 1m`.
**Смысл:** телеметрия теряется (бизнес-путь — нет: SDK экспортирует асинхронно).
**Диагностика:** панель «Collector: очередь экспортёров» (size → capacity), какой exporter;
`up{job=~"loki|tempo"}`; логи Collector `docker compose logs otel-collector | grep Exporting`.
**Действия:** восстановить backend (`docker compose up -d tempo loki prometheus`); потери за период
оценить по `increase(otelcol_exporter_*_failed_*[окно])`. Восполнить потерянное нельзя — это
осознанный выбор: ограниченный буфер в памяти вместо неограниченного роста RAM.
## MessengerTelemetryBackendDown
**Условие:** `up{job=~"otel-collector|loki|tempo"} == 0`, `for: 1m`.
**Действия:** `docker compose ps`, `docker compose up -d <service>`. Если упал сам Collector —
SDK приложений теряют данные после заполнения своих очередей (2048 spans / log records на
процесс); потери видны после восстановления в `otel_sdk_exporter_*_exported_total{error_type!=""}`
и `otel_sdk_processor_*_processed_total{error_type="queue_full"}`. Если упал Prometheus — alerts
не вычисляются вовсе (ограничение учебного стенда: нет внешнего мониторинга мониторинга).
+42
View File
@@ -0,0 +1,42 @@
# Tempo (grafana/tempo:2.10.10) — хранилище ТРАСС, монолитный режим, локальный backend
# (volume tempodata: WAL + блоки), хранение 7 дней. Приём OTLP gRPC :4317 от Collector,
# запросы Grafana — HTTP :3200 (TraceQL, поиск по trace_id).
stream_over_http_enabled: true
server:
http_listen_port: 3200
grpc_listen_port: 9096
log_level: warn
distributor:
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
ingester:
max_block_duration: 5m
trace_idle_period: 10s
compactor:
compaction:
block_retention: 168h
storage:
trace:
backend: local
wal:
path: /var/tempo/wal
local:
path: /var/tempo/blocks
overrides:
defaults:
ingestion:
rate_limit_bytes: 15000000
burst_size_bytes: 20000000
max_traces_per_user: 20000
usage_report:
reporting_enabled: false
+40
View File
@@ -0,0 +1,40 @@
-- Lab2: начальная схема. Источник истины — PostgreSQL.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id),
user_id uuid NOT NULL REFERENCES users(id),
position integer NOT NULL, -- порядок участников как в запросе
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL,
created_at timestamptz NOT NULL
);
-- Индекс под keyset-пагинацию истории: (created_at, id) внутри чата.
CREATE INDEX messages_chat_order_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY, -- SHA-256 от токена; сам токен не хранится
user_id uuid NOT NULL REFERENCES users(id),
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
+17
View File
@@ -0,0 +1,17 @@
-- Lab3: общая (для всех реплик) идемпотентность POST сообщения.
-- Миграция только добавляет таблицу: код lab2 продолжает работать на новой схеме
-- (expand-only), поэтому её можно применить до замены реплик при rolling update.
--
-- Область уникальности по контракту: пользователь + метод + путь чата + ключ.
-- Метод всегда POST, путь однозначно задаётся chat_id, поэтому ключ PK — (user_id, chat_id, idem_key).
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users(id),
chat_id uuid NOT NULL REFERENCES chats(id),
idem_key text NOT NULL,
request_hash bytea NOT NULL, -- SHA-256 канонического JSON тела запроса
message_id uuid NOT NULL REFERENCES messages(id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
PRIMARY KEY (user_id, chat_id, idem_key)
);
CREATE INDEX idempotency_keys_expires_idx ON idempotency_keys (expires_at);
+40
View File
@@ -0,0 +1,40 @@
-- Lab4: метаданные вложений (PostgreSQL) отдельно от байтов (приватный S3-bucket).
-- Expand-only: только новые таблицы, код lab3 продолжает работать на этой схеме.
--
-- Жизненный цикл строки attachments:
-- pending — намерение записано ДО S3 PUT (известны размер, SHA-256, object_key);
-- ready — объект в S3 подтверждён, строка видна API и может быть прикреплена.
-- Если процесс упал/БД отказала между PUT и переводом в ready, строка остаётся pending.
-- Её находит janitor (src/janitor.py) по created_at старше grace period и удаляет
-- сначала объект в S3, затем строку. Поэтому в S3 нет объектов, о которых не знает БД.
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
owner_id uuid NOT NULL REFERENCES users(id),
filename text NOT NULL CHECK (char_length(filename) BETWEEN 1 AND 255),
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
width integer NOT NULL CHECK (width > 0),
height integer NOT NULL CHECK (height > 0),
-- Ключ назначает сервер (случайный), filename в нём не участвует.
object_key text NOT NULL UNIQUE,
status text NOT NULL CHECK (status IN ('pending', 'ready')),
created_at timestamptz NOT NULL,
updated_at timestamptz NOT NULL
);
CREATE INDEX attachments_chat_idx ON attachments (chat_id);
-- Janitor ищет только «зависшие» pending: частичный индекс маленький.
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE status = 'pending';
-- Ссылки сообщения на вложения (порядок как в запросе).
CREATE TABLE message_attachments (
message_id uuid NOT NULL REFERENCES messages(id),
attachment_id uuid NOT NULL REFERENCES attachments(id),
position integer NOT NULL,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
-- Отпечаток тела в ключе идемпотентности уже включает attachment_ids (= [] для lab3),
-- поэтому существующие ключи остаются валидными без пересчёта.
+126
View File
@@ -0,0 +1,126 @@
-- Lab5: асинхронная обработка вложений (очередь RabbitMQ + worker).
--
-- Жизненный цикл attachments.status:
-- pending — внутреннее: строка записана ДО PUT в staging, API её не показывает (как в lab4);
-- queued — оригинал в staging + задание + запись outbox зафиксированы ОДНОЙ транзакцией, ответ 202;
-- processing — worker взял аренду (lease) задания;
-- ready — оригинал и все варианты в конечном prefix, метаданные вариантов записаны;
-- failed — постоянная ошибка или исчерпаны попытки (error_code).
-- Источник истины по состоянию задания — таблица jobs; сообщение брокера — только «пинок»
-- с job_id: worker все решения принимает по строке jobs (FOR UPDATE).
ALTER TABLE attachments DROP CONSTRAINT attachments_status_check;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_check
CHECK (status IN ('pending', 'queued', 'processing', 'ready', 'failed'));
-- Ключ staging-объекта (staging/<uuid>); NULL после безопасной очистки.
ALTER TABLE attachments ADD COLUMN staging_key text UNIQUE;
ALTER TABLE attachments ADD COLUMN error_code text;
-- Версия pipeline, результат которой сейчас опубликован/ожидается (основной курс: 1).
ALTER TABLE attachments ADD COLUMN pipeline_version integer NOT NULL DEFAULT 1;
-- Одна логическая работа = (attachment_id, pipeline_version). job_id не меняется при
-- redelivery и retry; attempt — номер управляемой попытки (растёт при каждом захвате).
CREATE TABLE jobs (
id uuid PRIMARY KEY,
attachment_id uuid NOT NULL REFERENCES attachments(id),
pipeline_version integer NOT NULL CHECK (pipeline_version >= 1),
status text NOT NULL CHECK (status IN ('queued', 'processing', 'ready', 'failed')),
attempt integer NOT NULL DEFAULT 0 CHECK (attempt >= 0),
max_attempts integer NOT NULL CHECK (max_attempts >= 1),
next_attempt_at timestamptz NOT NULL,
-- Аренда: кто обрабатывает (host:boot), токен попытки (fencing) и срок.
lease_owner text,
lease_token uuid,
lease_until timestamptz,
error_code text,
last_error text,
replay_count integer NOT NULL DEFAULT 0,
created_at timestamptz NOT NULL,
updated_at timestamptz NOT NULL,
finished_at timestamptz,
UNIQUE (attachment_id, pipeline_version),
CHECK ((status = 'processing') = (lease_token IS NOT NULL))
);
CREATE INDEX jobs_lease_idx ON jobs (lease_until) WHERE status = 'processing';
CREATE INDEX jobs_queued_idx ON jobs (updated_at) WHERE status = 'queued';
CREATE INDEX jobs_failed_idx ON jobs (updated_at) WHERE status = 'failed';
-- Результаты: ключ эффекта (attachment_id, pipeline_version, variant) — PRIMARY KEY.
-- Повтор job не может создать второй набор вариантов.
CREATE TABLE attachment_variants (
attachment_id uuid NOT NULL REFERENCES attachments(id),
pipeline_version integer NOT NULL,
name text NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
object_key text NOT NULL UNIQUE,
content_type text NOT NULL CHECK (content_type IN ('image/jpeg', 'image/png', 'image/webp')),
size_bytes bigint NOT NULL CHECK (size_bytes > 0),
width integer NOT NULL CHECK (width > 0),
height integer NOT NULL CHECK (height > 0),
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
created_at timestamptz NOT NULL,
PRIMARY KEY (attachment_id, pipeline_version, name)
);
-- Transactional outbox: сообщение для брокера пишется в той же транзакции, что и
-- задание. Relay публикует с publisher confirm и только потом ставит published_at.
-- available_at позволяет отложить публикацию (retry с backoff).
CREATE TABLE outbox (
id bigserial PRIMARY KEY,
job_id uuid NOT NULL REFERENCES jobs(id),
payload jsonb NOT NULL,
available_at timestamptz NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
published_at timestamptz,
publish_count integer NOT NULL DEFAULT 0
);
CREATE INDEX outbox_unpublished_idx ON outbox (available_at, id) WHERE published_at IS NULL;
CREATE INDEX outbox_job_idx ON outbox (job_id);
-- Журнал переходов (audit): кто, когда, какая попытка, причина. Без секретов и bytes.
CREATE TABLE job_events (
id bigserial PRIMARY KEY,
job_id uuid NOT NULL REFERENCES jobs(id),
at timestamptz NOT NULL DEFAULT clock_timestamp(),
event text NOT NULL,
attempt integer,
actor text,
detail jsonb
);
CREATE INDEX job_events_job_idx ON job_events (job_id, id);
-- Relay ждёт NOTIFY, а не опрашивает таблицу каждые N мс. Уведомление доставляется
-- только после COMMIT; при потере уведомления relay всё равно делает опрос раз в секунду.
CREATE FUNCTION outbox_notify() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
PERFORM pg_notify('outbox', '');
RETURN NULL;
END $$;
CREATE TRIGGER outbox_notify_trg AFTER INSERT ON outbox
FOR EACH STATEMENT EXECUTE FUNCTION outbox_notify();
-- Переход lab4 -> lab5: готовые вложения lab4 не имеют вариантов. Их оригинал
-- (originals/<uuid>) становится staging-объектом, вложение — queued, создаётся задание.
-- Готовность заявляется только когда все варианты уровня существуют.
WITH legacy AS (
UPDATE attachments
SET staging_key = object_key,
object_key = 'attachments/' || id || '/v1/original',
status = 'queued',
updated_at = now()
WHERE status = 'ready'
RETURNING id
), new_jobs AS (
INSERT INTO jobs (id, attachment_id, pipeline_version, status, attempt, max_attempts,
next_attempt_at, created_at, updated_at)
SELECT gen_random_uuid(), id, 1, 'queued', 0, 5, now(), now(), now() FROM legacy
RETURNING id, attachment_id, created_at
), events AS (
INSERT INTO job_events (job_id, event, attempt, actor, detail)
SELECT id, 'enqueued', 1, 'migration', '{"reason":"lab4 backfill"}'::jsonb FROM new_jobs
)
INSERT INTO outbox (job_id, payload, available_at)
SELECT id,
jsonb_build_object('schema_version', 1, 'job_id', id, 'type', 'attachment.process.v1',
'attachment_id', attachment_id, 'pipeline_version', 1, 'attempt', 1,
'created_at', to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')),
now()
FROM new_jobs;
+19
View File
@@ -0,0 +1,19 @@
# Закреплённые версии. Lab5 (аудит F04): Pillow 13.0.0 (GHSA-wqgw-9xfh-qf2g, EXIF memory DoS),
# urllib3 2.8.0 (GHSA-vxq7-64xx-v4gw), minio 7.2.20 — совместимая с новым urllib3.
# Драйвер PostgreSQL для Python (из lab3).
psycopg[binary]==3.2.3
psycopg-pool==3.2.4
# Lab4: S3-клиент (SigV4, multipart) и проверка JPEG (draft-декодирование).
minio==7.2.20
urllib3==2.8.0
# Lab5: Pillow также делает варианты (JPEG, WebP — libwebp входит в wheel).
Pillow==13.0.0
# Lab5: клиент AMQP 0-9-1 для RabbitMQ (publisher confirms, manual ack, basic.qos).
pika==1.3.2
# Lab6: OpenTelemetry SDK (traces, metrics, logs) и экспорт OTLP/HTTP protobuf в Collector.
# Транзитивные зависимости (protobuf, requests, googleapis-common-protos) зафиксированы в
# evidence/pip-freeze.txt по фактической сборке образа.
opentelemetry-api==1.45.1
opentelemetry-sdk==1.45.1
opentelemetry-exporter-otlp-proto-http==1.45.1
opentelemetry-semantic-conventions==0.66b1
+323
View File
@@ -0,0 +1,323 @@
#!/usr/bin/env python3
"""Генератор импортируемого dashboard Grafana: infra/grafana/dashboards/messenger.json.
JSON лежит в Git и подхватывается provisioning-ом; этот скрипт — воспроизводимый способ его
изменить (python3 scripts/build_dashboard.py). Только стандартная библиотека.
Все запросы ссылаются на реальные имена метрик (см. REPORT.md «Схема сигналов»).
Перцентили — histogram_quantile по sum by (le) buckets всех реплик, не среднее p95.
"""
import json
from pathlib import Path
OUT = Path(__file__).resolve().parents[1] / "infra/grafana/dashboards/messenger.json"
PROM = {"type": "prometheus", "uid": "prometheus"}
LOKI = {"type": "loki", "uid": "loki"}
TEMPO = {"type": "tempo", "uid": "tempo"}
API = 'job="messenger-api", instance=~"$instance"'
BUSINESS = API + ', http_route!~"/health/.*|unmatched"'
_panels = []
_id = [0]
_pos = {"x": 0, "y": 0, "h": 0}
def _next_id():
_id[0] += 1
return _id[0]
def place(w, h):
if _pos["x"] + w > 24:
_pos["x"] = 0
_pos["y"] += _pos["h"]
_pos["h"] = 0
g = {"x": _pos["x"], "y": _pos["y"], "w": w, "h": h}
_pos["x"] += w
_pos["h"] = max(_pos["h"], h)
return g
def row(title):
_pos["x"] = 0
_pos["y"] += _pos["h"]
_pos["h"] = 0
_panels.append({"type": "row", "id": _next_id(), "title": title, "collapsed": False,
"gridPos": {"x": 0, "y": _pos["y"], "w": 24, "h": 1}, "panels": []})
_pos["y"] += 1
def target(expr, legend="", ref="A", exemplar=False, instant=False):
t = {"datasource": PROM, "expr": expr, "legendFormat": legend or "__auto", "refId": ref,
"range": not instant, "instant": instant}
if exemplar:
t["exemplar"] = True
return t
def ts(title, targets, unit="short", w=8, h=8, description="", stack=False, min0=True, thresholds=None):
refs = "ABCDEFGHIJ"
tg = [target(*t[:2], ref=refs[i], exemplar=(len(t) > 2 and t[2])) for i, t in enumerate(targets)]
p = {"type": "timeseries", "id": _next_id(), "title": title, "description": description,
"datasource": PROM, "gridPos": place(w, h), "targets": tg,
"fieldConfig": {"defaults": {"unit": unit, "custom": {"lineWidth": 1, "fillOpacity": 10,
"showPoints": "never",
"stacking": {"mode": "normal" if stack else "none"}},
**({"min": 0} if min0 else {})},
"overrides": []},
"options": {"legend": {"displayMode": "table", "placement": "bottom", "calcs": ["lastNotNull", "max"]},
"tooltip": {"mode": "multi", "sort": "desc"}}}
if thresholds:
p["fieldConfig"]["defaults"]["thresholds"] = {"mode": "absolute", "steps": thresholds}
p["fieldConfig"]["defaults"]["custom"]["thresholdsStyle"] = {"mode": "line+area"}
_panels.append(p)
def stat(title, expr, unit="short", w=3, h=4, steps=None, description="", decimals=None):
p = {"type": "stat", "id": _next_id(), "title": title, "description": description, "datasource": PROM,
"gridPos": place(w, h), "targets": [target(expr, "", instant=True)],
"fieldConfig": {"defaults": {"unit": unit, "thresholds": {"mode": "absolute", "steps": steps or [
{"color": "green", "value": None}]}}, "overrides": []},
"options": {"reduceOptions": {"calcs": ["lastNotNull"], "fields": "", "values": False},
"colorMode": "background", "graphMode": "area", "textMode": "value"}}
if decimals is not None:
p["fieldConfig"]["defaults"]["decimals"] = decimals
_panels.append(p)
def build():
# ------------------------------------------------------------------ обзор
row("Обзор и SLO")
stat("RPS бизнес-запросов", "messenger:http_requests:rate2m", "reqps",
description="sum(rate(http_server_request_duration_seconds_count{job=messenger-api, без /health}[2m]))")
stat("5xx, доля (2m)", "messenger:http_error_ratio:rate2m", "percentunit", decimals=2,
steps=[{"color": "green", "value": None}, {"color": "orange", "value": 0.01}, {"color": "red", "value": 0.05}],
description="Числитель: 5xx бизнес-запросов; знаменатель: все бизнес-запросы (без /health, unmatched).")
stat("p95 API (5m)", "messenger:http_latency_seconds:p95_5m", "s", decimals=3,
steps=[{"color": "green", "value": None}, {"color": "orange", "value": 0.5}, {"color": "red", "value": 1}])
stat("SLO доступности, 7d", "messenger:slo_availability:ratio_7d", "percentunit", decimals=3,
steps=[{"color": "red", "value": None}, {"color": "green", "value": 0.995}],
description="SLO: 99.5 % бизнес-запросов без 5xx за скользящие 7 дней.")
stat("Остаток error budget, 7d", "messenger:slo_availability:error_budget_remaining_7d", "percentunit",
decimals=1, steps=[{"color": "red", "value": None}, {"color": "orange", "value": 0.25},
{"color": "green", "value": 0.5}])
stat("Time to ready p95", "messenger:time_to_ready_seconds:p95_5m", "s", decimals=2,
steps=[{"color": "green", "value": None}, {"color": "orange", "value": 10}, {"color": "red", "value": 30}],
description="От durable acceptance (COMMIT enqueue) до COMMIT ready. SLO: 99 % не дольше 30 с.")
stat("Ready lag очереди", "max(messenger_jobs_ready_lag_seconds) or vector(0)", "s", decimals=0,
steps=[{"color": "green", "value": None}, {"color": "orange", "value": 10}, {"color": "red", "value": 30}],
description="Сколько ждёт worker самое старое созревшее задание (PostgreSQL jobs).")
stat("Alerts firing", 'count(ALERTS{alertstate="firing"}) or vector(0)', "short",
steps=[{"color": "green", "value": None}, {"color": "red", "value": 1}])
_panels.append({
"type": "state-timeline", "id": _next_id(), "title": "История alerts (pending/firing -> resolved)",
"datasource": PROM, "gridPos": place(24, 6),
"targets": [target('max by (alertname, source, alertstate) (ALERTS)', "{{alertname}} {{source}} {{alertstate}}")],
"fieldConfig": {"defaults": {"color": {"mode": "thresholds"},
"thresholds": {"mode": "absolute", "steps": [
{"color": "transparent", "value": None}, {"color": "red", "value": 1}]}},
"overrides": []},
"options": {"showValue": "never", "mergeValues": True, "rowHeight": 0.8,
"legend": {"showLegend": False}}})
# ------------------------------------------------------------------ API
row("API: трафик, ошибки, задержка")
ts("RPS по маршруту", [("sum by (http_route) (rate(http_server_request_duration_seconds_count{%s}[1m]))" % API,
"{{http_route}}")], "reqps", stack=True)
ts("Ответы по классу статуса", [(
"sum by (http_response_status_class) (rate(http_server_request_duration_seconds_count{%s}[1m]))" % BUSINESS,
"{{http_response_status_class}}")], "reqps", stack=True)
ts("Доля 5xx: API и LB", [
("messenger:http_error_ratio:rate2m", "API (без /health)"),
("messenger:lb_error_ratio:rate2m", "HAProxy fe_api")], "percentunit",
thresholds=[{"color": "transparent", "value": None}, {"color": "red", "value": 0.05}],
description="Если БД недоступна, реплики не ready и 503 отдаёт LB: эти запросы видны только в метрике LB.")
ts("Задержка API p50/p95/p99 (из histogram)", [
("histogram_quantile(0.50, sum by (le) (rate(http_server_request_duration_seconds_bucket{%s}[1m])))" % BUSINESS, "p50", True),
("histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{%s}[1m])))" % BUSINESS, "p95", True),
("histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{%s}[1m])))" % BUSINESS, "p99", True)],
"s", w=12, description="Точки-exemplars ведут в трассу Tempo конкретного запроса.")
ts("p95 по маршруту", [(
"histogram_quantile(0.95, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{%s}[5m])))" % BUSINESS,
"{{http_route}}")], "s", w=12)
ts("5xx по причине (error.type)", [(
'sum by (error_type, http_route) (rate(http_server_request_duration_seconds_count{%s, http_response_status_class="5xx"}[1m]))' % API,
"{{error_type}} {{http_route}}")], "reqps", stack=True)
ts("Запросы в обработке (saturation API)", [
("sum by (instance) (http_server_active_requests{%s})" % API, "{{instance}}")], "short")
ts("HAProxy: UP-реплики и очередь LB", [
('haproxy_backend_active_servers{proxy="be_api"}', "UP реплик"),
('haproxy_backend_current_queue{proxy="be_api"}', "очередь LB")], "short")
# ------------------------------------------------------------------ worker
row("Worker и очередь заданий")
ts("Задания по исходу (в минуту)", [(
"sum by (messenger_job_outcome) (increase(messenger_jobs_processed_total[1m]))", "{{messenger_job_outcome}}")],
"short", stack=True, description="ready / retry / failed / duplicate / lease_lost / rejected / requeued")
ts("Длительность обработки job p50/p95/p99", [
('histogram_quantile(0.50, sum by (le) (rate(messenger_job_duration_seconds_bucket{messenger_job_outcome="ready"}[5m])))', "p50", True),
('histogram_quantile(0.95, sum by (le) (rate(messenger_job_duration_seconds_bucket{messenger_job_outcome="ready"}[5m])))', "p95", True),
('histogram_quantile(0.99, sum by (le) (rate(messenger_job_duration_seconds_bucket{messenger_job_outcome="ready"}[5m])))', "p99", True)],
"s")
ts("Time to ready p50/p95/p99", [
('histogram_quantile(0.50, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[5m])))', "p50", True),
('histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[5m])))', "p95", True),
('histogram_quantile(0.99, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[5m])))', "p99", True)],
"s", description="Backlog-ожидание + обработка: время от 202 (COMMIT) до ready.")
ts("Глубина очереди: PostgreSQL и RabbitMQ", [
('max by (messenger_job_status) (messenger_jobs_count{messenger_job_status=~"queued|processing"})', "jobs {{messenger_job_status}} (БД)"),
('max(messenger_outbox_pending)', "outbox не опубликовано"),
('sum(rabbitmq_detailed_queue_messages_ready{queue="attachments.process.v1"})', "RabbitMQ ready"),
('sum(rabbitmq_detailed_queue_messages_unacked{queue="attachments.process.v1"})', "RabbitMQ unacked"),
('sum(rabbitmq_detailed_queue_messages{queue="attachments.dlq"})', "DLQ")], "short")
ts("Возраст старейшего задания и lag", [
('max by (messenger_job_status) (messenger_jobs_oldest_age_seconds)', "oldest {{messenger_job_status}}"),
("max(messenger_jobs_ready_lag_seconds)", "ready lag"),
("max(messenger_outbox_oldest_age_seconds)", "outbox oldest")], "s",
thresholds=[{"color": "transparent", "value": None}, {"color": "red", "value": 30}])
ts("Ожидание в очереди p95 (до claim)", [
("histogram_quantile(0.95, sum by (le) (rate(messenger_job_queue_wait_seconds_bucket[5m])))", "p95 queue wait"),
("histogram_quantile(0.95, sum by (le) (rate(messenger_outbox_publish_delay_seconds_bucket[5m])))", "p95 outbox -> broker")],
"s", description="Backlog (сколько ждут) отдельно от processing latency (сколько обрабатываются).")
ts("Saturation worker: занятость потребителей", [
("sum(rate(messenger_worker_busy_time_seconds_total[1m])) / sum(last_over_time(messenger_worker_capacity[30s]))", "utilization (busy_time/capacity)"),
("sum(messenger_worker_busy) / sum(last_over_time(messenger_worker_capacity[30s]))", "busy/capacity (мгновенно)")],
"percentunit", description="1.0 = все WORKER_CONCURRENCY потоков всех реплик заняты; очередь растёт быстрее обработки.")
ts("Relay: публикации outbox", [
("sum by (outcome) (rate(messenger_outbox_published_total[1m]))", "{{outcome}}")], "short")
# ------------------------------------------------------------------ DB / S3
row("PostgreSQL и S3")
ts("Пул соединений API: used / idle / max", [
('sum by (instance, db_client_connection_state) (db_client_connection_count{%s})' % API,
"{{instance}} {{db_client_connection_state}}"),
('max(db_client_connection_max{%s})' % API, "max на реплику")], "short")
ts("Ожидающие соединение и таймауты пула", [
('sum by (instance) (db_client_connection_pending_requests{%s})' % API, "pending {{instance}}"),
('sum by (instance) (increase(db_client_connection_timeouts_total{%s}[1m]))' % API, "timeouts/мин {{instance}}")],
"short")
ts("Ожидание соединения пула p95", [
('histogram_quantile(0.95, sum by (le) (rate(db_client_connection_wait_time_seconds_bucket{%s}[1m])))' % API, "p95 wait")],
"s")
ts("Операции БД p95 по операции (API)", [
('histogram_quantile(0.95, sum by (le, db_operation_name) (rate(db_client_operation_duration_seconds_bucket{%s}[1m])))' % API,
"{{db_operation_name}}")], "s", w=12)
ts("Операции БД worker/relay p95", [
('histogram_quantile(0.95, sum by (le, db_operation_name) (rate(db_client_operation_duration_seconds_bucket{job=~"messenger-worker|messenger-relay"}[5m])))',
"{{db_operation_name}}")], "s", w=12)
ts("Ошибки операций БД", [
('sum by (job, db_operation_name, error_type) (rate(db_client_operation_duration_seconds_count{error_type!=""}[1m]))',
"{{job}} {{db_operation_name}} {{error_type}}")], "short")
ts("S3 p95 по операции", [
('histogram_quantile(0.95, sum by (le, messenger_s3_operation) (rate(messenger_s3_operation_duration_seconds_bucket[5m])))',
"{{messenger_s3_operation}}")], "s")
ts("S3 ошибки", [
('sum by (job, messenger_s3_operation, outcome) (rate(messenger_s3_operation_duration_seconds_count{outcome!="ok"}[1m]))',
"{{job}} {{messenger_s3_operation}} {{outcome}}")], "short")
# ------------------------------------------------------------------ ресурсы
row("Ресурсы контейнеров (CPU/RAM)")
ts("CPU, ядер (cgroup контейнера)", [
("sum by (job, instance) (rate(container_cpu_time_seconds_total[1m]))", "{{job}} {{instance}}")], "short", w=12)
ts("CPU saturation: доля лимита", [
("rate(container_cpu_time_seconds_total[1m]) / on(job, instance) container_cpu_limit", "{{job}} {{instance}}")],
"percentunit", w=12)
ts("Память контейнеров приложений", [
("container_memory_usage_bytes", "{{job}} {{instance}}")], "bytes", w=12)
ts("Память: доля лимита", [
("container_memory_usage_bytes / on(job, instance) container_memory_limit_bytes", "{{job}} {{instance}}")],
"percentunit", w=12)
ts("Память telemetry-стека (RSS)", [
('process_resident_memory_bytes{job=~"prometheus|loki|tempo"}', "{{job}}"),
('{__name__=~"otelcol_process_memory_rss(_bytes)?"}', "otel-collector RSS (вкл. страницы бинарника)"),
('otelcol_process_runtime_heap_alloc_bytes', "otel-collector Go heap"),
('rabbitmq_process_resident_memory_bytes', "rabbitmq")], "bytes", w=12)
ts("CPU telemetry-стека", [
('rate(process_cpu_seconds_total{job=~"prometheus|loki|tempo"}[1m])', "{{job}}"),
('rate({__name__=~"otelcol_process_cpu_seconds(_total)?"}[1m])', "otel-collector")], "short", w=12)
# ------------------------------------------------------------------ telemetry
row("Конвейер телеметрии (потери)")
ts("Collector: принято / отправлено / потеряно (spans)", [
('sum(rate({__name__=~"otelcol_receiver_accepted_spans(_total)?"}[1m]))', "принято"),
('sum(rate({__name__=~"otelcol_exporter_sent_spans(_total)?"}[1m]))', "отправлено в Tempo"),
('sum(rate({__name__=~"otelcol_exporter_send_failed_spans(_total)?"}[1m]))', "ошибка отправки"),
('sum(rate({__name__=~"otelcol_exporter_enqueue_failed_spans(_total)?"}[1m]))', "очередь полна (потеря)"),
('sum(rate({__name__=~"otelcol_receiver_refused_spans(_total)?"}[1m]))', "отказ приёма (memory_limiter)")], "short")
ts("Collector: логи", [
('sum(rate({__name__=~"otelcol_receiver_accepted_log_records(_total)?"}[1m]))', "принято"),
('sum(rate({__name__=~"otelcol_exporter_sent_log_records(_total)?"}[1m]))', "отправлено в Loki"),
('sum(rate({__name__=~"otelcol_exporter_send_failed_log_records(_total)?"}[1m]))', "ошибка отправки"),
('sum(rate({__name__=~"otelcol_exporter_enqueue_failed_log_records(_total)?"}[1m]))', "очередь полна (потеря)")], "short")
ts("Collector: очередь экспортёров", [
("max by (exporter) (otelcol_exporter_queue_size)", "size {{exporter}}"),
("max by (exporter) (otelcol_exporter_queue_capacity)", "capacity {{exporter}}")], "short")
ts("SDK приложений: потери на стороне процесса", [
('sum by (job, error_type) (rate(otel_sdk_processor_span_processed_total{error_type!=""}[1m]))', "spans dropped {{job}} {{error_type}}"),
('sum by (job, error_type) (rate(otel_sdk_processor_log_processed_total{error_type!=""}[1m]))', "logs dropped {{job}} {{error_type}}"),
('sum by (job, error_type) (rate(otel_sdk_exporter_span_exported_total{error_type!=""}[1m]))', "span export failed {{job}} {{error_type}}")],
"short", w=12)
ts("SDK: заполнение очереди BatchSpanProcessor", [
("max by (job, instance) (otel_sdk_processor_span_queue_size)", "{{job}} {{instance}}"),
("max(otel_sdk_processor_span_queue_capacity)", "capacity")], "short", w=12)
# ------------------------------------------------------------------ logs / traces
row("Логи и трассы")
_panels.append({
"type": "logs", "id": _next_id(), "title": "Логи WARN/ERROR приложений (Loki)", "datasource": LOKI,
"gridPos": place(24, 10),
"targets": [{"datasource": LOKI, "refId": "A", "queryType": "range",
"expr": '{service_name=~"messenger-.+"} | severity_text=~"WARN.*|ERROR.*|CRITICAL"'}],
"options": {"showTime": True, "wrapLogMessage": True, "enableLogDetails": True, "sortOrder": "Descending",
"dedupStrategy": "none", "prettifyLogMessage": False}})
_panels.append({
"type": "logs", "id": _next_id(), "title": "HTTP 5xx (event=http.request)", "datasource": LOKI,
"gridPos": place(12, 10),
"targets": [{"datasource": LOKI, "refId": "A", "queryType": "range",
"expr": '{service_name="messenger-api"} | event="http.request" | http_response_status_code >= 500'}],
"options": {"showTime": True, "wrapLogMessage": True, "enableLogDetails": True, "sortOrder": "Descending"}})
_panels.append({
"type": "table", "id": _next_id(), "title": "Последние трассы обработки заданий (Tempo)", "datasource": TEMPO,
"gridPos": place(12, 10),
"targets": [{"datasource": TEMPO, "refId": "A", "queryType": "traceql", "limit": 20, "tableType": "traces",
"query": '{ resource.service.name = "messenger-worker" && name = "attachments.process.v1 process" }'}]})
_panels.append({
"type": "table", "id": _next_id(), "title": "Медленные запросы API > 1 s (Tempo)", "datasource": TEMPO,
"gridPos": place(12, 10),
"targets": [{"datasource": TEMPO, "refId": "A", "queryType": "traceql", "limit": 20, "tableType": "traces",
"query": '{ resource.service.name = "messenger-api" && kind = server && duration > 1s }'}]})
_panels.append({
"type": "table", "id": _next_id(), "title": "Трассы с ошибкой (Tempo)", "datasource": TEMPO,
"gridPos": place(12, 10),
"targets": [{"datasource": TEMPO, "refId": "A", "queryType": "traceql", "limit": 20, "tableType": "traces",
"query": '{ status = error }'}]})
return {
"uid": "messenger-overview",
"title": "Messenger — наблюдаемость (lab6)",
"description": "API, worker, очередь, PostgreSQL, S3, ресурсы, конвейер телеметрии. Provisioning из Git.",
"tags": ["messenger", "lab6", "otel"],
"timezone": "browser",
"editable": False,
"graphTooltip": 1,
"refresh": "10s",
"schemaVersion": 39,
"version": 1,
"time": {"from": "now-30m", "to": "now"},
"templating": {"list": [{
"name": "instance", "label": "API-реплика", "type": "query", "datasource": PROM,
"query": {"query": 'label_values(http_server_request_duration_seconds_count{job="messenger-api"}, instance)',
"refId": "PrometheusVariableQueryEditor-VariableQuery"},
"definition": 'label_values(http_server_request_duration_seconds_count{job="messenger-api"}, instance)',
"includeAll": True, "multi": True, "allValue": ".*", "current": {"text": "All", "value": "$__all"},
"refresh": 2, "sort": 1}]},
"annotations": {"list": [{
"builtIn": 1, "datasource": {"type": "grafana", "uid": "-- Grafana --"}, "enable": True, "hide": True,
"iconColor": "rgba(0, 211, 255, 1)", "name": "Annotations & Alerts", "type": "dashboard"}]},
"panels": _panels,
}
if __name__ == "__main__":
OUT.parent.mkdir(parents=True, exist_ok=True)
OUT.write_text(json.dumps(build(), ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
print("written %s (%d panels)" % (OUT.relative_to(OUT.parents[3]), len(_panels)))
+24
View File
@@ -0,0 +1,24 @@
#!/bin/sh
# Офлайн-проверка конфигураций телеметрии теми же образами, что и стенд (сеть не нужна):
# promtool check config + check rules + unit-тесты alert rules,
# otelcol-contrib validate, loki -verify-config.
# Использование: scripts/check_rules.sh (код возврата 0 — всё валидно)
set -eu
cd "$(dirname "$0")/.."
img() { grep -E "^\s+image: $1" compose.yaml | head -1 | awk '{print $2}'; }
PROM=$(img prom/prometheus)
OTEL=$(img otel/opentelemetry-collector-contrib)
LOKI=$(img grafana/loki)
echo "== promtool check config ($PROM)"
docker run --rm -v "$PWD/infra/prometheus:/etc/prometheus:ro" --entrypoint promtool "$PROM" check config /etc/prometheus/prometheus.yml
echo "== promtool test rules"
docker run --rm -v "$PWD/infra/prometheus:/w:ro" -w /w/tests --entrypoint promtool "$PROM" test rules messenger.test.yml
echo "== otelcol validate ($OTEL)"
docker run --rm -v "$PWD/infra/otel/collector.yaml:/c.yaml:ro" "$OTEL" validate --config=/c.yaml && echo "collector config OK"
echo "== loki -verify-config ($LOKI)"
docker run --rm -v "$PWD/infra/loki/loki.yaml:/c.yaml:ro" "$LOKI" -config.file=/c.yaml -verify-config && echo "loki config OK"
echo "== dashboard JSON is up to date with scripts/build_dashboard.py"
tmp=$(mktemp)
cp infra/grafana/dashboards/messenger.json "$tmp"
python3 scripts/build_dashboard.py >/dev/null
cmp -s "$tmp" infra/grafana/dashboards/messenger.json && echo "dashboard OK" || { echo "dashboard JSON differs from generator" >&2; exit 1; }
+50
View File
@@ -0,0 +1,50 @@
#!/bin/sh
# Уровень 4: ПОСЛЕДОВАТЕЛЬНО останавливает КАЖДУЮ API-реплику под нагрузкой,
# восстанавливая предыдущую перед следующей. Режимы:
# stop — docker stop (SIGTERM -> graceful drain), штатная остановка/деплой;
# kill — docker kill (SIGKILL), внезапное падение процесса без drain.
# Результаты: evidence/failover-<mode>-<container>.json (+ .action.log).
# Использование: scripts/failover-each.sh [stop|kill] ... (по умолчанию: stop kill)
set -eu
cd "$(dirname "$0")/.."
MODES=${*:-stop kill}
CONCURRENCY=${CONCURRENCY:-8}
DURATION=${DURATION:-40}
mkdir -p evidence
wait_all_up() {
# API-контейнеры healthy и HAProxy видит их все UP (rise 2 * inter 1s).
./scripts/start-all.sh >/dev/null
n=$(docker compose ps -q api | wc -l | tr -d ' ')
for _ in $(seq 1 60); do
up=$(curl -s 'http://127.0.0.1:8404/stats;csv' | awk -F, '$1=="be_api" && $18=="UP"' | wc -l | tr -d ' ')
[ "$up" -ge "$n" ] && return 0
sleep 1
done
echo "HAProxy did not mark all $n api servers UP" >&2; return 1
}
wait_all_up
# Список фиксируется один раз: остановленная реплика пропала бы из `docker compose ps`.
NAMES=$(docker compose ps --format '{{.Name}}' api | sort)
for mode in $MODES; do
for name in $NAMES; do
wait_all_up
cid=$(docker inspect -f '{{.Id}}' "$name"); short=$(echo "$cid" | cut -c1-12)
case $mode in
stop) action="docker stop -t 20 $cid" ;;
kill) action="docker kill $cid" ;;
*) echo "unknown mode $mode" >&2; exit 2 ;;
esac
echo "== $mode $name ($short) $(date -u +%FT%TZ)"
out=evidence/failover-$mode-$name.json
python3 student-tests/failover_bench.py --label "$mode $name" \
--concurrency "$CONCURRENCY" --duration "$DURATION" --action-at 10 \
--action "$action" --target-instance "$short" \
--action-log "${out%.json}.action.log" --output "$out" \
| python3 -c 'import json,sys; t=sys.stdin.read(); s=json.loads(t[:t.rindex("}")+1]); print(json.dumps({k:s[k] for k in ("baseline_ok_rps","post_action_ok_rps","capacity_ratio","errors_total","errors_by_kind","error_window_s","recovery_s","target_last_seen_s","lb_events","lost_confirmed","duplicate_texts","pass")},ensure_ascii=False)); sys.exit(0 if s["pass"] else 1)'
echo "-- state after action:"; docker compose ps -a --format '{{.Name}} {{.Status}}' api
done
done
wait_all_up
echo "== restored: $(docker compose ps --format '{{.Name}} {{.Status}}' api | tr '\n' ';')"
+114
View File
@@ -0,0 +1,114 @@
#!/bin/sh
# Создаёт локальные секреты и .env для учебного стенда (lab6). Повторный запуск ничего не перезаписывает.
# Значения секретов не печатаются.
#
# S3 (SeaweedFS) — РАЗНЫЕ ключи с разными правами (secrets/s3_identities.json):
# admin — Admin/Read/Write/List: только job s3-init (создание bucket);
# api — Read+Write на bucket: staging PUT и выдача байтов, без List и без управления bucket;
# worker — Read+Write на bucket: чтение staging, запись результатов, удаление staging;
# janitor — List+Write на bucket: обход и удаление, без чтения содержимого.
# RabbitMQ — пользователи с минимальными правами в vhost messenger (secrets/rabbitmq_definitions.json):
# relay — только publish в exchange attachments;
# worker — только consume из attachments.process.v1;
# ops — consume из DLQ и publish в attachments (replay/учебные проверки).
# Ни у кого из них нет права configure: топология создаётся из definitions при старте брокера.
set -eu
cd "$(dirname "$0")/.."
umask 077
mkdir -p secrets
chmod 700 secrets
gen() { # gen <file> <bytes>
if [ ! -s "secrets/$1" ]; then
python3 -c "import secrets,sys; print(secrets.token_urlsafe(int(sys.argv[1])))" "$2" > "secrets/$1"
echo "created secrets/$1"
fi
}
gen postgres_password 24
# Lab6: пароль администратора Grafana (GF_SECURITY_ADMIN_PASSWORD__FILE).
gen grafana_admin_password 18
for who in admin api worker janitor; do
if [ ! -s "secrets/s3_${who}_access_key" ]; then
python3 -c "import secrets; print('MTUSI' + secrets.token_hex(8).upper())" > "secrets/s3_${who}_access_key"
echo "created secrets/s3_${who}_access_key"
fi
gen "s3_${who}_secret_key" 30
done
for who in relay worker ops; do
gen "broker_${who}_password" 24
done
BUCKET=$(grep -E '^S3_BUCKET=' .env 2>/dev/null | cut -d= -f2 || true)
BUCKET=${BUCKET:-messenger-attachments}
# Производные файлы пересобираются из базовых секретов (детерминированно, кроме соли хеша).
python3 - "$BUCKET" <<'PY'
import base64, hashlib, json, os, sys
b = sys.argv[1]
def read(name):
return open("secrets/" + name).read().strip()
def ident(name, actions):
return {"name": name, "credentials": [{"accessKey": read("s3_%s_access_key" % name),
"secretKey": read("s3_%s_secret_key" % name)}], "actions": actions}
cfg = {"identities": [
ident("admin", ["Admin", "Read", "List", "Tagging", "Write"]),
ident("api", ["Read:" + b, "Write:" + b]),
ident("worker", ["Read:" + b, "Write:" + b]),
ident("janitor", ["List:" + b, "Write:" + b]),
]}
with open("secrets/s3_identities.json", "w") as f:
json.dump(cfg, f, indent=1)
# RabbitMQ: rabbit_password_hashing_sha256 = base64(salt4 + sha256(salt4 + password)).
def rmq_hash(password):
salt = os.urandom(4)
return base64.b64encode(salt + hashlib.sha256(salt + password.encode()).digest()).decode()
vhost = "messenger"
users, perms = [], []
rights = {
"relay": {"configure": "^$", "write": "^attachments$", "read": "^$"},
"worker": {"configure": "^$", "write": "^$", "read": r"^attachments\.process\.v1$"},
"ops": {"configure": "^$", "write": "^attachments$", "read": r"^attachments\.dlq$"},
}
for user, r in rights.items():
password = read("broker_%s_password" % user)
users.append({"name": user, "password_hash": rmq_hash(password),
"hashing_algorithm": "rabbit_password_hashing_sha256", "tags": []})
perms.append(dict(user=user, vhost=vhost, **r))
with open("secrets/broker_%s_url" % user, "w") as f:
f.write("amqp://%s:%s@broker:5672/%s\n" % (user, password, vhost))
x = lambda name, kind: {"name": name, "vhost": vhost, "type": kind, "durable": True, "auto_delete": False,
"internal": False, "arguments": {}}
definitions = {
"users": users,
"vhosts": [{"name": vhost}],
"permissions": perms,
"exchanges": [x("attachments", "direct"), x("attachments.dlx", "fanout")],
"queues": [
# Quorum-очередь: durable, сообщения пишутся на диск (Raft-журнал) до publisher confirm.
# delivery-limit: сообщение, которое 10 раз вернулось без ack (crash-loop worker),
# уходит в DLQ. at-least-once dead-lettering требует overflow=reject-publish.
{"name": "attachments.process.v1", "vhost": vhost, "durable": True, "auto_delete": False,
"arguments": {"x-queue-type": "quorum", "x-delivery-limit": 10,
"x-dead-letter-exchange": "attachments.dlx",
"x-dead-letter-strategy": "at-least-once", "x-overflow": "reject-publish",
"x-max-length": 100000}},
{"name": "attachments.dlq", "vhost": vhost, "durable": True, "auto_delete": False,
"arguments": {"x-queue-type": "quorum"}},
],
"bindings": [
{"source": "attachments", "vhost": vhost, "destination": "attachments.process.v1",
"destination_type": "queue", "routing_key": "attachment.process.v1", "arguments": {}},
{"source": "attachments.dlx", "vhost": vhost, "destination": "attachments.dlq",
"destination_type": "queue", "routing_key": "", "arguments": {}},
],
}
if not os.path.exists("secrets/rabbitmq_definitions.json"):
with open("secrets/rabbitmq_definitions.json", "w") as f:
json.dump(definitions, f, indent=1)
print("created secrets/rabbitmq_definitions.json")
PY
# Файлы монтируются в контейнеры (uid 70 postgres, uid 10001 app, uid 100 rabbitmq, root в seaweedfs) —
# нужны на чтение; от других пользователей хоста их закрывает каталог secrets/ с правами 700.
chmod 644 secrets/*
if [ ! -f .env ]; then
cp .env.example .env
echo "created .env from .env.example"
fi
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Перезапуск ВСЕХ хранилищ — данных (PostgreSQL, SeaweedFS S3, RabbitMQ) и, с lab6, телеметрии
# (Prometheus, Loki, Tempo) — и всех процессов (API-реплики, relay, worker, janitor, LB,
# OTel Collector, Grafana) с сохранением volumes pgdata, s3data, brokerdata, promdata, lokidata,
# tempodata, grafanadata. Не выполняет down -v, не пересоздаёт БД/bucket/очереди и не повторяет seed.
set -eu
cd "$(dirname "$0")/.."
docker compose restart db s3 broker prometheus loki tempo
# Потребители стартуют, когда хранилища действительно готовы (healthcheck s3 проверяет запись,
# healthcheck broker — запущенный узел и объявленную очередь, prometheus — /-/ready).
docker compose up -d --no-deps --no-recreate --wait db s3 broker prometheus
docker compose restart otel-collector api relay worker janitor lb grafana
+69
View File
@@ -0,0 +1,69 @@
#!/bin/sh
# Поочерёдная замена API-реплик на новую версию образа без остановки сервиса.
# scripts/rolling-update.sh <APP_VERSION>
# Порядок (expand -> replace):
# 1. собрать новый образ (тот же тег mtusi-messenger:lab6, build-arg APP_VERSION). Секция build
# есть только у сервиса migrate (аудит F10: `build api` молча ничего не собирал), поэтому
# собираем migrate и проверяем, что в образе действительно новая версия;
# 2. ОДИН раз применить миграции (job migrate). Допускаются только обратно совместимые
# (expand-only) миграции: старые реплики продолжают работать на новой схеме;
# 3. для каждой старой реплики: поднять +1 новую -> дождаться healthy и UP в HAProxy ->
# штатно остановить (SIGTERM, drain) и удалить старую. Число обслуживающих реплик
# не опускается ниже исходного.
# 4. записать APP_VERSION в .env, чтобы следующий `docker compose up` не пересоздал всё разом.
set -eu
cd "$(dirname "$0")/.."
VERSION=${1:?usage: rolling-update.sh <APP_VERSION>}
export APP_VERSION="$VERSION"
ts() { date -u +%FT%TZ; }
lb_up_count() {
curl -s 'http://127.0.0.1:8404/stats;csv' | awk -F, '$1=="be_api" && $18=="UP"' | wc -l | tr -d ' '
}
# UP ли в HAProxy слот с адресом конкретного контейнера. Проверяем именно адрес, а не число
# UP-серверов: новый контейнер может получить IP только что удалённого, и счётчик обманет.
lb_has_up() {
curl -s 'http://127.0.0.1:8404/stats;csv' | awk -F, -v a="$1:8080" '$1=="be_api" && $18=="UP" && $74==a' | grep -q .
}
echo "$(ts) build version $VERSION"
docker compose --env-file .env build migrate >/dev/null
built=$(docker run --rm --entrypoint printenv mtusi-messenger:lab6 APP_VERSION)
[ "$built" = "$VERSION" ] || { echo "image has APP_VERSION=$built, expected $VERSION" >&2; exit 1; }
echo "$(ts) migrate (once)"
docker compose --env-file .env run --rm --no-deps migrate
OLD=$(docker compose ps -q api)
N=$(echo "$OLD" | wc -l | tr -d ' ')
echo "$(ts) replacing $N replicas"
for old in $OLD; do
before=$(docker compose ps -q api | sort)
docker compose --env-file .env up -d --no-deps --no-recreate --scale api=$((N + 1)) api >/dev/null 2>&1
new=$(docker compose ps -q api | sort | grep -v -F "$before" | head -1)
[ -n "$new" ] || { echo "new replica was not created" >&2; exit 1; }
for _ in $(seq 1 60); do
[ "$(docker inspect -f '{{.State.Health.Status}}' "$new")" = healthy ] && break; sleep 1
done
[ "$(docker inspect -f '{{.State.Health.Status}}' "$new")" = healthy ] || { echo "new replica not healthy" >&2; exit 1; }
ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$new")
for _ in $(seq 1 30); do lb_has_up "$ip" && break; sleep 0.5; done
lb_has_up "$ip" || { echo "HAProxy did not mark new replica $ip UP" >&2; exit 1; }
got=$(docker exec "$new" printenv APP_VERSION)
[ "$got" = "$VERSION" ] || { echo "new replica runs APP_VERSION=$got, expected $VERSION" >&2; exit 1; }
echo "$(ts) up $(docker inspect -f '{{.Name}}' "$new" | tr -d /) version=$got ip=$ip UP in LB (UP slots: $(lb_up_count))"
name=$(docker inspect -f '{{.Name}}' "$old" | tr -d /)
docker stop -t 20 "$old" >/dev/null && docker rm "$old" >/dev/null
echo "$(ts) gone $name (graceful SIGTERM)"
done
if grep -q '^APP_VERSION=' .env; then
sed -i.bak "s/^APP_VERSION=.*/APP_VERSION=$VERSION/" .env && rm -f .env.bak
else
echo "APP_VERSION=$VERSION" >> .env
fi
echo "$(ts) done: $(docker compose ps --format '{{.Name}}' api | tr '\n' ' ')"
# Проверка через LB: все ответы — от новой версии.
for _ in $(seq 1 10); do
v=$(curl -s -D - -o /dev/null http://127.0.0.1:${LB_PORT:-8080}/health/ready | tr -d '\r' | awk -F': ' 'tolower($1)=="x-app-version"{print $2}')
[ "$v" = "$VERSION" ] || { echo "LB served X-App-Version=$v, expected $VERSION" >&2; exit 1; }
done
echo "$(ts) verified: 10/10 responses via LB have X-App-Version=$VERSION"
+40
View File
@@ -0,0 +1,40 @@
#!/usr/bin/env python3
"""Проверка перед commit: значения из secrets/ (пароли, ключи S3, URL брокера) не встречаются
ни в одном файле репозитория вне secrets/ и .env. Значения не печатаются — только имена файлов.
python3 scripts/scan_secrets.py (код 0 — чисто)"""
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SKIP_DIRS = {".git", "secrets", ".venv", "__pycache__", "node_modules"}
values = set()
for f in (ROOT / "secrets").glob("*"):
text = f.read_text(encoding="utf-8", errors="replace").strip()
if f.suffix == ".json":
def walk(x):
if isinstance(x, dict):
for k, v in x.items():
if k in ("accessKey", "secretKey", "password_hash"):
values.add(str(v))
walk(v)
elif isinstance(x, list):
for v in x:
walk(v)
walk(json.loads(text))
elif len(text) >= 8:
values.add(text)
if "://" in text and "@" in text: # пароль из URL брокера
values.add(text.split("://", 1)[1].split("@", 1)[0].split(":", 1)[-1])
hits = []
for p in ROOT.rglob("*"):
if p.is_dir() or set(p.relative_to(ROOT).parts) & SKIP_DIRS or p.name == ".env":
continue
try:
data = p.read_text(encoding="utf-8", errors="ignore")
except OSError:
continue
if any(v in data for v in values):
hits.append(str(p.relative_to(ROOT)))
print("checked %d secret values; files with leaks: %s" % (len(values), hits or "none"))
sys.exit(1 if hits else 0)
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Восстанавливает остановленные API-реплики и worker (после stop-one.sh / stop-worker.sh) и ждёт готовности.
# --no-deps: хранилища и job-ы не трогаются; --no-recreate: те же контейнеры (тот же образ).
set -eu
cd "$(dirname "$0")/.."
docker compose up -d --no-deps --no-recreate --wait api worker
docker compose ps --format '{{.Name}} {{.Status}}' api worker
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
# Запустить worker после stop-worker.sh (те же контейнеры) и дождаться готовности.
set -eu
cd "$(dirname "$0")/.."
docker compose up -d --no-deps --no-recreate --wait worker
docker compose ps --format '{{.Name}} {{.Status}}' worker
+19
View File
@@ -0,0 +1,19 @@
#!/bin/sh
# Останавливает ОДНУ API-реплику, обслужившую тест, и оставляет её остановленной.
# TARGET_INSTANCE_ID = X-Instance-Id = hostname контейнера = короткий ID контейнера.
# DB, LB и volumes не трогаются. Восстановление: scripts/start-all.sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]*|'') echo "unexpected instance id format" >&2; exit 2 ;;
esac
# Проверяем, что это действительно запущенный контейнер сервиса api ЭТОГО compose-проекта.
# Список берём у самого compose: работает и при другом имени проекта (-p / COMPOSE_PROJECT_NAME).
cid=$(docker compose ps -q --status running api | grep "^${TARGET_INSTANCE_ID}" || true)
[ -n "$cid" ] || { echo "no running api container for $TARGET_INSTANCE_ID" >&2; exit 3; }
name=$(docker inspect -f '{{.Name}}' "$cid")
echo "$(date -u +%FT%TZ) stopping api container ${name#/} (${TARGET_INSTANCE_ID})" >&2
# SIGTERM -> graceful shutdown приложения (drain 3 с + дообслуживание), затем выход.
docker stop -t 20 "$cid" >/dev/null
echo "$(date -u +%FT%TZ) stopped ${name#/}" >&2
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Сценарий защиты: остановить ВСЕ worker (SIGTERM, текущие задания дорабатываются).
# API, relay и брокер продолжают работать: upload -> 202, задания копятся в очереди.
set -eu
cd "$(dirname "$0")/.."
docker compose stop worker
docker compose ps --format '{{.Name}} {{.State}}' worker
+99
View File
@@ -0,0 +1,99 @@
"""Общее для фоновых процессов lab5 (relay, worker, ops): конфигурация, БД, брокер.
API (server.py) брокер не использует вовсе: он только пишет outbox в PostgreSQL.
Поэтому недоступность RabbitMQ не влияет на приём файлов — задания копятся в outbox.
"""
import logging
import os
import socket
import sys
import time
import uuid
import pika
from psycopg.conninfo import make_conninfo
# Lab6: логирование (JSON stdout + OTLP) настраивает telemetry.setup() в main() каждого процесса.
logging.getLogger("pika").setLevel(logging.WARNING)
# Топология брокера (объявляется декларативно в secrets/rabbitmq_definitions.json,
# приложения её не создают — у их пользователей нет права configure).
EXCHANGE = "attachments"
ROUTING_KEY = "attachment.process.v1"
QUEUE = "attachments.process.v1"
DLQ = "attachments.dlq"
HOSTNAME = socket.gethostname()
# Идентификатор процесса для lease_owner: hostname контейнера + случайный boot id.
BOOT_ID = uuid.uuid4().hex[:8]
OWNER = "%s:%s" % (HOSTNAME, BOOT_ID)
def env_int(name, default):
return int(os.environ.get(name, str(default)))
def env_float(name, default):
return float(os.environ.get(name, str(default)))
def secret(name):
"""Значение из NAME_FILE (Docker secret) либо из NAME."""
path = os.environ.get(name + "_FILE")
if path:
with open(path, encoding="utf-8") as f:
return f.read().strip()
return os.environ.get(name, "")
def database_conninfo():
options = "-c statement_timeout=%d" % env_int("DB_STATEMENT_TIMEOUT_MS", 5000)
url = secret("DATABASE_URL")
if url:
return make_conninfo(url, connect_timeout=3, options=options)
return make_conninfo(
host=os.environ.get("POSTGRES_HOST", "localhost"),
port=os.environ.get("POSTGRES_PORT", "5432"),
dbname=os.environ.get("POSTGRES_DB", "messenger"),
user=os.environ.get("POSTGRES_USER", "messenger"),
password=secret("POSTGRES_PASSWORD"),
connect_timeout=3,
options=options,
)
def broker_parameters():
"""amqp URL из BROKER_URL_FILE: у relay, worker и ops — разные пользователи RabbitMQ."""
params = pika.URLParameters(secret("BROKER_URL"))
# heartbeat: брокер закроет соединение мёртвого/замороженного клиента и вернёт его unacked
# сообщения в очередь (в т.ч. выданные заранее по prefetch). 10 с: эксперимент
# lease_takeover показал, что при 20 с такое сообщение висело ~35 с. Worker обрабатывает
# задание в отдельном потоке и продолжает обслуживать heartbeat (process_data_events),
# поэтому долгая обработка соединение не рвёт.
params.heartbeat = env_int("BROKER_HEARTBEAT_SECONDS", 10)
params.blocked_connection_timeout = 30
params.socket_timeout = 5
params.connection_attempts = 1
params.client_properties = {"connection_name": "%s-%s" % (os.environ.get("SERVICE_NAME", "app"), HOSTNAME)}
return params
def connect_broker(log, stop=None):
"""Подключение с повторами и паузой до 5 с; stop — threading.Event для выхода."""
delay = 0.5
while True:
try:
return pika.BlockingConnection(broker_parameters())
except Exception as exc:
log.warning("broker unavailable (%s), retry in %.1fs", type(exc).__name__, delay,
extra={"event": "broker.unavailable", "error.type": type(exc).__name__})
if stop is not None and stop.wait(delay):
return None
if stop is None:
time.sleep(delay)
delay = min(5.0, delay * 2)
def touch(path):
with open(path, "w") as f:
f.write(str(time.time()))
+282
View File
@@ -0,0 +1,282 @@
"""Проверка загружаемых изображений по СОДЕРЖИМОМУ, с ограниченной памятью.
Заголовок Content-Type клиента — только заявление: настоящий формат определяется
по сигнатуре и структуре файла. Лимит пикселей проверяется по заголовку (PNG IHDR,
JPEG SOF) ДО распаковки, поэтому «бомба» 100 000×100 000 не декодируется вовсе.
PNG проверяется собственным потоковым валидатором (стандартная библиотека):
структура и CRC каждого chunk, допустимые IHDR, IDAT распаковывается zlib кусками
по 1 MiB без сохранения результата; объём распакованных данных должен ТОЧНО совпасть
с размером, который следует из IHDR (больше — бомба/мусор, меньше — обрезанный файл).
JPEG: разбор маркеров до SOF (размеры), затем пробное декодирование Pillow в режиме
draft (масштаб 1/8) в ОТДЕЛЬНОМ процессе с лимитами (src/jpeg_probe.py). Для baseline JPEG
draft экономит память, но progressive JPEG держит DCT-коэффициенты всего кадра: до ~250 MiB
на 40 Мпикс (аудит F02) — поэтому не в процессе API.
PNG (аудит F05): кроме CRC/zlib/объёма проверяется байт фильтра КАЖДОЙ строки (0..4),
включая проходы Adam7, а также PLTE (кратна 3, <= 256 записей) и пустой IEND.
"""
import os
import subprocess
import sys
import struct
import zlib
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
JPEG_SOI = b"\xff\xd8\xff"
READ_CHUNK = 64 * 1024
INFLATE_STEP = 1024 * 1024
# Допустимые глубины цвета по типу цвета PNG и число каналов.
_PNG_DEPTHS = {0: {1, 2, 4, 8, 16}, 2: {8, 16}, 3: {1, 2, 4, 8}, 4: {8, 16}, 6: {8, 16}}
_PNG_CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}
# Adam7: (x0, y0, dx, dy)
_ADAM7 = ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2))
_JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
class InvalidImage(Exception):
"""Файл не является корректным PNG/JPEG заявленного типа -> 415."""
class TooManyPixels(Exception):
"""Декодированный размер превышает лимит -> 413."""
class ResourceLimit(Exception):
"""Проверка не уложилась в лимиты памяти/времени -> 413 (вход слишком тяжёлый)."""
JPEG_PROBE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "jpeg_probe.py")
JPEG_PROBE_TIMEOUT_SECONDS = float(os.environ.get("JPEG_PROBE_TIMEOUT_SECONDS", "15"))
def sniff(head):
"""Тип по сигнатуре первых байтов: 'image/png', 'image/jpeg' или None."""
if head.startswith(PNG_SIGNATURE):
return "image/png"
if head.startswith(JPEG_SOI):
return "image/jpeg"
return None
def png_header_pixels(head):
"""Ранняя проверка по первым 33 байтам (сигнатура + IHDR): (w, h) или None."""
if len(head) < 33 or not head.startswith(PNG_SIGNATURE) or head[12:16] != b"IHDR":
return None
return struct.unpack(">II", head[16:24])
def _read_exact(f, n):
data = f.read(n)
if len(data) != n:
raise InvalidImage("truncated")
return data
def _png_passes(w, h, bits_per_pixel, interlace):
"""[(строк, байт в строке вместе с байтом фильтра)] для каждого непустого прохода."""
def row(pw):
return 1 + (pw * bits_per_pixel + 7) // 8
if interlace == 0:
return [(h, row(w))]
out = []
for x0, y0, dx, dy in _ADAM7:
pw = (w - x0 + dx - 1) // dx if w > x0 else 0
ph = (h - y0 + dy - 1) // dy if h > y0 else 0
if pw and ph:
out.append((ph, row(pw)))
return out
class _FilterCheck:
"""Байт фильтра в начале каждой строки распакованных данных PNG должен быть 0..4.
Проверка срезами bytes[first::rowbytes] — скорость C, без цикла Python по строкам
(иначе PNG 1x40 000 000 стал бы атакой на CPU)."""
def __init__(self, passes):
self.passes = passes
self.index = 0
self.offset = 0 # байт уже пройдено в текущем проходе
def feed(self, out):
i, n = 0, len(out)
while i < n:
if self.index >= len(self.passes):
raise InvalidImage("too much pixel data")
rows, rb = self.passes[self.index]
total = rows * rb
take = min(n - i, total - self.offset)
first = (-self.offset) % rb
if first < take and max(out[i + first:i + take:rb]) > 4:
raise InvalidImage("bad filter type")
i += take
self.offset += take
if self.offset == total:
self.index += 1
self.offset = 0
def _png_expected_bytes(w, h, bits_per_pixel, interlace):
def raw(pw, ph):
return ph * (1 + (pw * bits_per_pixel + 7) // 8) if pw and ph else 0
if interlace == 0:
return raw(w, h)
total = 0
for x0, y0, dx, dy in _ADAM7:
pw = (w - x0 + dx - 1) // dx if w > x0 else 0
ph = (h - y0 + dy - 1) // dy if h > y0 else 0
total += raw(pw, ph)
return total
def validate_png(f, size, max_pixels):
if _read_exact(f, 8) != PNG_SIGNATURE:
raise InvalidImage("signature")
pos = 8
width = height = None
expected = produced = 0
inflater = None
seen_plte = idat_done = False
color_type = None
last_type = None
while True:
if pos + 12 > size:
raise InvalidImage("truncated")
length, ctype = struct.unpack(">I4s", _read_exact(f, 8))
pos += 8
if length > 0x7FFFFFFF or pos + length + 4 > size:
raise InvalidImage("chunk length")
if not ctype.isalpha():
raise InvalidImage("chunk type")
if width is None and ctype != b"IHDR":
raise InvalidImage("IHDR must be first")
crc = zlib.crc32(ctype)
if ctype == b"IDAT":
if idat_done or (color_type == 3 and not seen_plte):
raise InvalidImage("IDAT order")
remaining = length
while remaining:
piece = _read_exact(f, min(READ_CHUNK, remaining))
remaining -= len(piece)
crc = zlib.crc32(piece, crc)
buf = piece
while buf:
if inflater.eof:
raise InvalidImage("data after zlib stream")
try:
out = inflater.decompress(buf, INFLATE_STEP)
except zlib.error:
raise InvalidImage("zlib")
produced += len(out)
if produced > expected:
raise InvalidImage("too much pixel data") # бомба/мусор
filters.feed(out)
buf = inflater.unconsumed_tail
else:
if last_type == b"IDAT":
idat_done = True
data = _read_exact(f, length)
crc = zlib.crc32(data, crc)
if ctype == b"IHDR":
if width is not None or length != 13:
raise InvalidImage("IHDR")
width, height, depth, color_type, comp, filt, interlace = struct.unpack(">IIBBBBB", data)
if not (1 <= width <= 0x7FFFFFFF and 1 <= height <= 0x7FFFFFFF):
raise InvalidImage("dimensions")
if width * height > max_pixels:
raise TooManyPixels()
if depth not in _PNG_DEPTHS.get(color_type, ()) or comp != 0 or filt != 0 or interlace not in (0, 1):
raise InvalidImage("IHDR values")
expected = _png_expected_bytes(width, height, _PNG_CHANNELS[color_type] * depth, interlace)
filters = _FilterCheck(_png_passes(width, height, _PNG_CHANNELS[color_type] * depth, interlace))
inflater = zlib.decompressobj()
elif ctype == b"PLTE":
# PLTE: кратна 3, 1..256 записей, только одна, не для серых типов, до IDAT.
if seen_plte or length == 0 or length % 3 or length > 768 or color_type in (0, 4) \
or last_type == b"IDAT" or idat_done:
raise InvalidImage("PLTE")
seen_plte = True
elif ctype == b"IEND":
if length != 0:
raise InvalidImage("IEND")
elif ctype[0:1].isupper():
raise InvalidImage("unknown critical chunk") # декодер обязан его понимать
if struct.unpack(">I", _read_exact(f, 4))[0] != crc & 0xFFFFFFFF:
raise InvalidImage("crc")
pos += length + 4
last_type = ctype
if ctype == b"IEND":
break
if inflater is None or not inflater.eof or produced != expected:
raise InvalidImage("incomplete pixel data")
if pos != size:
raise InvalidImage("trailing data") # полиглоты PNG+что-то ещё не принимаем
return width, height
def jpeg_dimensions(f, size):
"""Размеры из первого SOF без декодирования. Ограничено размером файла."""
if _read_exact(f, 2) != b"\xff\xd8":
raise InvalidImage("signature")
pos = 2
while pos < size:
b = _read_exact(f, 1)
pos += 1
if b != b"\xff":
raise InvalidImage("marker")
marker = 0xFF
while marker == 0xFF:
marker = _read_exact(f, 1)[0]
pos += 1
if marker == 0x01 or 0xD0 <= marker <= 0xD7:
continue
if marker in (0xD8, 0xD9, 0xDA):
raise InvalidImage("no SOF before scan")
seg_len = struct.unpack(">H", _read_exact(f, 2))[0]
if seg_len < 2 or pos + seg_len > size:
raise InvalidImage("segment length")
if marker in _JPEG_SOF:
if seg_len < 8:
raise InvalidImage("SOF")
_precision, height, width = struct.unpack(">BHH", _read_exact(f, 5))
if width == 0 or height == 0:
raise InvalidImage("dimensions") # DNL-высота не поддерживается
return width, height
f.seek(seg_len - 2, 1)
pos += seg_len
raise InvalidImage("no SOF")
def validate_jpeg(f, size, max_pixels):
width, height = jpeg_dimensions(f, size)
if width * height > max_pixels:
raise TooManyPixels()
if not hasattr(f, "fileno"):
raise InvalidImage("probe needs a real file")
f.flush()
f.seek(0)
try:
# stdin подпроцесса — тот же временный файл (анонимный, O_TMPFILE): байты не копируются.
proc = subprocess.run([sys.executable, JPEG_PROBE, str(max_pixels), str(width), str(height)],
stdin=f, capture_output=True, timeout=JPEG_PROBE_TIMEOUT_SECONDS, check=False)
except subprocess.TimeoutExpired:
raise ResourceLimit("timeout")
finally:
f.seek(0)
if proc.returncode == 0:
return width, height
if proc.returncode == 3:
raise InvalidImage("decode")
raise ResourceLimit("probe exit %d" % proc.returncode) # 5 или убит сигналом (RLIMIT/OOM)
def validate(f, size, content_type, max_pixels):
"""(width, height) или InvalidImage/TooManyPixels. f — seekable файл, позиция 0."""
f.seek(0)
if content_type == "image/png":
return validate_png(f, size, max_pixels)
if content_type == "image/jpeg":
return validate_jpeg(f, size, max_pixels)
raise InvalidImage("type")
+242
View File
@@ -0,0 +1,242 @@
#!/usr/bin/env python3
"""Сверка PostgreSQL <-> S3 и очистка (compose-сервис `janitor`). Lab5.
Prefix-ы bucket:
staging/<uuid> принятые оригиналы до публикации результата (attachments.staging_key);
attachments/<id>/v<ver>/<name> конечные объекты: original и варианты;
originals/<uuid> оригиналы lab4 (после миграции 004 — staging-объекты backfill-заданий);
health/, bootstrap/ служебные, не трогаются.
За один проход (под pg_try_advisory_lock):
1. abandoned: pending-строки старше grace (API упал до постановки в очередь, 202 не было)
-> удалить staging-объект, затем строку;
2. staging ready: у ready-вложения остался staging (worker не смог удалить после COMMIT)
-> удалить объект, staging_key = NULL;
3. staging failed: failed дольше STAGING_RETENTION_SECONDS -> удалить staging (replay после
этого невозможен: ops replay ответит refused_staging_expired). Для 2 и 3: под блокировкой
jobs+attachments условие проверяется заново, staging_key снимается и COMMIT, потом DELETE
в S3 — гонка с replay исключена (аудит F01);
4. orphan: объекты staging/, originals/, attachments/ старше grace, на которые не ссылается
ни одна строка (staging_key, object_key ready-вложения, attachment_variants), и вложение
не queued/processing -> удалить;
5. missing: ready без объекта оригинала или варианта -> ТОЛЬКО отчёт.
Текущую работу (queued/processing) janitor не удаляет никогда: её staging нужен worker.
Grace (ATTACHMENT_GRACE_SECONDS, 3600 с) многократно больше UPLOAD_TIMEOUT_SECONDS и
JOB_TIMEOUT_SECONDS, поэтому идущая загрузка/обработка не считается брошенной.
python src/janitor.py --once --dry-run | --once | --interval 300
"""
import argparse
import datetime as dt
import json
import logging
import os
import re
import sys
import time
import jobs
import telemetry
from server import OBJ, STORE
log = logging.getLogger("messenger.janitor")
JANITOR_LOCK_ID = 727002
PREFIXES = ("staging/", "originals/", "attachments/")
HEARTBEAT = "/tmp/janitor.heartbeat"
STAGING_RETENTION = int(os.environ.get("STAGING_RETENTION_SECONDS", "86400"))
# Только для теста гонки (student-tests/janitor_replay_race.py): пауза между выборкой
# кандидатов и их захватом — воспроизводит чередование «выбрал -> replay -> удаляю». Обычно 0.
PAUSE_AFTER_SELECT = float(os.environ.get("JANITOR_PAUSE_AFTER_SELECT_SECONDS", "0"))
_FINAL_RE = re.compile(r"^attachments/([0-9a-f-]{36})/")
def heartbeat():
with open(HEARTBEAT, "w") as f:
f.write(str(time.time()))
def _delete(report, key, dry_run):
if dry_run:
return True
try:
OBJ.delete(key)
report["deleted_objects"] += 1
return True
except Exception as exc:
report["errors"] += 1
log.warning("object not deleted (%s)", type(exc).__name__)
return False
def run_once(grace_seconds, dry_run, staging_retention=STAGING_RETENTION):
started = time.monotonic()
report = {"dry_run": dry_run, "grace_seconds": grace_seconds, "staging_retention_seconds": staging_retention,
"abandoned_pending": 0, "staging_ready_cleaned": 0, "staging_failed_expired": 0,
"staging_skipped_changed": 0,
"orphan_objects": 0, "missing_objects": 0, "deleted_objects": 0, "deleted_rows": 0, "errors": 0}
with STORE.pool.connection() as conn:
conn.autocommit = True
if not conn.execute("SELECT pg_try_advisory_lock(%s) AS ok", (JANITOR_LOCK_ID,)).fetchone()["ok"]:
report["skipped"] = "another janitor is running"
return report
try:
now_db = conn.execute("SELECT now() AS t").fetchone()["t"]
cutoff = now_db - dt.timedelta(seconds=grace_seconds)
report["rows_by_status"] = {r["status"]: r["n"] for r in conn.execute(
"SELECT status, count(*) AS n FROM attachments GROUP BY status")}
report["jobs_by_status"] = {r["status"]: r["n"] for r in conn.execute(
"SELECT status, count(*) AS n FROM jobs GROUP BY status")}
report["outbox_unpublished"] = conn.execute(
"SELECT count(*) AS n FROM outbox WHERE published_at IS NULL").fetchone()["n"]
# 1. брошенные pending
abandoned = conn.execute(
"""SELECT id, staging_key FROM attachments
WHERE status = 'pending' AND created_at < %s ORDER BY created_at""", (cutoff,)).fetchall()
report["abandoned_pending"] = len(abandoned)
report["abandoned_ids"] = [str(r["id"]) for r in abandoned[:20]]
for row in abandoned:
if dry_run:
continue
if row["staging_key"] and not _delete(report, row["staging_key"], dry_run):
continue
report["deleted_rows"] += conn.execute(
"DELETE FROM attachments WHERE id = %s AND status = 'pending'", (row["id"],)).rowcount
# 2/3. staging, который больше не нужен
stale = conn.execute(
"""SELECT a.id, a.staging_key, a.status, j.id AS job_id FROM attachments a
LEFT JOIN jobs j ON j.attachment_id = a.id AND j.pipeline_version = a.pipeline_version
WHERE a.staging_key IS NOT NULL AND (a.status = 'ready'
OR (a.status = 'failed' AND a.updated_at < now() - make_interval(secs => %s)))""",
(staging_retention,)).fetchall()
report["staging_candidates"] = [str(r["id"]) for r in stale][:20]
if stale and PAUSE_AFTER_SELECT > 0:
time.sleep(PAUSE_AFTER_SELECT)
for row in stale:
if dry_run:
report["staging_ready_cleaned" if row["status"] == "ready" else "staging_failed_expired"] += 1
continue
# Аудит F01: выборка выше — без блокировок; между ней и удалением оператор мог
# выполнить replay (failed -> queued), и удаление уничтожило бы исходник принятой
# работы. Поэтому под блокировкой строк (порядок как у replay и worker:
# сначала jobs, потом attachments) условие проверяется ЗАНОВО, ссылка
# staging_key снимается и фиксируется, и только ПОСЛЕ COMMIT удаляется объект.
# Replay после этого увидит staging_key IS NULL и откажет (refused_staging_expired);
# replay, успевший раньше, оставит queued — и janitor пропустит строку.
with conn.transaction():
conn.execute("SELECT 1 FROM jobs WHERE attachment_id = %s FOR UPDATE", (row["id"],))
claimed = conn.execute(
"""UPDATE attachments SET staging_key = NULL
WHERE id = %s AND staging_key = %s AND (status = 'ready'
OR (status = 'failed' AND updated_at < now() - make_interval(secs => %s)))
RETURNING status""",
(row["id"], row["staging_key"], staging_retention)).fetchone()
if claimed is None:
report["staging_skipped_changed"] += 1 # состояние изменилось (replay и т. п.)
continue
if row["job_id"]:
jobs.add_event(conn, row["job_id"], "staging_released", None, "janitor",
{"status": claimed["status"]})
report["staging_ready_cleaned" if claimed["status"] == "ready" else "staging_failed_expired"] += 1
# Ссылки уже нет: если удаление не удастся, объект станет сиротой и будет удалён
# обходом bucket после grace — исходник «живой» работы так не потеряется.
_delete(report, row["staging_key"], dry_run)
# 4/5. обход bucket. Момент начала — по часам БД: ready раньше этого момента обязан
# иметь все объекты в листинге (объекты пишутся ДО COMMIT ready).
list_started = conn.execute("SELECT now() AS t").fetchone()["t"]
listed = {}
for prefix in PREFIXES:
for obj in OBJ.client.list_objects(OBJ.bucket, prefix=prefix, recursive=True):
listed[obj.object_name] = obj.last_modified
report["objects_total"] = len(listed)
report["objects_by_prefix"] = {p: sum(1 for k in listed if k.startswith(p)) for p in PREFIXES}
known = set()
busy = set() # вложения с текущей работой: их объекты не трогаем
keys = list(listed)
for i in range(0, len(keys), 1000):
batch = keys[i:i + 1000]
for r in conn.execute(
"""SELECT staging_key AS k FROM attachments WHERE staging_key = ANY(%(b)s)
UNION SELECT object_key FROM attachments WHERE status = 'ready' AND object_key = ANY(%(b)s)
UNION SELECT object_key FROM attachment_variants WHERE object_key = ANY(%(b)s)""",
{"b": batch}):
known.add(r["k"])
ids = {m.group(1) for k in keys for m in [_FINAL_RE.match(k)] if m}
if ids:
for r in conn.execute(
"SELECT id FROM attachments WHERE id = ANY(%s::uuid[]) AND status IN ('pending','queued','processing')",
(list(ids),)):
busy.add(str(r["id"]))
orphans = []
for k, mtime in listed.items():
if k in known or mtime is None or mtime >= cutoff:
continue
m = _FINAL_RE.match(k)
if m and m.group(1) in busy:
continue
orphans.append(k)
report["orphan_objects"] = len(orphans)
report["orphan_keys_sample"] = sorted(orphans)[:5]
for key in orphans:
_delete(report, key, dry_run)
missing = []
for r in conn.execute(
"""SELECT a.id, a.object_key AS k FROM attachments a WHERE a.status = 'ready' AND a.updated_at < %s
UNION ALL
SELECT v.attachment_id, v.object_key FROM attachment_variants v
JOIN attachments a ON a.id = v.attachment_id
WHERE a.status = 'ready' AND a.updated_at < %s""", (list_started, list_started)):
if r["k"] not in listed:
missing.append(str(r["id"]))
report["missing_objects"] = len(missing)
report["missing_ids_sample"] = sorted(set(missing))[:5]
if missing:
log.error("ready attachments without object: %d (manual investigation needed)", len(missing))
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (JANITOR_LOCK_ID,))
report["duration_ms"] = round((time.monotonic() - started) * 1000, 1)
return report
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--once", action="store_true")
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--grace-seconds", type=int,
default=int(os.environ.get("ATTACHMENT_GRACE_SECONDS", "3600")))
parser.add_argument("--staging-retention-seconds", type=int, default=STAGING_RETENTION)
parser.add_argument("--interval", type=int, default=int(os.environ.get("JANITOR_INTERVAL_SECONDS", "300")))
args = parser.parse_args()
if args.grace_seconds < 1:
parser.error("grace period must be positive")
if args.once:
telemetry.configure_logging(stream=sys.stderr) # stdout — JSON-отчёт для оператора
else:
telemetry.setup("messenger-janitor")
telemetry.observe_pool(STORE.pool, "janitor")
STORE.open()
try:
while True:
try:
print(json.dumps(run_once(args.grace_seconds, args.dry_run, args.staging_retention_seconds),
ensure_ascii=False), flush=True)
except Exception as exc:
log.warning("janitor pass failed (%s)", type(exc).__name__,
extra={"event": "janitor.failed", "error.type": type(exc).__name__})
if args.once:
return 1
if args.once:
return 0
wake = time.monotonic() + args.interval
while time.monotonic() < wake:
heartbeat()
time.sleep(min(30, max(0.1, wake - time.monotonic())))
finally:
STORE.close()
if __name__ == "__main__":
sys.exit(main())
+451
View File
@@ -0,0 +1,451 @@
"""Задания обработки вложений: схема сообщения, переходы состояний, retry, lease, replay.
Используется API (постановка в очередь), worker, relay (reaper) и ops-CLI. Все переходы —
SQL-транзакции над строкой jobs под FOR UPDATE, поэтому решение «что делать с сообщением»
принимается по устойчивому состоянию в PostgreSQL, а не по факту доставки.
Сообщение брокера (contracts/jobs.schema.json) — только ссылка: job_id, attachment_id,
pipeline_version, attempt. Bytes, credentials, URL и ключи S3 в сообщение не попадают:
worker берёт доверенные storage metadata из БД.
Переходы (contracts/attachment-states.md):
enqueue нет -> queued API, одна транзакция с outbox
claim queued -> processing worker: attempt+1, lease_owner/token/until
heartbeat processing (продление) worker, только со своим lease_token
complete processing -> ready worker, только со своим lease_token (fencing)
retry processing -> queued временная ошибка, backoff + jitter, outbox с available_at
fail processing -> failed постоянная ошибка или исчерпаны попытки
lease expired processing -> queued reaper (relay), если аренду никто не продлил
replay failed -> queued оператор (ops.py), audit, ready не трогается
Lab6 (W3C Trace Context через очередь): add_outbox внутри активной трассы создаёт PRODUCER span
«attachment.process.v1 create» и пишет его traceparent/tracestate в payload outbox (поля
разрешены contracts/jobs.schema.json). Relay публикует сообщение в span-е «send» (child), worker
обрабатывает в CONSUMER span-е «process» (child от send). Retry из worker пишет новый outbox в
контексте текущей попытки -> следующая попытка в той же трассе. Фоновые переходы без трассы
(reaper, redrive, replay оператора) берут traceparent последнего outbox этого job — цепочка
upload -> все попытки остаётся одной трассой.
"""
import datetime as dt
import json
import random
import re
import uuid
import telemetry
from telemetry import SpanKind, db_operation
SCHEMA_VERSION = 1
# Аудит F11: публикация результата и выборка вариантов согласованы только для v1.
SUPPORTED_PIPELINE_VERSIONS = (1,)
JOB_TYPE = "attachment.process.v1"
VARIANT_NAMES = ("thumbnail", "crop", "optimized")
# Постоянные ошибки: повтор не поможет (тот же вход даст тот же результат).
PERMANENT_ERRORS = {"invalid_image", "image_too_large", "staging_corrupted", "staging_missing",
"resource_limit"}
_UUID_FIELDS = ("job_id", "attachment_id")
_ALLOWED = {"schema_version", "job_id", "type", "attachment_id", "pipeline_version", "attempt",
"created_at", "traceparent", "tracestate"}
class InvalidMessage(Exception):
"""Сообщение не соответствует jobs.schema.json -> reject в DLQ."""
def utc_now_text():
return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def make_payload(job_id, attachment_id, pipeline_version, attempt, created_at=None, trace_fields=None):
payload = {
"schema_version": SCHEMA_VERSION,
"job_id": str(job_id),
"type": JOB_TYPE,
"attachment_id": str(attachment_id),
"pipeline_version": int(pipeline_version),
"attempt": int(attempt),
"created_at": created_at or utc_now_text(),
}
for key in ("traceparent", "tracestate"):
value = (trace_fields or {}).get(key)
if key == "traceparent" and value and _TRACEPARENT_RE.match(value):
payload[key] = value
elif key == "tracestate" and value and len(value) <= 512:
payload[key] = value
return payload
_UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
# RFC 3339 date-time: обязательно время и зона (Z или ±hh:mm).
_DATETIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$")
_TRACEPARENT_RE = re.compile(r"^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$")
def _strict_int(v):
# В Python True == 1 и isinstance(True, int): bool исключается явно (аудит F12).
# По JSON Schema 2020-12 integer — число с нулевой дробной частью: 1.0 тоже допустимо.
return type(v) is int or (type(v) is float and v.is_integer())
def parse_message(body):
"""bytes -> dict строго по jobs.schema.json (без внешних библиотек). Иначе InvalidMessage.
Аудит F12: раньше проходили schema_version=true, created_at без времени, traceparent-число
и tracestate длиннее 512. Соответствие сверяется с jsonschema тестом job_schema_check.py."""
try:
msg = json.loads(body.decode("utf-8"))
except (UnicodeDecodeError, ValueError):
raise InvalidMessage("not json")
if not isinstance(msg, dict):
raise InvalidMessage("not object")
if set(msg) - _ALLOWED:
raise InvalidMessage("extra fields")
for field in ("schema_version", "job_id", "type", "attachment_id", "pipeline_version", "attempt", "created_at"):
if field not in msg:
raise InvalidMessage("missing " + field)
if not _strict_int(msg["schema_version"]) or msg["schema_version"] != SCHEMA_VERSION:
raise InvalidMessage("unsupported schema_version")
if msg["type"] != JOB_TYPE:
raise InvalidMessage("unsupported type")
for field in _UUID_FIELDS:
if not isinstance(msg[field], str) or not _UUID_RE.match(msg[field]):
raise InvalidMessage("bad " + field)
for field in ("pipeline_version", "attempt"):
if not _strict_int(msg[field]) or msg[field] < 1:
raise InvalidMessage("bad " + field)
created = msg["created_at"]
if not isinstance(created, str) or not _DATETIME_RE.match(created):
raise InvalidMessage("bad created_at")
try:
dt.datetime.fromisoformat(created.upper().replace("Z", "+00:00"))
except ValueError:
raise InvalidMessage("bad created_at")
if "traceparent" in msg and (not isinstance(msg["traceparent"], str) or not _TRACEPARENT_RE.match(msg["traceparent"])):
raise InvalidMessage("bad traceparent")
if "tracestate" in msg and (not isinstance(msg["tracestate"], str) or len(msg["tracestate"]) > 512):
raise InvalidMessage("bad tracestate")
for field in ("schema_version", "pipeline_version", "attempt"):
msg[field] = int(msg[field]) # 1.0 -> 1
return msg
def backoff_seconds(attempt, base, cap, rng=random):
"""Экспоненциальный backoff с «equal jitter»: d = min(cap, base*2^(attempt-1)),
задержка равномерно в [d/2, d]. Половина гарантирует паузу (не долбим упавший S3),
случайная половина разносит повторы многих заданий во времени (нет «стада»)."""
d = min(float(cap), float(base) * (2 ** max(0, attempt - 1)))
return d / 2 + rng.uniform(0, d / 2)
def add_event(conn, job_id, event, attempt=None, actor=None, detail=None):
conn.execute(
"INSERT INTO job_events (job_id, event, attempt, actor, detail) VALUES (%s, %s, %s, %s, %s)",
(job_id, event, attempt, actor, json.dumps(detail, ensure_ascii=False) if detail is not None else None))
def _previous_trace(conn, job_id):
row = conn.execute(
"""SELECT payload->>'traceparent' AS traceparent, payload->>'tracestate' AS tracestate FROM outbox
WHERE job_id = %s AND payload ? 'traceparent' ORDER BY id DESC LIMIT 1""", (job_id,)).fetchone()
if row is None:
return {}
row = row if isinstance(row, dict) else {"traceparent": row[0], "tracestate": row[1]}
return {k: v for k, v in row.items() if v}
def add_outbox(conn, job_id, attachment_id, pipeline_version, attempt, delay_seconds=0.0):
if telemetry.has_active_span():
attrs = {"messaging.system": "rabbitmq", "messaging.operation.type": "create",
"messaging.operation.name": "create", "messaging.destination.name": "attachments",
"messenger.job.id": str(job_id), "messenger.attachment.id": str(attachment_id),
"messenger.job.attempt": int(attempt), "messenger.outbox.delay_s": round(float(delay_seconds), 3)}
with telemetry.child_span(JOB_TYPE + " create", SpanKind.PRODUCER, attrs):
return _insert_outbox(conn, job_id, attachment_id, pipeline_version, attempt, delay_seconds,
telemetry.inject_dict())
return _insert_outbox(conn, job_id, attachment_id, pipeline_version, attempt, delay_seconds,
_previous_trace(conn, job_id))
def _insert_outbox(conn, job_id, attachment_id, pipeline_version, attempt, delay_seconds, trace_fields):
payload = make_payload(job_id, attachment_id, pipeline_version, attempt, trace_fields=trace_fields)
conn.execute(
"""INSERT INTO outbox (job_id, payload, available_at)
VALUES (%s, %s, now() + make_interval(secs => %s))""",
(job_id, json.dumps(payload), delay_seconds))
return payload
# ---------------------------------------------------------------------------
# API: постановка в очередь
# ---------------------------------------------------------------------------
@db_operation("jobs.enqueue")
def enqueue(conn, attachment_id, pipeline_version, max_attempts):
"""В ТЕКУЩЕЙ транзакции: pending -> queued, jobs, outbox, событие. job_id или None."""
row = conn.execute(
"""UPDATE attachments SET status = 'queued', updated_at = now()
WHERE id = %s AND status = 'pending' RETURNING id""", (attachment_id,)).fetchone()
if row is None:
return None
job_id = uuid.uuid4()
conn.execute(
"""INSERT INTO jobs (id, attachment_id, pipeline_version, status, attempt, max_attempts,
next_attempt_at, created_at, updated_at)
VALUES (%s, %s, %s, 'queued', 0, %s, now(), now(), now())""",
(job_id, attachment_id, pipeline_version, max_attempts))
add_event(conn, job_id, "enqueued", 1, "api")
add_outbox(conn, job_id, attachment_id, pipeline_version, 1)
return job_id
# ---------------------------------------------------------------------------
# Worker
# ---------------------------------------------------------------------------
JOB_COLUMNS = """j.id AS job_id, j.attachment_id, j.pipeline_version, j.status AS job_status, j.attempt,
j.max_attempts, j.next_attempt_at, j.error_code, j.lease_owner, j.lease_token, j.lease_until, j.replay_count,
j.lease_until > now() AS lease_alive, j.next_attempt_at > now() + interval '1 second' AS too_early,
GREATEST(0, EXTRACT(EPOCH FROM now() - j.next_attempt_at))::float8 AS eligible_wait_s,
EXTRACT(EPOCH FROM now() - j.created_at)::float8 AS job_age_s,
a.status AS attachment_status, a.content_type, a.size_bytes, a.sha256, a.width, a.height,
a.object_key, a.staging_key, a.filename, a.pipeline_version AS current_pipeline_version"""
def load_job(conn, job_id, lock=False):
return conn.execute(
"SELECT " + JOB_COLUMNS + " FROM jobs j JOIN attachments a ON a.id = j.attachment_id WHERE j.id = %s"
+ (" FOR UPDATE OF j" if lock else ""), (job_id,)).fetchone()
def _owner_host(owner):
return (owner or "").split(":", 1)[0]
@db_operation("jobs.claim")
def claim(conn, msg, owner, lease_seconds):
"""Решение по сообщению. Возвращает (action, job):
'process' — аренда взята (job со свежим lease_token), можно работать;
'ack' — ничего делать не нужно (уже ready/failed, занято живой арендой, ранний дубль);
'reject' — сообщение не соответствует заданию (в DLQ, разбирает оператор).
Вызывается в транзакции; при 'process' коммит фиксирует processing ДО начала работы."""
job = load_job(conn, msg["job_id"], lock=True)
if job is None:
return "reject", "unknown_job"
if str(job["attachment_id"]) != msg["attachment_id"] or job["pipeline_version"] != msg["pipeline_version"]:
return "reject", "job_mismatch"
status = job["job_status"]
if status == "ready":
add_event(conn, job["job_id"], "duplicate_ignored", msg["attempt"], owner, {"status": "ready"})
return "ack", job
if status == "failed":
add_event(conn, job["job_id"], "duplicate_ignored", msg["attempt"], owner, {"status": "failed"})
return "ack", job
if job["current_pipeline_version"] > job["pipeline_version"]:
# Устаревшая job после новой версии pipeline: результат не публикуем.
conn.execute("""UPDATE jobs SET status = 'failed', error_code = 'superseded', lease_owner = NULL,
lease_token = NULL, lease_until = NULL, updated_at = now(), finished_at = now()
WHERE id = %s""", (job["job_id"],))
add_event(conn, job["job_id"], "superseded", msg["attempt"], owner)
return "ack", job
if status == "processing" and job["lease_alive"]:
prev = job["lease_owner"] or ""
# Тот же контейнер (hostname), но другой процесс (boot id): прежняя инкарнация этого
# worker умерла (crash/restart) — два процесса одного контейнера одновременно не живут.
if not (_owner_host(prev) == _owner_host(owner) and prev != owner):
add_event(conn, job["job_id"], "busy_ignored", msg["attempt"], owner, {"lease_owner": prev})
return "ack", job
add_event(conn, job["job_id"], "lease_taken_over", job["attempt"], owner,
{"previous_owner": prev, "reason": "previous process of this container died"})
elif status == "processing":
add_event(conn, job["job_id"], "lease_taken_over", job["attempt"], owner,
{"previous_owner": job["lease_owner"], "reason": "lease expired"})
elif job["too_early"]:
# queued, но время следующей попытки ещё не пришло: это старый дубль, а запланированное
# сообщение relay опубликует само (outbox.available_at).
add_event(conn, job["job_id"], "early_duplicate_ignored", msg["attempt"], owner)
return "ack", job
if job["attempt"] >= job["max_attempts"]:
_finish_failed(conn, job, "retry_exhausted", owner, "attempts exhausted before claim")
return "ack", job
token = uuid.uuid4()
conn.execute(
"""UPDATE jobs SET status = 'processing', attempt = attempt + 1, lease_owner = %s, lease_token = %s,
lease_until = now() + make_interval(secs => %s), updated_at = now()
WHERE id = %s""", (owner, token, lease_seconds, job["job_id"]))
conn.execute("UPDATE attachments SET status = 'processing', updated_at = now() WHERE id = %s",
(job["attachment_id"],))
job = dict(job, attempt=job["attempt"] + 1, lease_token=token, job_status="processing")
add_event(conn, job["job_id"], "claimed", job["attempt"], owner,
{"redelivered_message_attempt": msg["attempt"]})
return "process", job
@db_operation("jobs.heartbeat")
def heartbeat(conn, job_id, token, lease_seconds):
"""Продлить аренду. False — аренда потеряна (reaper/другой worker), работу надо бросить."""
cur = conn.execute(
"""UPDATE jobs SET lease_until = now() + make_interval(secs => %s)
WHERE id = %s AND lease_token = %s AND status = 'processing'""", (lease_seconds, job_id, token))
return cur.rowcount == 1
@db_operation("jobs.complete")
def complete(conn, job, variants, owner):
"""processing -> ready атомарно с метаданными вариантов. Только владелец аренды (fencing по
lease_token): опоздавший процесс, у которого аренду забрали, ничего не перезапишет.
Возвращает 'ready' | 'already_ready' | 'lease_lost'."""
cur = conn.execute(
"""UPDATE jobs SET status = 'ready', lease_owner = NULL, lease_token = NULL, lease_until = NULL,
error_code = NULL, last_error = NULL, updated_at = now(), finished_at = now()
WHERE id = %s AND status = 'processing' AND lease_token = %s
RETURNING EXTRACT(EPOCH FROM clock_timestamp() - created_at)::float8 AS time_to_ready_s""",
(job["job_id"], job["lease_token"]))
row = cur.fetchone() if cur.rowcount == 1 else None
if row is not None:
# От durable acceptance (COMMIT enqueue в API = jobs.created_at) до публикации ready.
job["time_to_ready_s"] = row["time_to_ready_s"] if isinstance(row, dict) else row[0]
if cur.rowcount != 1:
now = load_job(conn, job["job_id"])
add_event(conn, job["job_id"], "commit_rejected_lease_lost", job["attempt"], owner,
{"current_status": now["job_status"]})
return "already_ready" if now["job_status"] == "ready" else "lease_lost"
with conn.cursor() as cur:
# Ключ эффекта — PK (attachment_id, pipeline_version, name): второго набора не будет.
cur.executemany(
"""INSERT INTO attachment_variants (attachment_id, pipeline_version, name, object_key, content_type,
size_bytes, width, height, sha256, created_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, now())
ON CONFLICT (attachment_id, pipeline_version, name) DO UPDATE SET
object_key = EXCLUDED.object_key, content_type = EXCLUDED.content_type,
size_bytes = EXCLUDED.size_bytes, width = EXCLUDED.width, height = EXCLUDED.height,
sha256 = EXCLUDED.sha256""",
[(job["attachment_id"], job["pipeline_version"], v["name"], v["key"], v["content_type"],
v["size_bytes"], v["width"], v["height"], v["sha256"]) for v in variants])
# Не откатываем более новую версию pipeline (на случай нескольких версий, трек 5).
conn.execute(
"""UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = now()
WHERE id = %s AND pipeline_version <= %s""", (job["attachment_id"], job["pipeline_version"]))
add_event(conn, job["job_id"], "ready", job["attempt"], owner,
{"variants": {v["name"]: [v["width"], v["height"]] for v in variants}})
return "ready"
def _finish_failed(conn, job, code, actor, detail):
row = conn.execute(
"""UPDATE jobs SET status = 'failed', error_code = %s, last_error = %s, lease_owner = NULL,
lease_token = NULL, lease_until = NULL, updated_at = now(), finished_at = now()
WHERE id = %s RETURNING EXTRACT(EPOCH FROM clock_timestamp() - created_at)::float8 AS t""",
(code, (detail or "")[:500], job["job_id"])).fetchone()
if row is not None and isinstance(job, dict):
job["time_to_terminal_s"] = row["t"] if isinstance(row, dict) else row[0]
conn.execute("UPDATE attachments SET status = 'failed', error_code = %s, updated_at = now() WHERE id = %s",
(code, job["attachment_id"]))
add_event(conn, job["job_id"], "failed", job["attempt"], actor, {"error_code": code, "detail": detail})
@db_operation("jobs.fail_or_retry")
def fail_or_retry(conn, job, code, detail, owner, base, cap, rng=random):
"""Ошибка попытки. Постоянная -> failed(code); временная -> queued с backoff, пока есть
попытки, иначе failed(retry_exhausted). Только владелец аренды.
Возвращает 'failed' | 'retry' | 'lease_lost' и задержку."""
cur = load_job(conn, job["job_id"], lock=True)
if cur["job_status"] != "processing" or cur["lease_token"] != job["lease_token"]:
add_event(conn, job["job_id"], "error_ignored_lease_lost", job["attempt"], owner, {"error_code": code})
return "lease_lost", None
if code in PERMANENT_ERRORS:
_finish_failed(conn, job, code, owner, detail)
return "failed", None
if cur["attempt"] >= cur["max_attempts"]:
_finish_failed(conn, job, "retry_exhausted", owner, "last error: %s %s" % (code, detail or ""))
return "failed", None
delay = backoff_seconds(cur["attempt"], base, cap, rng)
_schedule_retry(conn, cur, delay, code, detail, owner, "retry_scheduled")
return "retry", delay
def _schedule_retry(conn, job, delay, code, detail, actor, event):
conn.execute(
"""UPDATE jobs SET status = 'queued', lease_owner = NULL, lease_token = NULL, lease_until = NULL,
error_code = NULL, last_error = %s, next_attempt_at = now() + make_interval(secs => %s),
updated_at = now()
WHERE id = %s""", (("%s: %s" % (code, detail or ""))[:500], delay, job["job_id"]))
conn.execute("UPDATE attachments SET status = 'queued', updated_at = now() WHERE id = %s",
(job["attachment_id"],))
add_outbox(conn, job["job_id"], job["attachment_id"], job["pipeline_version"], job["attempt"] + 1, delay)
add_event(conn, job["job_id"], event, job["attempt"], actor,
{"error_code": code, "delay_seconds": round(delay, 3), "next_attempt": job["attempt"] + 1})
# ---------------------------------------------------------------------------
# Reaper (в relay): зависшие processing и потерянные сообщения
# ---------------------------------------------------------------------------
@db_operation("jobs.reap_expired_leases")
def reap_expired_leases(conn, base, cap, actor="reaper", limit=100):
"""processing с истёкшей арендой (worker умер/завис и не продлевал lease) -> queued
с backoff или failed(retry_exhausted). Возвращает число обработанных."""
rows = conn.execute(
"SELECT " + JOB_COLUMNS + """ FROM jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.status = 'processing' AND j.lease_until < now()
ORDER BY j.lease_until LIMIT %s FOR UPDATE OF j SKIP LOCKED""", (limit,)).fetchall()
for job in rows:
add_event(conn, job["job_id"], "lease_expired", job["attempt"], actor, {"lease_owner": job["lease_owner"]})
if job["attempt"] >= job["max_attempts"]:
_finish_failed(conn, job, "retry_exhausted", actor, "lease expired on last attempt")
else:
_schedule_retry(conn, job, backoff_seconds(job["attempt"], base, cap), "lease_expired",
"worker did not renew lease", actor, "requeued_after_lease")
return len(rows)
@db_operation("jobs.redrive_stale_queued")
def redrive_stale_queued(conn, after_seconds, actor="reaper", limit=100):
"""queued-задание, по которому давно нет ни неопубликованного outbox, ни движения:
сообщение могло потеряться в брокере (например, после потери его volume). Публикуем
ещё раз — дубль безопасен, решение примет worker по строке jobs."""
rows = conn.execute(
"""SELECT j.id, j.attachment_id, j.pipeline_version, j.attempt FROM jobs j
WHERE j.status = 'queued' AND j.updated_at < now() - make_interval(secs => %s)
AND j.next_attempt_at < now() - make_interval(secs => %s)
AND NOT EXISTS (SELECT 1 FROM outbox o WHERE o.job_id = j.id AND o.published_at IS NULL)
ORDER BY j.updated_at LIMIT %s FOR UPDATE OF j SKIP LOCKED""",
(after_seconds, after_seconds, limit)).fetchall()
for r in rows:
conn.execute("UPDATE jobs SET updated_at = now() WHERE id = %s", (r["id"],))
add_outbox(conn, r["id"], r["attachment_id"], r["pipeline_version"], r["attempt"] + 1)
add_event(conn, r["id"], "redriven", r["attempt"] + 1, actor, {"stale_after_seconds": after_seconds})
return len(rows)
# ---------------------------------------------------------------------------
# Оператор: replay
# ---------------------------------------------------------------------------
@db_operation("jobs.replay")
def replay(conn, attachment_id, actor, extra_attempts, reason, dry_run=False):
"""failed -> queued. Новая попытка того же job_id (прежний ключ эффекта), max_attempts
увеличивается на extra_attempts. ready/queued/processing НЕ трогаются: «повторить» не
означает выполнить дубль успешной работы. Возвращает (result, job)."""
job = conn.execute(
"SELECT " + JOB_COLUMNS + """ FROM jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.attachment_id = %s AND j.pipeline_version = a.pipeline_version FOR UPDATE OF j""",
(attachment_id,)).fetchone()
if job is None:
return "not_found", None
if job["job_status"] != "failed":
return "refused_status_" + job["job_status"], job
# Аудит F01: staging_key перечитывается ОТДЕЛЬНЫМ запросом под блокировкой строки вложения.
# В READ COMMITTED «SELECT ... FOR UPDATE OF j» после ожидания блокировки перечитывает только
# строку jobs, а колонки attachments из соединения могли остаться из старого снимка — и replay
# принял бы работу, исходник которой janitor уже освободил.
att = conn.execute("SELECT staging_key FROM attachments WHERE id = %s FOR UPDATE",
(job["attachment_id"],)).fetchone()
if att["staging_key"] is None:
return "refused_staging_expired", job
if dry_run:
return "would_replay", job
conn.execute(
"""UPDATE jobs SET status = 'queued', max_attempts = attempt + %s, error_code = NULL,
next_attempt_at = now(), replay_count = replay_count + 1, updated_at = now(), finished_at = NULL
WHERE id = %s""", (extra_attempts, job["job_id"]))
conn.execute("UPDATE attachments SET status = 'queued', error_code = NULL, updated_at = now() WHERE id = %s",
(job["attachment_id"],))
add_outbox(conn, job["job_id"], job["attachment_id"], job["pipeline_version"], job["attempt"] + 1)
add_event(conn, job["job_id"], "replayed", job["attempt"] + 1, actor,
{"reason": reason, "previous_error": job.get("error_code"), "replay_count": job["replay_count"] + 1})
return "replayed", job
+52
View File
@@ -0,0 +1,52 @@
#!/usr/bin/env python3
"""Пробное декодирование JPEG в ОТДЕЛЬНОМ процессе с лимитами (аудит F02).
python jpeg_probe.py <max_pixels> <width> <height> < файл на stdin (обычный файл, seekable)
API раньше декодировал JPEG в своём процессе, рассчитывая, что draft(1/8) уменьшает
память в ~64 раза. Для progressive JPEG это неверно: декодеру нужен буфер DCT-
коэффициентов ВСЕГО кадра. Замер на Pillow 13, 6324x6324 (~40 Мпикс): baseline — 23 MiB,
progressive 4:2:0 — 137 MiB, progressive 4:4:4 — 252 MiB на одно декодирование, а лимит
реплики был 256 MiB. Поэтому проверка вынесена в подпроцесс:
* RLIMIT_AS / RLIMIT_CPU ставятся ДО импорта Pillow;
* oom_score_adj=1000: если памяти контейнера всё же не хватит, ядро убьёт пробу, а не API;
* код выхода: 0 — корректный JPEG; 3 — повреждён/не тот формат; 5 — не хватило памяти/CPU.
"""
import os
import resource
import sys
EXIT_OK, EXIT_INVALID, EXIT_RESOURCE = 0, 3, 5
def main():
max_pixels, width, height = (int(x) for x in sys.argv[1:4])
limit = int(os.environ.get("JPEG_PROBE_MEMORY_MB", "384")) * 1024 * 1024
cpu = int(os.environ.get("JPEG_PROBE_CPU_SECONDS", "10"))
resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
resource.setrlimit(resource.RLIMIT_CPU, (cpu, cpu + 1))
try:
with open("/proc/self/oom_score_adj", "w") as f:
f.write("1000")
except OSError:
pass
import warnings
from PIL import Image
Image.MAX_IMAGE_PIXELS = max_pixels
warnings.simplefilter("error", Image.DecompressionBombWarning)
src = os.fdopen(0, "rb", closefd=False)
try:
with Image.open(src, formats=("JPEG",)) as im:
if im.size != (width, height):
return EXIT_INVALID
im.draft("RGB", (max(1, width // 8), max(1, height // 8)))
im.load() # обрезанные/битые энтропийные данные -> исключение
except MemoryError:
return EXIT_RESOURCE
except Exception:
return EXIT_INVALID
return EXIT_OK
if __name__ == "__main__":
sys.exit(main())
+30
View File
@@ -0,0 +1,30 @@
#!/usr/bin/env python3
"""Однократное применение миграций (compose-сервис `migrate`).
Запускается ОДИН раз до старта/замены API-реплик, а не каждой репликой.
Дополнительно миграции выполняются под pg_advisory_xact_lock: даже если
оператор случайно запустит job дважды параллельно, гонки не будет.
Каждый файл применяется в своей транзакции и фиксируется в schema_migrations.
"""
import logging
import sys
import telemetry
from server import MIGRATIONS_DIR, STORE
log = logging.getLogger("messenger.migrate")
def main():
telemetry.configure_logging() # короткоживущий job: только JSON-лог в stdout, без экспорта
STORE.open()
try:
before = STORE.pending_migrations(MIGRATIONS_DIR)
STORE.migrate(MIGRATIONS_DIR)
log.info("migrations done; applied now: %s", ", ".join(before) or "nothing")
finally:
STORE.close()
if __name__ == "__main__":
sys.exit(main())
+230
View File
@@ -0,0 +1,230 @@
"""Доступ к S3-совместимому хранилищу (SeaweedFS) через клиент minio-py.
API работает с bucket под ОТДЕЛЬНЫМИ credentials с правами только Read+Write на этот
bucket (без List, без создания/удаления bucket, без политик и IAM) — см.
scripts/init-secrets.sh и REPORT.md. Публичных URL/redirect нет: байты всегда идут
через авторизованный API.
Lab6: каждый запрос к S3 — CLIENT span «s3 <Операция>» (внутри запроса/задания) и гистограмма
messenger.s3.operation.duration{messenger.s3.operation, outcome}. В span — bucket и ключ объекта
(ключи назначает сервер: staging/<uuid>, attachments/<id>/v1/<variant>; filename в ключ не входит),
без credentials и подписанных URL.
"""
import contextlib
import logging
import os
import threading
import time
from urllib.parse import urlsplit
import urllib3
from minio import Minio
from minio.error import S3Error
import telemetry
from telemetry import SpanKind
log = logging.getLogger("messenger.s3")
# minio-py для объектов больше part_size делает multipart и держит в памяти
# один part. 5 MiB — минимум S3: файл 10 MiB -> 2 части по 5 MiB.
PART_SIZE = 5 * 1024 * 1024
STREAM_CHUNK = 64 * 1024
# Служебные объекты S3Health: health/<реплика> (вне prefix originals/, janitor их не трогает).
HEALTH_PREFIX = "health/"
class StorageUnavailable(Exception):
"""S3 недоступен/таймаут/ошибка сервера -> 503."""
class ObjectMissing(Exception):
"""Метаданные есть, объекта нет (рассогласование) -> 503 + лог."""
def _secret(name):
path = os.environ.get(name + "_FILE")
if path:
with open(path, encoding="utf-8") as f:
return f.read().strip()
return os.environ.get(name, "")
def make_client(access_env="S3_ACCESS_KEY_ID", secret_env="S3_SECRET_ACCESS_KEY",
connect_timeout=None, read_timeout=None):
endpoint = urlsplit(os.environ.get("S3_ENDPOINT", "http://s3:8333"))
connect_timeout = connect_timeout or float(os.environ.get("S3_CONNECT_TIMEOUT_SECONDS", "2"))
read_timeout = read_timeout or float(os.environ.get("S3_READ_TIMEOUT_SECONDS", "5"))
# Короткие таймауты и без собственных повторов: зависший S3 не держит поток
# дольше таймаута LB, повтор решает клиент (для upload — новым запросом).
http = urllib3.PoolManager(
timeout=urllib3.Timeout(connect=connect_timeout, read=read_timeout),
retries=urllib3.Retry(total=0, connect=0, read=0, redirect=0, status=0),
maxsize=int(os.environ.get("S3_POOL_SIZE", "16")),
block=False)
return Minio(endpoint.netloc, access_key=_secret(access_env), secret_key=_secret(secret_env),
secure=endpoint.scheme == "https", region=os.environ.get("S3_REGION", "us-east-1"),
http_client=http)
def _is_transport_error(exc):
return isinstance(exc, (urllib3.exceptions.HTTPError, OSError))
@contextlib.contextmanager
def _s3_op(operation, bucket, key):
started = time.perf_counter()
outcome = "ok"
attrs = {"rpc.system": "aws-api", "rpc.service": "S3", "rpc.method": operation,
"aws.s3.bucket": bucket, "server.address": "s3"}
if key and not key.startswith(HEALTH_PREFIX):
attrs["aws.s3.key"] = key
try:
with telemetry.child_span("s3 " + operation, SpanKind.CLIENT, attrs):
yield
except ObjectMissing:
outcome = "not_found"
raise
except BaseException:
outcome = "error"
raise
finally:
telemetry.s3_duration.record(time.perf_counter() - started,
{"messenger.s3.operation": operation, "outcome": outcome})
class ObjectStore:
def __init__(self, client, bucket):
self.client = client
self.bucket = bucket
def put(self, key, fileobj, length, content_type):
with _s3_op("PutObject", self.bucket, key):
self._put(key, fileobj, length, content_type)
def _put(self, key, fileobj, length, content_type):
try:
self.client.put_object(self.bucket, key, fileobj, length, content_type=content_type,
part_size=PART_SIZE)
except S3Error as exc:
log.warning("s3 put failed: %s", exc.code)
raise StorageUnavailable()
except Exception as exc:
if _is_transport_error(exc):
log.warning("s3 put failed: %s", type(exc).__name__)
raise StorageUnavailable()
raise
def open(self, key):
"""Поток объекта (urllib3 response). Закрывать: resp.close(); resp.release_conn()."""
with _s3_op("GetObject", self.bucket, key):
return self._open(key)
def _open(self, key):
try:
return self.client.get_object(self.bucket, key)
except S3Error as exc:
if exc.code in ("NoSuchKey", "NoSuchObject"):
raise ObjectMissing()
log.warning("s3 get failed: %s", exc.code)
raise StorageUnavailable()
except Exception as exc:
if _is_transport_error(exc):
log.warning("s3 get failed: %s", type(exc).__name__)
raise StorageUnavailable()
raise
def delete(self, key):
"""Идемпотентно: отсутствие объекта — не ошибка (S3 DELETE так и работает)."""
with _s3_op("DeleteObject", self.bucket, key):
self._delete(key)
def _delete(self, key):
try:
self.client.remove_object(self.bucket, key)
except S3Error as exc:
if exc.code in ("NoSuchKey", "NoSuchObject"):
return
raise StorageUnavailable()
except Exception as exc:
if _is_transport_error(exc):
raise StorageUnavailable()
raise
def ping(self, probe_key):
"""PUT + GET маленького служебного объекта health/<реплика>: проверяет S3,
credentials и РЕАЛЬНЫЕ пути записи и чтения. HEAD bucket/healthz для этого мало:
у SeaweedFS после рестарта они успешны, а первая запись ещё ~5 с висит
(выбор raft-лидера master, выдача volume под запись)."""
import io
with _s3_op("HealthProbe", self.bucket, None):
return self._ping(probe_key, io)
def _ping(self, probe_key, io):
self.client.put_object(self.bucket, probe_key, io.BytesIO(b"ok"), 2, content_type="text/plain")
resp = self.client.get_object(self.bucket, probe_key)
try:
if resp.read() != b"ok":
raise RuntimeError("probe mismatch")
finally:
resp.close()
resp.release_conn()
return True
class S3Health:
"""Фоновая проверка S3, как DbHealth для PostgreSQL.
S3 НЕ входит в /health/ready: он общий для всех реплик, и его отказ не лечится
исключением реплики из LB, а текстовые сообщения без него работают. Флаг нужен,
чтобы upload при известном отказе S3 сразу получал 503, не принимая 10 MiB."""
def __init__(self, store, interval, stale_after, instance_id):
self.store = store
self.probe_key = HEALTH_PREFIX + instance_id
self.interval = interval
self.stale_after = stale_after
self.last_ok = None
self._stop = threading.Event()
self._ok_event = threading.Event() # выставлен, пока последняя проверка успешна
def start(self):
threading.Thread(target=self._loop, name="s3-health", daemon=True).start()
def stop(self):
self._stop.set()
def ok(self):
last = self.last_ok
return last is not None and time.monotonic() - last <= self.stale_after
def wait_startup(self, timeout):
"""Только на старте реплики (успешной проверки ещё не было): подождать до timeout,
пока S3 станет доступен для записи. При подтверждённом отказе — не ждать."""
if self.last_ok is None:
self._ok_event.wait(timeout)
return self.ok()
def known_down(self):
"""S3 был доступен и перестал отвечать. На старте реплики (успешной проверки ещё
не было) — False: чтение может работать раньше, чем прогреется запись."""
last = self.last_ok
return last is not None and time.monotonic() - last > self.stale_after
def _loop(self):
healthy = None
while not self._stop.is_set():
try:
self.store.ping(self.probe_key)
self.last_ok = time.monotonic()
self._ok_event.set()
if healthy is not True:
log.info("s3 health: ok", extra={"event": "s3.health.ok"})
healthy = True
except Exception as exc:
self._ok_event.clear()
if healthy is not False:
log.warning("s3 health: failing (%s)", type(exc).__name__,
extra={"event": "s3.health.failing", "error.type": type(exc).__name__})
healthy = False
self._stop.wait(self.interval)
+220
View File
@@ -0,0 +1,220 @@
#!/usr/bin/env python3
"""Операторский CLI (compose-сервис `ops`, profile tools). Вывод — JSON без секретов.
ops inspect <attachment_id> состояние: attachment, job, события, варианты, outbox, объекты S3
ops failed [--limit N] реестр failed-заданий (DLQ на стороне БД)
ops replay <attachment_id>... [--all-failed] [--error-code C] [--dry-run] [--reason TEXT]
явный replay failed -> queued (ready/queued/processing не трогаются)
ops dlq [--replay] [--purge-invalid]
сообщения в RabbitMQ DLQ: показать; --replay — разобрать каждое
по состоянию jobs (failed -> replay, остальное -> отбросить с audit)
ops publish-raw <json> учебное: опубликовать произвольное тело (проверка DLQ)
Replay всегда проходит через строку jobs под FOR UPDATE: повтор ready-задания отклоняется,
поэтому «повторить» не означает исполнить дубль уже успешной работы.
"""
import argparse
import json
import os
import sys
import pika
import psycopg
from psycopg.rows import dict_row
import common
import telemetry
import jobs
import objstore
EXTRA_ATTEMPTS = common.env_int("JOB_MAX_ATTEMPTS", 5)
def db():
return psycopg.connect(common.database_conninfo(), row_factory=dict_row)
def jsonable(value):
if isinstance(value, dict):
return {k: jsonable(v) for k, v in value.items()}
if isinstance(value, (list, tuple)):
return [jsonable(v) for v in value]
if isinstance(value, (str, int, float, bool)) or value is None:
return value
if hasattr(value, "isoformat"):
return value.isoformat().replace("+00:00", "Z")
return str(value)
def out(data):
print(json.dumps(jsonable(data), ensure_ascii=False, indent=1))
def s3_objects(prefix):
"""Только имена/размеры (ключ janitor: List, без чтения содержимого)."""
store = objstore.ObjectStore(objstore.make_client(), os.environ.get("S3_BUCKET", "messenger-attachments"))
try:
return sorted((o.object_name, o.size) for o in store.client.list_objects(store.bucket, prefix=prefix, recursive=True))
except Exception as exc:
return [("error", type(exc).__name__)]
def cmd_inspect(args):
with db() as conn:
att = conn.execute(
"""SELECT id, chat_id, status, error_code, content_type, size_bytes, sha256, width, height,
object_key, staging_key, pipeline_version, created_at, updated_at
FROM attachments WHERE id = %s""", (args.attachment_id,)).fetchone()
if att is None:
out({"error": "not_found"})
return 1
job = conn.execute(
"""SELECT id, pipeline_version, status, attempt, max_attempts, next_attempt_at, lease_owner,
lease_until, error_code, last_error, replay_count, created_at, updated_at, finished_at
FROM jobs WHERE attachment_id = %s ORDER BY pipeline_version""", (args.attachment_id,)).fetchall()
job_ids = [j["id"] for j in job]
events = conn.execute(
"SELECT job_id, at, event, attempt, actor, detail FROM job_events WHERE job_id = ANY(%s) ORDER BY id",
(job_ids,)).fetchall()
outbox = conn.execute(
"""SELECT id, payload->>'attempt' AS attempt, available_at, created_at, published_at, publish_count,
payload->>'traceparent' AS traceparent
FROM outbox WHERE job_id = ANY(%s) ORDER BY id""", (job_ids,)).fetchall()
variants = conn.execute(
"""SELECT pipeline_version, name, object_key, content_type, size_bytes, width, height, sha256
FROM attachment_variants WHERE attachment_id = %s ORDER BY pipeline_version, name""",
(args.attachment_id,)).fetchall()
objects = s3_objects("attachments/%s/" % args.attachment_id)
staging = s3_objects(att["staging_key"]) if att["staging_key"] else []
out({"attachment": att, "jobs": job, "events": events, "outbox": outbox, "variants": variants,
"s3_final_objects": objects, "s3_staging_objects": staging})
return 0
def cmd_failed(args):
with db() as conn:
rows = conn.execute(
"""SELECT j.attachment_id, j.id AS job_id, j.error_code, j.attempt, j.max_attempts, j.replay_count,
j.last_error, j.updated_at, a.staging_key IS NOT NULL AS replayable
FROM jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.status = 'failed' ORDER BY j.updated_at DESC LIMIT %s""", (args.limit,)).fetchall()
out({"failed": rows, "count": len(rows)})
return 0
def cmd_replay(args):
results = []
with db() as conn:
ids = list(args.attachment_ids)
if args.all_failed:
q = "SELECT attachment_id FROM jobs WHERE status = 'failed'"
params = []
if args.error_code:
q += " AND error_code = %s"
params.append(args.error_code)
ids += [str(r["attachment_id"]) for r in conn.execute(q, params)]
for att_id in ids:
with conn.transaction():
result, job = jobs.replay(conn, att_id, "ops:" + common.HOSTNAME, EXTRA_ATTEMPTS,
args.reason, dry_run=args.dry_run)
results.append({"attachment_id": att_id, "result": result,
"job_id": str(job["job_id"]) if job else None})
out({"replay": results})
return 0 if all(r["result"] in ("replayed", "would_replay") for r in results) else 3
def broker_channel():
conn = pika.BlockingConnection(common.broker_parameters())
return conn, conn.channel()
def cmd_dlq(args):
conn, ch = broker_channel()
seen = []
tags = []
try:
with db() as dbc:
while True:
method, props, body = ch.basic_get(common.DLQ, auto_ack=False)
if method is None:
break
deaths = (props.headers or {}).get("x-death") or []
reason = deaths[0].get("reason") if deaths else None
item = {"reason": reason.decode() if isinstance(reason, bytes) else reason,
"delivery_count": (props.headers or {}).get("x-delivery-count"), "action": "kept"}
try:
msg = jobs.parse_message(body)
item["job_id"] = msg["job_id"]
if args.replay:
with dbc.transaction():
job = jobs.load_job(dbc, msg["job_id"], lock=True)
if job is None:
item["action"] = "kept_unknown_job"
elif job["job_status"] == "failed":
result, _ = jobs.replay(dbc, str(job["attachment_id"]), "ops-dlq", EXTRA_ATTEMPTS,
"dlq replay")
item["action"] = result
else:
# queued/processing/ready: состояние уже ведёт БД, дубль не нужен.
jobs.add_event(dbc, job["job_id"], "dlq_message_dropped", msg["attempt"], "ops-dlq",
{"job_status": job["job_status"], "reason": item["reason"]})
item["action"] = "dropped_job_" + job["job_status"]
except jobs.InvalidMessage as exc:
item["invalid"] = str(exc)
if args.purge_invalid:
item["action"] = "purged_invalid"
seen.append(item)
if item["action"].startswith("kept"):
tags.append(method.delivery_tag) # вернём в DLQ после обхода
else:
ch.basic_ack(method.delivery_tag)
for tag in tags:
ch.basic_nack(tag, requeue=True)
finally:
conn.close()
out({"dlq_messages": seen, "count": len(seen)})
return 0
def cmd_publish_raw(args):
conn, ch = broker_channel()
try:
ch.confirm_delivery()
ch.basic_publish(common.EXCHANGE, common.ROUTING_KEY, args.body.encode(),
pika.BasicProperties(delivery_mode=2, content_type="application/json"), mandatory=True)
finally:
conn.close()
out({"published": True})
return 0
def main():
telemetry.configure_logging(stream=sys.stderr) # stdout — только JSON-результат команды
p = argparse.ArgumentParser(prog="ops")
sub = p.add_subparsers(dest="cmd", required=True)
s = sub.add_parser("inspect")
s.add_argument("attachment_id")
s.set_defaults(func=cmd_inspect)
s = sub.add_parser("failed")
s.add_argument("--limit", type=int, default=50)
s.set_defaults(func=cmd_failed)
s = sub.add_parser("replay")
s.add_argument("attachment_ids", nargs="*")
s.add_argument("--all-failed", action="store_true")
s.add_argument("--error-code")
s.add_argument("--dry-run", action="store_true")
s.add_argument("--reason", default="operator replay")
s.set_defaults(func=cmd_replay)
s = sub.add_parser("dlq")
s.add_argument("--replay", action="store_true")
s.add_argument("--purge-invalid", action="store_true")
s.set_defaults(func=cmd_dlq)
s = sub.add_parser("publish-raw")
s.add_argument("body")
s.set_defaults(func=cmd_publish_raw)
args = p.parse_args()
return args.func(args)
if __name__ == "__main__":
sys.exit(main())
+347
View File
@@ -0,0 +1,347 @@
#!/usr/bin/env python3
"""Outbox relay + reaper (compose-сервис `relay`).
Закрывает разрыв PostgreSQL <-> broker (transactional outbox):
API в ОДНОЙ транзакции пишет queued-вложение, jobs и outbox. Relay берёт неопубликованные
строки (FOR UPDATE SKIP LOCKED — несколько relay не мешают друг другу), публикует каждую
в RabbitMQ с publisher confirm (persistent, mandatory) и только ПОСЛЕ подтверждения
брокера ставит published_at в той же транзакции. Крах между COMMIT API и publish, между
publish и confirm или между confirm и UPDATE outbox -> строка остаётся неопубликованной и
будет опубликована снова: возможен дубль сообщения (at-least-once), его гасит worker по
состоянию jobs.
Будит relay NOTIFY из триггера outbox; без уведомления — опрос раз в RELAY_POLL_SECONDS.
Строки с available_at в будущем (retry с backoff) публикуются, когда наступит срок.
Reaper (раз в REAPER_INTERVAL_SECONDS, под advisory-блокировкой — один на всех):
* processing с истёкшей арендой -> queued (backoff) или failed(retry_exhausted);
* queued без движения дольше JOB_REDRIVE_AFTER_SECONDS и без неопубликованного outbox
-> ещё одна публикация (сообщение могло потеряться вместе с volume брокера);
* опубликованные строки outbox старше OUTBOX_RETENTION_SECONDS удаляются.
Учебная инъекция отказа: RELAY_FAULT=crash-before-publish | crash-after-publish —
один раз за жизнь контейнера (маркер в /tmp) процесс делает os._exit посреди батча.
Lab6:
* каждое сообщение публикуется в PRODUCER span «attachments send» — child контекста из
payload.traceparent (span «create» API/worker). Контекст send записывается и в тело
(traceparent/tracestate, по jobs.schema.json), и в AMQP headers — worker продолжает трассу;
* метрики: messenger.outbox.published{outcome}, messenger.outbox.publish_delay (s, от
available_at до publisher confirm), и наблюдаемые gauges очереди по источнику истины
(PostgreSQL): messenger.jobs.count{status}, messenger.jobs.oldest_age{status} (s, возраст
старейшего незавершённого job от durable acceptance), messenger.jobs.ready_lag (s, сколько
ждёт самый старый job, которому уже пора выполняться), messenger.outbox.pending и
messenger.outbox.oldest_age (не опубликовано relay). Gauges считает отдельное соединение
со statement_timeout 2 с раз в интервал экспорта метрик.
"""
import json
import logging
import os
import sys
import threading
import time
import pika
import psycopg
from psycopg.rows import dict_row
import common
import jobs
import telemetry
from telemetry import SpanKind, Status, StatusCode
log = logging.getLogger("relay")
POLL_SECONDS = common.env_float("RELAY_POLL_SECONDS", 1)
BATCH = common.env_int("RELAY_BATCH", 100)
REAPER_INTERVAL = common.env_float("REAPER_INTERVAL_SECONDS", 5)
REDRIVE_AFTER = common.env_int("JOB_REDRIVE_AFTER_SECONDS", 900)
OUTBOX_RETENTION = common.env_int("OUTBOX_RETENTION_SECONDS", 86400)
RETRY_BASE = common.env_float("JOB_RETRY_BASE_SECONDS", 2)
RETRY_MAX = common.env_float("JOB_RETRY_MAX_SECONDS", 60)
FAULT = os.environ.get("RELAY_FAULT", "")
FAULT_MARKER = "/tmp/relay-fault.done"
HEARTBEAT = "/tmp/relay.heartbeat"
REAPER_LOCK_ID = 727003
PUBLISHED = telemetry.meter.create_counter(
"messenger.outbox.published", unit="{message}", description="Outbox rows published to the broker")
PUBLISH_DELAY = telemetry.meter.create_histogram(
"messenger.outbox.publish_delay", unit="s",
description="Delay from outbox available_at to broker publisher confirm")
class QueueGauges:
"""Глубина очереди и возраст заданий по PostgreSQL (источник истины), не по брокеру."""
QUERY = """
SELECT
(SELECT json_object_agg(status, n) FROM (SELECT status, count(*) AS n FROM jobs GROUP BY status) c) AS counts,
(SELECT json_object_agg(status, age) FROM (
SELECT status, EXTRACT(EPOCH FROM now() - min(created_at))::float8 AS age FROM jobs
WHERE status IN ('queued', 'processing') GROUP BY status) a) AS ages,
(SELECT COALESCE(EXTRACT(EPOCH FROM now() - min(next_attempt_at)), 0)::float8 FROM jobs
WHERE status = 'queued' AND next_attempt_at <= now()) AS ready_lag,
(SELECT count(*) FROM outbox WHERE published_at IS NULL AND available_at <= now()) AS outbox_pending,
(SELECT COALESCE(EXTRACT(EPOCH FROM now() - min(available_at)), 0)::float8 FROM outbox
WHERE published_at IS NULL AND available_at <= now()) AS outbox_age"""
STATUSES = ("queued", "processing", "ready", "failed")
def __init__(self, conninfo):
self.conninfo = conninfo
self.conn = None
self.lock = threading.Lock()
self.cache = (0.0, None)
def snapshot(self):
# Несколько callbacks за один сбор метрик -> один SQL-запрос (кэш на 2 с).
with self.lock:
at, data = self.cache
if data is not None and time.monotonic() - at < 2:
return data
try:
if self.conn is None or self.conn.closed:
self.conn = psycopg.connect(self.conninfo, autocommit=True, row_factory=dict_row,
options="-c statement_timeout=2000")
data = self.conn.execute(self.QUERY).fetchone()
except psycopg.Error:
try:
if self.conn is not None:
self.conn.close()
except Exception:
pass
self.conn, data = None, None
self.cache = (time.monotonic(), data)
return data
def register(self):
def counts(options):
d = self.snapshot()
if d is not None:
got = d["counts"] or {}
for st in self.STATUSES:
yield telemetry.metrics.Observation(int(got.get(st, 0)), {"messenger.job.status": st})
def ages(options):
d = self.snapshot()
if d is not None:
got = d["ages"] or {}
for st in ("queued", "processing"):
yield telemetry.metrics.Observation(float(got.get(st) or 0.0), {"messenger.job.status": st})
def ready_lag(options):
d = self.snapshot()
if d is not None:
yield telemetry.metrics.Observation(float(d["ready_lag"] or 0.0))
def outbox_pending(options):
d = self.snapshot()
if d is not None:
yield telemetry.metrics.Observation(int(d["outbox_pending"] or 0))
def outbox_age(options):
d = self.snapshot()
if d is not None:
yield telemetry.metrics.Observation(float(d["outbox_age"] or 0.0))
m = telemetry.meter
m.create_observable_gauge("messenger.jobs.count", [counts], unit="{job}",
description="Jobs by status (PostgreSQL jobs table)")
m.create_observable_gauge("messenger.jobs.oldest_age", [ages], unit="s",
description="Age of the oldest unfinished job since durable acceptance")
m.create_observable_gauge("messenger.jobs.ready_lag", [ready_lag], unit="s",
description="How long the oldest due queued job has been waiting for a worker")
m.create_observable_gauge("messenger.outbox.pending", [outbox_pending], unit="{message}",
description="Due outbox rows not yet published to the broker")
m.create_observable_gauge("messenger.outbox.oldest_age", [outbox_age], unit="s",
description="Age of the oldest due unpublished outbox row")
def fault(point):
if FAULT != point or os.path.exists(FAULT_MARKER):
return
with open(FAULT_MARKER, "w") as f:
f.write(point)
log.warning("FAULT INJECTION %s: exiting without finishing the batch", point,
extra={"event": "fault.injected", "fault.point": point})
os._exit(86)
class Relay:
def __init__(self):
self.conninfo = common.database_conninfo()
self.db = None
self.listen = None
self.broker = None
self.channel = None
self.next_reap = 0.0
self.stop = threading.Event()
# --- соединения ---
def ensure_db(self):
if self.db is None or self.db.closed:
self.db = psycopg.connect(self.conninfo, row_factory=dict_row)
if self.listen is None or self.listen.closed:
self.listen = psycopg.connect(self.conninfo, autocommit=True)
self.listen.execute("LISTEN outbox")
def ensure_broker(self):
if self.broker is None or self.broker.is_closed or self.channel is None or self.channel.is_closed:
self.close_broker()
self.broker = common.connect_broker(log, self.stop)
if self.broker is None:
return
self.channel = self.broker.channel()
# Publisher confirms: basic_publish ждёт ack брокера (сообщение записано в
# quorum-очередь) и бросает NackError/UnroutableError при отказе.
self.channel.confirm_delivery()
log.info("connected to broker", extra={"event": "broker.connected"})
def close_broker(self):
try:
if self.broker is not None and not self.broker.is_closed:
self.broker.close()
except Exception:
pass
self.broker = self.channel = None
def close_db(self):
for conn in (self.db, self.listen):
try:
if conn is not None:
conn.close()
except Exception:
pass
self.db = self.listen = None
# --- публикация ---
def publish_batch(self):
"""Один батч в одной транзакции. Возвращает число опубликованных строк."""
spans = []
try:
with self.db.transaction():
rows = self.db.execute(
"""SELECT id, job_id, payload, EXTRACT(EPOCH FROM now() - available_at)::float8 AS delay_s
FROM outbox WHERE published_at IS NULL AND available_at <= now()
ORDER BY available_at, id LIMIT %s FOR UPDATE SKIP LOCKED""", (BATCH,)).fetchall()
if not rows:
return 0
fault("crash-before-publish") # COMMIT задания есть, publish ещё нет
for row in rows:
payload = dict(row["payload"])
parent = telemetry.extract({k: payload[k] for k in ("traceparent", "tracestate") if k in payload})
span = telemetry.tracer.start_span(
"attachments send", kind=SpanKind.PRODUCER, context=parent,
attributes={"messaging.system": "rabbitmq", "messaging.operation.type": "send",
"messaging.operation.name": "publish",
"messaging.destination.name": common.EXCHANGE,
"messaging.rabbitmq.destination.routing_key": common.ROUTING_KEY,
"messaging.message.id": "%s:%s" % (payload["job_id"], payload["attempt"]),
"messenger.job.id": payload["job_id"],
"messenger.attachment.id": payload["attachment_id"],
"messenger.job.attempt": payload["attempt"],
"messenger.outbox.id": row["id"],
"messenger.outbox.publish_delay_s": round(row["delay_s"] or 0.0, 3)})
spans.append((span, row["delay_s"] or 0.0))
with telemetry.trace.use_span(span, end_on_exit=False):
carrier = telemetry.inject_dict()
payload.pop("tracestate", None)
payload.update(carrier)
self.channel.basic_publish(
exchange=common.EXCHANGE, routing_key=common.ROUTING_KEY,
body=json.dumps(payload, separators=(",", ":")).encode(),
properties=pika.BasicProperties(
content_type="application/json", delivery_mode=pika.DeliveryMode.Persistent,
message_id="%s:%s" % (payload["job_id"], payload["attempt"]), type=jobs.JOB_TYPE,
headers=dict({"x-outbox-id": row["id"]}, **carrier)),
mandatory=True)
fault("crash-after-publish") # confirm получен, published_at не записан -> дубль
self.db.execute(
"UPDATE outbox SET published_at = now(), publish_count = publish_count + 1 WHERE id = ANY(%s)",
([r["id"] for r in rows],))
except BaseException as exc:
# Транзакция откатилась: строки останутся неопубликованными и уйдут следующим батчем.
for span, _delay in spans:
span.set_attribute("error.type", type(exc).__name__)
span.set_status(Status(StatusCode.ERROR, type(exc).__name__))
span.end()
if spans:
PUBLISHED.add(len(spans), {"outcome": "failed", "error.type": type(exc).__name__})
raise
for span, delay in spans:
PUBLISH_DELAY.record(delay)
span.end()
PUBLISHED.add(len(rows), {"outcome": "ok"})
log.info("published %d job message(s)", len(rows), extra={"event": "outbox.published", "count": len(rows)})
return len(rows)
def reap(self):
with self.db.transaction():
if not self.db.execute("SELECT pg_try_advisory_xact_lock(%s) AS ok", (REAPER_LOCK_ID,)).fetchone()["ok"]:
return
expired = jobs.reap_expired_leases(self.db, RETRY_BASE, RETRY_MAX, actor="reaper:" + common.OWNER)
redriven = jobs.redrive_stale_queued(self.db, REDRIVE_AFTER, actor="reaper:" + common.OWNER)
purged = self.db.execute(
"DELETE FROM outbox WHERE published_at < now() - make_interval(secs => %s)",
(OUTBOX_RETENTION,)).rowcount
if expired or redriven or purged:
log.info("reaper: expired_leases=%d redriven=%d outbox_purged=%d", expired, redriven, purged,
extra={"event": "reaper.pass", "expired_leases": expired, "redriven": redriven,
"outbox_purged": purged})
def wait_notify(self, timeout):
"""Ждём NOTIFY outbox не дольше timeout; параллельно обслуживаем heartbeat брокера."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
if self.broker is not None:
self.broker.process_data_events(time_limit=0)
for _ in self.listen.notifies(timeout=min(0.25, max(0.01, deadline - time.monotonic())), stop_after=1):
return
def run(self):
log.info("relay started owner=%s fault=%s", common.OWNER, FAULT or "-", extra={"event": "relay.started"})
delay = 0.5
while not self.stop.is_set():
common.touch(HEARTBEAT)
try:
self.ensure_db()
self.ensure_broker()
if self.broker is None:
continue
while self.publish_batch() == BATCH:
pass
if time.monotonic() >= self.next_reap:
self.reap()
self.next_reap = time.monotonic() + REAPER_INTERVAL
self.wait_notify(POLL_SECONDS)
delay = 0.5
except (pika.exceptions.AMQPError, pika.exceptions.UnroutableError, pika.exceptions.NackError) as exc:
# Транзакция батча откатилась: строки остались неопубликованными.
log.warning("broker publish failed (%s), retry in %.1fs", type(exc).__name__, delay,
extra={"event": "broker.publish_failed", "error.type": type(exc).__name__})
self.close_broker()
self.stop.wait(delay)
delay = min(5.0, delay * 2)
except psycopg.Error as exc:
log.warning("database error (%s), retry in %.1fs", type(exc).__name__, delay,
extra={"event": "db.error", "error.type": type(exc).__name__})
self.close_db()
self.stop.wait(delay)
delay = min(5.0, delay * 2)
self.close_broker()
self.close_db()
def main():
import signal
telemetry.setup("messenger-relay")
relay = Relay()
QueueGauges(relay.conninfo).register()
signal.signal(signal.SIGTERM, lambda *_: relay.stop.set())
signal.signal(signal.SIGINT, lambda *_: relay.stop.set())
relay.run()
log.info("relay stopped", extra={"event": "relay.stopped"})
telemetry.shutdown()
return 0
if __name__ == "__main__":
sys.exit(main())
+85
View File
@@ -0,0 +1,85 @@
#!/usr/bin/env python3
"""Идемпотентный bootstrap S3 (однократный compose-job `s3-init`).
Работает под admin-credentials, которые есть ТОЛЬКО у этого job (API и janitor их не
получают). Повторный запуск ничего не ломает:
1. ждёт доступности S3 (до 60 с);
2. создаёт bucket, если его нет (уже существующий — не ошибка);
3. проверяет приватность: анонимные GET объекта и ListBucket должны получить 403.
Если bucket вдруг публичен — exit 1, и API не стартует (depends_on).
Права пользователей (api: Read+Write, janitor: List+Write) задаются декларативно в
secrets/s3_identities.json (генерирует scripts/init-secrets.sh).
"""
import io
import json
import logging
import os
import sys
import time
import urllib.error
import urllib.request
from minio.error import S3Error
import objstore
import telemetry
telemetry.configure_logging()
log = logging.getLogger("messenger.s3-init")
def anonymous_status(url):
try:
with urllib.request.urlopen(url, timeout=3) as resp:
return resp.status
except urllib.error.HTTPError as exc:
return exc.code
def main():
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
endpoint = os.environ.get("S3_ENDPOINT", "http://s3:8333").rstrip("/")
# Первый PUT в новый bucket ждёт, пока SeaweedFS выделит volume-ы коллекции: таймаут больше.
client = objstore.make_client(read_timeout=30)
deadline = time.monotonic() + 60
while True:
try:
exists = client.bucket_exists(bucket)
break
except Exception as exc:
if time.monotonic() > deadline:
raise
log.info("s3 not ready (%s), retrying", type(exc).__name__)
time.sleep(1)
created = False
if not exists:
try:
client.make_bucket(bucket)
created = True
except S3Error as exc:
if exc.code not in ("BucketAlreadyOwnedByYou", "BucketAlreadyExists"):
raise
# Контрольный объект: на нём проверяем, что анонимный GET не проходит.
probe = "bootstrap/probe"
for attempt in range(1, 6):
try:
client.put_object(bucket, probe, io.BytesIO(b"private"), 7, content_type="text/plain")
break
except Exception as exc:
if attempt == 5:
raise
log.info("probe put failed (%s), retry %d", type(exc).__name__, attempt)
time.sleep(2)
checks = {
"anonymous_get_object": anonymous_status("%s/%s/%s" % (endpoint, bucket, probe)),
"anonymous_list_bucket": anonymous_status("%s/%s?list-type=2" % (endpoint, bucket)),
}
client.remove_object(bucket, probe)
private = all(code in (401, 403) for code in checks.values())
print(json.dumps({"bucket": bucket, "created": created, "already_existed": exists,
"anonymous_http_status": checks, "private": private}), flush=True)
return 0 if private else 1
if __name__ == "__main__":
sys.exit(main())
+53
View File
@@ -0,0 +1,53 @@
"""Пароли (scrypt из стандартной библиотеки) и сессионные токены."""
import base64
import hashlib
import hmac
import os
import secrets
# Параметры scrypt: N=2^15, r=8, p=1 (~32 МБ памяти и ~0.1 с на проверку).
SCRYPT_LOG_N = 15
SCRYPT_R = 8
SCRYPT_P = 1
_MAXMEM = 128 * 1024 * 1024
def _scrypt(password, salt, log_n, r, p):
return hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2 ** log_n, r=r, p=p,
maxmem=_MAXMEM, dklen=32)
def hash_password(password):
"""Возвращает строку scrypt$logN$r$p$salt$hash; plaintext нигде не хранится."""
salt = os.urandom(16)
digest = _scrypt(password, salt, SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P)
return "scrypt$%d$%d$%d$%s$%s" % (
SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P,
base64.b64encode(salt).decode(), base64.b64encode(digest).decode())
def verify_password(password, stored):
try:
scheme, log_n, r, p, salt, digest = stored.split("$")
if scheme != "scrypt":
return False
expected = base64.b64decode(digest)
actual = _scrypt(password, base64.b64decode(salt), int(log_n), int(r), int(p))
except (ValueError, TypeError):
return False
return hmac.compare_digest(actual, expected) # сравнение за постоянное время
# Хеш несуществующего пользователя: неверный логин тратит столько же времени,
# сколько неверный пароль, и не выдаёт, существует ли username.
DUMMY_HASH = hash_password(secrets.token_urlsafe(16))
def new_token():
"""Непрозрачный случайный токен: 32 байта = 256 бит энтропии."""
return secrets.token_urlsafe(32)
def token_hash(token):
"""В БД лежит только SHA-256 токена: утечка таблицы не даёт готовых сессий."""
return hashlib.sha256(token.encode("utf-8")).digest()
+1314
View File
File diff suppressed because it is too large Load Diff
+463
View File
@@ -0,0 +1,463 @@
"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии, метаданные вложений.
Lab5: вложение создаётся как pending (скрыто), после записи оригинала в staging одной
транзакцией становится queued вместе с заданием и записью outbox (src/jobs.py).
Источник истины — база данных. В памяти процесса состояния нет, поэтому
перезапуск API (и самой БД с сохранённым volume) не теряет данные.
Lab6: каждая публичная операция — CLIENT span «db <операция>» и гистограмма
db.client.operation.duration{db.operation.name}; ожидание соединения пула — отдельная
гистограмма db.client.connection.wait_time и атрибут span. По ним медленная/заблокированная БД
отличается от медленного кода обработчика (spans db длинные vs короткие).
"""
import contextlib
import datetime as dt
import logging
import time
import uuid
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
import jobs
import telemetry
from psycopg_pool import ConnectionPool
from telemetry import db_operation
log = logging.getLogger("messenger.store")
EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций
class Conflict(Exception):
pass
class UnknownMember(Exception):
pass
class AttachmentNotFound(Exception):
"""Вложение неизвестно, не принято (pending) или принадлежит другому чату -> 404."""
class AttachmentFailed(Exception):
"""Вложение в состоянии failed: прикреплять нельзя -> 409."""
def format_ts(value):
"""datetime -> RFC 3339 UTC с микросекундами и суффиксом Z."""
return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def to_micros(value):
delta = value - EPOCH
return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
def from_micros(micros):
return EPOCH + dt.timedelta(microseconds=micros)
def _user(row):
# Пароль/hash и сессионные данные никогда не входят в User.
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": format_ts(row["created_at"]),
}
def _chat(row):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": format_ts(row["created_at"]),
}
def _message(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": format_ts(row["created_at"]),
"attachment_ids": [str(a) for a in (row["attachment_ids"] or [])],
}
def _attachment(row):
# Наружу не отдаются object_key, bucket и внутренние адреса.
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"owner_id": str(row["owner_id"]),
"filename": row["filename"],
"content_type": row["content_type"],
"size_bytes": row["size_bytes"],
"sha256": row["sha256"],
"status": row["status"],
# Варианты показываются только у ready (их наличие = готовность уровня).
"variants": list(row["variants"] or []) if row["status"] == "ready" else [],
"error_code": row["error_code"] if row["status"] == "failed" else None,
"created_at": format_ts(row["created_at"]),
"updated_at": format_ts(row["updated_at"]),
}
ATTACHMENT_COLUMNS = """a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
a.status, a.error_code, a.object_key, a.created_at, a.updated_at,
(SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type,
'size_bytes', v.size_bytes, 'width', v.width, 'height', v.height, 'sha256', v.sha256)
ORDER BY array_position(ARRAY['thumbnail','crop','optimized'], v.name))
FROM attachment_variants v
WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version) AS variants"""
MESSAGE_COLUMNS = """m.id, m.chat_id, m.sender_id, m.text, m.created_at,
(SELECT array_agg(ma.attachment_id ORDER BY ma.position) FROM message_attachments ma
WHERE ma.message_id = m.id) AS attachment_ids"""
CHAT_COLUMNS = """c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids"""
class InstrumentedPool(ConnectionPool):
"""ConnectionPool, который измеряет ожидание соединения (насыщение пула видно в метриках)."""
@contextlib.contextmanager
def connection(self, timeout=None):
started = time.perf_counter()
outcome = {}
try:
conn = self.getconn(timeout=timeout)
except Exception as exc:
outcome["error.type"] = type(exc).__name__
raise
finally:
waited = time.perf_counter() - started
telemetry.db_wait.record(waited, dict({"db.client.connection.pool.name": "api",
"db.system.name": telemetry.DB_SYSTEM}, **outcome))
span = telemetry.trace.get_current_span()
if span.is_recording():
span.set_attribute("db.client.connection.wait_time_ms", round(waited * 1000, 3))
try:
with conn:
yield conn
finally:
self.putconn(conn)
class Store:
def __init__(self, conninfo, pool_size=10, pool_timeout=3):
# check: перед выдачей соединение проверяется. После перезапуска PostgreSQL
# «мёртвые» соединения отбрасываются, и запрос не получает ложный 503.
self.pool = InstrumentedPool(
conninfo, min_size=1, max_size=pool_size, timeout=pool_timeout,
kwargs={"row_factory": dict_row}, open=False,
check=ConnectionPool.check_connection)
# --- запуск ---
def open(self, wait_seconds=60):
"""Ждём готовности БД (она может стартовать дольше API) и открываем пул."""
self.pool.open()
deadline = time.monotonic() + wait_seconds
while True:
try:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
return
except Exception as exc:
if time.monotonic() > deadline:
raise
log.info("database is not ready yet (%s), retrying", type(exc).__name__)
time.sleep(1)
def close(self):
self.pool.close()
def migrate(self, directory):
"""Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз."""
files = sorted(Path(directory).glob("*.sql"))
with self.pool.connection() as conn:
# Advisory-блокировка (сессионная): параллельный повторный запуск job не устроит гонку.
conn.autocommit = True
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,))
try:
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""")
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in done:
continue
# Миграция и её отметка — одна транзакция: либо целиком, либо никак.
with conn.transaction():
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
log.info("migration applied: %s", path.name)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,))
conn.autocommit = False
def pending_migrations(self, directory):
"""Миграции из каталога образа, ещё не применённые к БД (API их НЕ применяет)."""
files = sorted(p.name for p in Path(directory).glob("*.sql"))
with self.pool.connection() as conn:
exists = conn.execute("SELECT to_regclass('schema_migrations') IS NOT NULL AS ok").fetchone()["ok"]
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")} if exists else set()
return [f for f in files if f not in done]
@db_operation("ping")
def ping(self):
with self.pool.connection() as conn:
conn.execute("SELECT 1")
# --- пользователи ---
@db_operation("create_user")
def create_user(self, username, display_name, password_hash):
try:
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, username, display_name, created_at""",
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
except psycopg.errors.UniqueViolation:
# Уникальность гарантирует сама БД — гонка двух регистраций безопасна.
raise Conflict()
return _user(row)
@db_operation("get_credentials")
def get_credentials(self, username):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,)).fetchone()
if row is None:
return None, None
return _user(row), row["password_hash"]
# --- сессии ---
@db_operation("create_session")
def create_session(self, user_id, token_hash, ttl_seconds):
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO sessions (token_hash, user_id, created_at, expires_at)
VALUES (%s, %s, now(), now() + make_interval(secs => %s))
RETURNING expires_at""",
(token_hash, user_id, ttl_seconds)).fetchone()
return format_ts(row["expires_at"])
@db_operation("get_session_user")
def get_session_user(self, token_hash):
"""Пользователь действующей сессии или None (неизвестна/истекла/отозвана)."""
with self.pool.connection() as conn:
row = conn.execute(
"""SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
(token_hash,)).fetchone()
return _user(row) if row else None
@db_operation("revoke_session")
def revoke_session(self, token_hash):
with self.pool.connection() as conn:
conn.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
(token_hash,))
# --- чаты ---
@db_operation("create_chat")
def create_chat(self, title, member_ids):
"""Чат и его участники создаются в одной транзакции (атомарно)."""
chat_id = uuid.uuid4()
with self.pool.connection() as conn:
found = conn.execute(
"SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"]
if found != len(member_ids):
raise UnknownMember()
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())",
(chat_id, title))
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat_id, m, i) for i, m in enumerate(member_ids)])
row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone()
return _chat(row)
@db_operation("get_chat_for")
def get_chat_for(self, user_id, chat_id):
"""Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT " + CHAT_COLUMNS + """ FROM chats c
WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)""",
(chat_id, user_id)).fetchone()
return _chat(row) if row else None
@db_operation("list_chats")
def list_chats(self, user_id, after, limit):
params = [user_id]
where = ""
if after:
where = "AND (c.created_at, c.id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT " + CHAT_COLUMNS + """ FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall()
return self._page(rows, limit, _chat)
# --- сообщения ---
@db_operation("add_message")
def add_message(self, user_id, chat_id, text, attachment_ids, idem_key, request_hash, idem_ttl_seconds):
"""Идемпотентная отправка. Возвращает (message, replayed) или None, если чата нет/он чужой.
Всё в ОДНОЙ транзакции: проверка доступа, поиск ключа, вставка сообщения и запись
ключа. Либо фиксируется и сообщение, и ключ, либо ничего (транзиентная ошибка
не запоминается как результат — клиент повторит с тем же ключом).
Конкурентные запросы с одним ключом через разные реплики сериализуются
блокировкой строки чата (FOR UPDATE), второй после COMMIT первого видит ключ.
PK таблицы ключей — страховка: даже без блокировки дубль не зафиксируется.
Lab4: в той же транзакции проверяется, что все attachment_ids — ready-вложения
ЭТОГО чата (FOR SHARE: строка не исчезнет до COMMIT), и пишутся ссылки.
"""
with self.pool.connection() as conn:
# FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому
# created_at растёт в порядке фиксации и keyset-курсор не пропускает записи.
allowed = conn.execute(
"""SELECT 1 FROM chats c WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)
FOR UPDATE OF c""", (chat_id, user_id)).fetchone()
if allowed is None:
return None
existing = conn.execute(
"""SELECT k.request_hash, k.expires_at > now() AS alive, """ + MESSAGE_COLUMNS + """
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
WHERE k.user_id = %s AND k.chat_id = %s AND k.idem_key = %s""",
(user_id, chat_id, idem_key)).fetchone()
if existing is not None:
if existing["alive"]:
if bytes(existing["request_hash"]) != request_hash:
raise Conflict()
return _message(existing), True
# Ключ старше TTL (24 ч) — освобождаем его и обрабатываем как новый.
conn.execute(
"DELETE FROM idempotency_keys WHERE user_id = %s AND chat_id = %s AND idem_key = %s",
(user_id, chat_id, idem_key))
if attachment_ids:
# Lab5: queued/processing/ready можно прикреплять; failed — 409;
# pending (upload ещё не принят) — как неизвестное.
found = conn.execute(
"""SELECT id, status FROM attachments
WHERE id = ANY(%s::uuid[]) AND chat_id = %s AND status <> 'pending'
FOR SHARE""", (attachment_ids, chat_id)).fetchall()
if len(found) != len(attachment_ids):
# Чужой чат, неизвестный или непринятый id — одинаково 404.
raise AttachmentNotFound()
if any(r["status"] == "failed" for r in found):
raise AttachmentFailed()
row = conn.execute(
"""INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, chat_id, sender_id, text, created_at""",
(uuid.uuid4(), chat_id, user_id, text)).fetchone()
if attachment_ids:
with conn.cursor() as cur:
cur.executemany(
"""INSERT INTO message_attachments (message_id, attachment_id, position)
VALUES (%s, %s, %s)""",
[(row["id"], a, i) for i, a in enumerate(attachment_ids)])
row = dict(row, attachment_ids=list(attachment_ids))
conn.execute(
"""INSERT INTO idempotency_keys (user_id, chat_id, idem_key, request_hash, message_id, expires_at)
VALUES (%s, %s, %s, %s, %s, now() + make_interval(secs => %s))""",
(user_id, chat_id, idem_key, request_hash, row["id"], idem_ttl_seconds))
return _message(row), False
@db_operation("list_messages")
def list_messages(self, chat_id, after, limit):
params = [chat_id]
where = ""
if after:
where = "AND (m.created_at, m.id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1)
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT " + MESSAGE_COLUMNS + " FROM messages m WHERE m.chat_id = %s "
+ where + " ORDER BY m.created_at, m.id LIMIT %s", params).fetchall()
return self._page(rows, limit, _message)
# --- вложения ---
@db_operation("create_pending_attachment")
def create_pending_attachment(self, att_id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, width, height, object_key, staging_key, pipeline_version):
"""Шаг 1: намерение фиксируется ДО PUT в staging (как в lab4). Строка pending
API не показывает; брошенную (крах до постановки в очередь) убирает janitor."""
with self.pool.connection() as conn:
conn.execute(
"""INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, width, height, object_key, staging_key, pipeline_version, status, created_at, updated_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'pending', now(), now())""",
(att_id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
width, height, object_key, staging_key, pipeline_version))
@db_operation("enqueue_attachment")
def enqueue_attachment(self, att_id, pipeline_version, max_attempts, before_commit=None):
"""Шаг 3 (после PUT в staging): ОДНА транзакция pending -> queued + jobs + outbox.
После COMMIT работа принята: даже если API сразу упадёт, relay опубликует задание.
None — строку уже убрал janitor (ответ 503)."""
with self.pool.connection() as conn:
job_id = jobs.enqueue(conn, att_id, pipeline_version, max_attempts)
if job_id is None:
return None
if before_commit:
before_commit()
row = conn.execute("SELECT " + ATTACHMENT_COLUMNS + " FROM attachments a WHERE a.id = %s",
(att_id,)).fetchone()
return _attachment(row)
@db_operation("delete_pending_attachment")
def delete_pending_attachment(self, att_id):
"""Компенсация: убрать непринятое намерение (staging-объект удалён/не создан)."""
with self.pool.connection() as conn:
conn.execute("DELETE FROM attachments WHERE id = %s AND status = 'pending'", (att_id,))
@db_operation("get_attachment_for")
def get_attachment_for(self, user_id, att_id):
"""(attachment, object_key) для участника чата; иначе None. Pending не виден."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT " + ATTACHMENT_COLUMNS + """ FROM attachments a
WHERE a.id = %s AND a.status <> 'pending' AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = a.chat_id AND m.user_id = %s)""",
(att_id, user_id)).fetchone()
return (_attachment(row), row["object_key"]) if row else None
@db_operation("get_variant_key")
def get_variant_key(self, att_id, name):
"""object_key варианта текущей версии pipeline (или None)."""
with self.pool.connection() as conn:
row = conn.execute(
"""SELECT v.object_key FROM attachment_variants v JOIN attachments a ON a.id = v.attachment_id
WHERE v.attachment_id = %s AND v.name = %s AND v.pipeline_version = a.pipeline_version""",
(att_id, name)).fetchone()
return row["object_key"] if row else None
@staticmethod
def _page(rows, limit, convert):
has_more = len(rows) > limit
rows = rows[:limit]
last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None
return [convert(r) for r in rows], last
+492
View File
@@ -0,0 +1,492 @@
"""Lab6: наблюдаемость всех процессов (API, relay, worker, janitor) через OpenTelemetry SDK.
Три сигнала уходят по OTLP/HTTP (protobuf) в OTel Collector (OTEL_EXPORTER_OTLP_ENDPOINT):
traces -> BatchSpanProcessor (ограниченная очередь, сброс раз в 1 с) -> Collector -> Tempo
metrics -> PeriodicExportingMetricReader (раз в OTEL_METRIC_EXPORT_INTERVAL) -> Collector -> Prometheus
logs -> logging.Handler -> BatchLogRecordProcessor -> Collector -> Loki
и параллельно — структурный JSON в stdout (`docker compose logs`), с trace_id/span_id.
Принципы:
* телеметрия никогда не ломает бизнес-путь: все очереди SDK ограничены (max_queue_size),
экспорт — с таймаутом в фоновых потоках; недоступный Collector = потерянная телеметрия,
а не ошибка запроса. Потери считает сам SDK: otel.sdk.processor.*.processed{error.type}
и otel.sdk.exporter.*.exported{error.type} (meter_provider передаётся процессорам/экспортёрам);
* в атрибуты МЕТРИК идут только низкокардинальные значения (метод, шаблон маршрута, класс
статуса, тип/исход задания, имя операции). ID пользователей/чатов/сообщений/вложений,
request_id, raw URL, filename и тексты — никогда;
* в трассы/логи допускаются технические ID синтетических учебных данных (job_id,
attachment_id, request_id) — по ним upload связывается с заданием. Пароли, Authorization,
токены, тела сообщений, байты изображений, URL с паролями — запрещены (см. redact());
* OTEL_SDK_DISABLED=true выключает экспорт полностью (no-op провайдеры), stdout-логи остаются.
Resource: service.name (messenger-api | -worker | -relay | -janitor), service.version
(= APP_VERSION образа), service.instance.id (= hostname контейнера = X-Instance-Id),
deployment.environment.name (из OTEL_RESOURCE_ATTRIBUTES, по умолчанию lab).
"""
import contextlib
import datetime as dt
import functools
import json
import logging
import os
import re
import socket
import sys
import threading
import time
from opentelemetry import metrics, propagate, trace
from opentelemetry.trace import SpanKind, Status, StatusCode
SERVICE_NAME = os.environ.get("OTEL_SERVICE_NAME", "messenger-app")
SERVICE_VERSION = os.environ.get("APP_VERSION", "dev")
INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname()
ENABLED = os.environ.get("OTEL_SDK_DISABLED", "false").strip().lower() != "true"
tracer = trace.get_tracer("messenger", SERVICE_VERSION)
meter = metrics.get_meter("messenger", SERVICE_VERSION)
_setup_done = False
_setup_lock = threading.Lock()
_providers = []
# --------------------------------------------------------------------------
# Гистограммы: границы под ожидаемые задержки (секунды). p50/p95/p99 считаются в Prometheus
# из buckets (histogram_quantile), а не из средних.
# --------------------------------------------------------------------------
# 3.5 и 5.5 с — рядом с PoolTimeout (3 с) и statement_timeout (5 с): без них ответы по таймауту
# попадали в (5, 10] и p95 линейной интерполяцией показывал ~9.75 с вместо ~5 с.
HTTP_BUCKETS = (0.002, 0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.25, 0.35, 0.5, 0.75, 1.0,
1.5, 2.5, 3.5, 5.0, 5.5, 7.5, 10.0, 30.0, 60.0)
DB_BUCKETS = (0.0005, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 3.5, 5.0, 5.5,
7.5, 10.0)
JOB_BUCKETS = (0.05, 0.1, 0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 20.0, 30.0, 60.0, 120.0)
READY_BUCKETS = (0.25, 0.5, 1.0, 1.5, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 20.0, 30.0, 60.0, 120.0, 300.0,
600.0, 1800.0, 3600.0)
def _env_float(name, default):
try:
return float(os.environ.get(name, str(default)))
except ValueError:
return float(default)
def _env_int(name, default):
try:
return int(os.environ.get(name, str(default)))
except ValueError:
return int(default)
# --------------------------------------------------------------------------
# Защита от утечек в логах (defense in depth: код и так не логирует секреты/тела).
# --------------------------------------------------------------------------
_REDACT = [
(re.compile(r"(?i)\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{6,}"), r"\1 [REDACTED]"),
(re.compile(r"(?i)(authorization\s*[:=]\s*)\S+"), r"\1[REDACTED]"),
(re.compile(r"([a-z][a-z0-9+.-]*://)[^/\s:@]+:[^@\s/]+@"), r"\1[REDACTED]@"),
(re.compile(r"(?i)(password|passwd|secret|token)(\"?\s*[:=]\s*\"?)[^\s\",}]+"), r"\1\2[REDACTED]"),
(re.compile(r"(?i)(X-Amz-Signature|X-Amz-Credential|Signature)=[^&\s]+"), r"\1=[REDACTED]"),
]
def redact(text):
if not isinstance(text, str):
return text
for pattern, repl in _REDACT:
text = pattern.sub(repl, text)
return text
_STD_ATTRS = set(vars(logging.LogRecord("", 0, "", 0, "", None, None))) | {"message", "asctime", "taskName"}
class EventFilter(logging.Filter):
"""У каждой записи есть поле event (стабильное имя события) и отредактированный текст."""
def filter(self, record):
if not getattr(record, "event", None):
record.event = "log"
if record.args:
try:
record.msg = record.getMessage()
record.args = None
except Exception:
pass
record.msg = redact(record.msg)
return True
class JsonFormatter(logging.Formatter):
"""Структурный лог в stdout: timestamp, severity, service.name, event, trace_id, span_id."""
def format(self, record):
out = {
"timestamp": dt.datetime.fromtimestamp(record.created, dt.timezone.utc).isoformat(timespec="milliseconds"),
"severity": record.levelname,
"service.name": SERVICE_NAME,
"service.instance.id": INSTANCE_ID,
"logger": record.name,
"event": getattr(record, "event", "log"),
"message": record.getMessage(),
}
ctx = trace.get_current_span().get_span_context()
if ctx.is_valid:
out["trace_id"] = format(ctx.trace_id, "032x")
out["span_id"] = format(ctx.span_id, "016x")
for key, value in vars(record).items():
if key not in _STD_ATTRS and key not in out and not key.startswith("_") and key != "event":
out[key] = value if isinstance(value, (int, float, bool)) or value is None else redact(str(value))
if record.exc_info:
out["exception.type"] = record.exc_info[0].__name__ if record.exc_info[0] else None
out["exception.stacktrace"] = redact(self.formatException(record.exc_info))
return json.dumps(out, ensure_ascii=False)
class _NotOtelInternals(logging.Filter):
"""Логи самого SDK/экспортёра не отправляем через тот же экспортёр (иначе при недоступном
Collector каждая ошибка экспорта порождала бы новую запись в очереди экспорта)."""
def filter(self, record):
return not (record.name.startswith("opentelemetry") or record.name.startswith("urllib3.connectionpool"))
def configure_logging(stream=None):
root = logging.getLogger()
for h in list(root.handlers):
root.removeHandler(h)
handler = logging.StreamHandler(stream or sys.stdout)
handler.setFormatter(JsonFormatter())
handler.addFilter(EventFilter())
root.addHandler(handler)
root.setLevel(logging.INFO)
logging.getLogger("pika").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
return handler
# --------------------------------------------------------------------------
# Настройка SDK
# --------------------------------------------------------------------------
def setup(service_name=None):
"""Идемпотентно: логирование (stdout JSON), затем — если не выключено — провайдеры OTel."""
global _setup_done, SERVICE_NAME
with _setup_lock:
if _setup_done:
return
_setup_done = True
if service_name and not os.environ.get("OTEL_SERVICE_NAME"):
SERVICE_NAME = service_name
configure_logging()
if not ENABLED:
logging.getLogger("telemetry").info("OpenTelemetry export disabled (OTEL_SDK_DISABLED=true)",
extra={"event": "telemetry.disabled"})
return
_setup_sdk()
def _setup_sdk():
from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import Histogram, MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import ExplicitBucketHistogramAggregation, View
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
# Resource.create() добавляет OTEL_RESOURCE_ATTRIBUTES (deployment.environment.name=lab)
# и атрибуты telemetry.sdk.*; явные значения ниже важнее.
resource = Resource.create({
"service.name": SERVICE_NAME,
"service.version": SERVICE_VERSION,
"service.instance.id": INSTANCE_ID,
})
if "deployment.environment.name" not in resource.attributes:
resource = resource.merge(Resource({"deployment.environment.name": os.environ.get("APP_ENV", "lab")}))
timeout = _env_float("OTEL_EXPORTER_OTLP_TIMEOUT_SECONDS", 5)
def views():
out = []
for name, buckets in (("http.server.request.duration", HTTP_BUCKETS),
("db.client.operation.duration", DB_BUCKETS),
("db.client.connection.wait_time", DB_BUCKETS),
("messenger.s3.operation.duration", DB_BUCKETS),
("messenger.job.duration", JOB_BUCKETS),
("messenger.job.queue_wait", READY_BUCKETS),
("messenger.attachment.time_to_ready", READY_BUCKETS),
("messenger.outbox.publish_delay", READY_BUCKETS)):
out.append(View(instrument_type=Histogram, instrument_name=name,
aggregation=ExplicitBucketHistogramAggregation(buckets)))
return out
# 1) Метрики первыми: их meter_provider получают процессоры/экспортёры других сигналов
# и считают собственные потери (queue_full, ошибки экспорта).
metric_exporter = OTLPMetricExporter(timeout=timeout)
reader = PeriodicExportingMetricReader(
metric_exporter,
export_interval_millis=_env_int("OTEL_METRIC_EXPORT_INTERVAL", 10000),
export_timeout_millis=_env_int("OTEL_METRIC_EXPORT_TIMEOUT", 5000))
meter_provider = MeterProvider(resource=resource, metric_readers=[reader], views=views())
metrics.set_meter_provider(meter_provider)
# 2) Трассы. Сэмплер по умолчанию parentbased_always_on; меняется OTEL_TRACES_SAMPLER(_ARG).
tracer_provider = TracerProvider(resource=resource)
tracer_provider.add_span_processor(BatchSpanProcessor(
OTLPSpanExporter(timeout=timeout, meter_provider=meter_provider),
max_queue_size=_env_int("OTEL_BSP_MAX_QUEUE_SIZE", 2048),
schedule_delay_millis=_env_int("OTEL_BSP_SCHEDULE_DELAY", 1000),
max_export_batch_size=_env_int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", 512),
export_timeout_millis=_env_int("OTEL_BSP_EXPORT_TIMEOUT", 5000),
meter_provider=meter_provider))
trace.set_tracer_provider(tracer_provider)
# 3) Логи: тот же формат событий (event, request_id, ...) как атрибуты записи; trace_id/span_id
# берутся из текущего контекста автоматически.
logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(
OTLPLogExporter(timeout=timeout, meter_provider=meter_provider),
max_queue_size=_env_int("OTEL_BLRP_MAX_QUEUE_SIZE", 2048),
schedule_delay_millis=_env_int("OTEL_BLRP_SCHEDULE_DELAY", 1000),
max_export_batch_size=_env_int("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE", 512),
export_timeout_millis=_env_int("OTEL_BLRP_EXPORT_TIMEOUT", 5000),
meter_provider=meter_provider))
set_logger_provider(logger_provider)
otel_handler = LoggingHandler(level=logging.INFO, logger_provider=logger_provider)
otel_handler.addFilter(EventFilter())
otel_handler.addFilter(_NotOtelInternals())
logging.getLogger().addHandler(otel_handler)
_providers.extend([tracer_provider, logger_provider, meter_provider])
_register_resource_gauges()
logging.getLogger("telemetry").info(
"OpenTelemetry enabled endpoint=%s protocol=%s", os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", "-"),
os.environ.get("OTEL_EXPORTER_OTLP_PROTOCOL", "http/protobuf"), extra={"event": "telemetry.enabled"})
def shutdown(timeout_millis=3000):
"""Сбросить буферы при штатной остановке. Общий срок timeout_millis на ВСЕ провайдеры:
при недоступном Collector экспортёр повторяет попытки, и без срока остановка API
затянулась бы дольше stop_grace_period (замер: ~14 с без ограничения)."""
providers = list(_providers)
_providers.clear()
threads = []
for p in providers:
t = threading.Thread(target=_quiet_shutdown, args=(p,), daemon=True)
t.start()
threads.append(t)
deadline = time.monotonic() + timeout_millis / 1000.0
for t in threads:
t.join(max(0.0, deadline - time.monotonic()))
def _quiet_shutdown(provider):
try:
provider.shutdown()
except Exception:
pass
# --------------------------------------------------------------------------
# Ресурсы контейнера/процесса (cgroup v2 своего контейнера, /proc/self): saturation CPU/RAM.
# Включают подпроцессы (проба JPEG в API, transform в worker).
# --------------------------------------------------------------------------
def _read(path):
try:
with open(path, encoding="ascii") as f:
return f.read().strip()
except OSError:
return None
def _cgroup_cpu_seconds():
raw = _read("/sys/fs/cgroup/cpu.stat")
if not raw:
return None
for line in raw.splitlines():
k, _, v = line.partition(" ")
if k == "usage_usec":
return int(v) / 1e6
return None
def _cgroup_cpu_limit():
raw = _read("/sys/fs/cgroup/cpu.max")
if not raw:
return None
quota, _, period = raw.partition(" ")
if quota == "max":
return float(os.cpu_count() or 1)
return int(quota) / int(period or 100000)
def _process_rss_bytes():
raw = _read("/proc/self/status")
if raw:
for line in raw.splitlines():
if line.startswith("VmRSS:"):
return int(line.split()[1]) * 1024
return None
def _register_resource_gauges():
def cpu_time(options):
v = _cgroup_cpu_seconds()
if v is not None:
yield metrics.Observation(v)
def mem_usage(options):
v = _read("/sys/fs/cgroup/memory.current")
if v and v.isdigit():
yield metrics.Observation(int(v))
def mem_limit(options):
v = _read("/sys/fs/cgroup/memory.max")
if v and v.isdigit():
yield metrics.Observation(int(v))
def cpu_limit(options):
v = _cgroup_cpu_limit()
if v is not None:
yield metrics.Observation(v)
def rss(options):
v = _process_rss_bytes()
if v is not None:
yield metrics.Observation(v)
def threads(options):
yield metrics.Observation(threading.active_count())
meter.create_observable_counter("container.cpu.time", [cpu_time], unit="s",
description="CPU time of this container (cgroup v2 cpu.stat usage_usec)")
meter.create_observable_gauge("container.memory.usage", [mem_usage], unit="By",
description="Memory of this container (cgroup v2 memory.current)")
meter.create_observable_gauge("container.memory.limit", [mem_limit], unit="By",
description="Memory limit of this container (cgroup v2 memory.max)")
meter.create_observable_gauge("container.cpu.limit", [cpu_limit], unit="{cpu}",
description="CPU quota of this container in cores (cgroup v2 cpu.max)")
meter.create_observable_gauge("process.memory.usage", [rss], unit="By",
description="Resident memory of the main process (VmRSS)")
meter.create_observable_gauge("process.thread.count", [threads], unit="{thread}",
description="Python threads of the main process")
# --------------------------------------------------------------------------
# Общие инструменты
# --------------------------------------------------------------------------
DB_SYSTEM = "postgresql"
DB_NAMESPACE = os.environ.get("POSTGRES_DB", "messenger")
db_duration = meter.create_histogram(
"db.client.operation.duration", unit="s",
description="Duration of a logical database operation (pool wait included)")
db_wait = meter.create_histogram(
"db.client.connection.wait_time", unit="s",
description="Time spent waiting for a connection from the pool")
s3_duration = meter.create_histogram(
"messenger.s3.operation.duration", unit="s", description="Duration of an S3 request")
def current_trace_ids():
ctx = trace.get_current_span().get_span_context()
if not ctx.is_valid:
return None, None
return format(ctx.trace_id, "032x"), format(ctx.span_id, "016x")
def has_active_span():
return trace.get_current_span().get_span_context().is_valid
def error_type_of(exc):
return type(exc).__name__
@contextlib.contextmanager
def child_span(name, kind=SpanKind.INTERNAL, attributes=None, root=False):
"""Span только внутри уже начатой трассы (запрос/задание). Фоновые циклы (health-пинги,
heartbeat аренды, опрос outbox) без родителя трасс не порождают — только метрики."""
if not root and not has_active_span():
yield None
return
with tracer.start_as_current_span(name, kind=kind, attributes=attributes or {},
record_exception=False, set_status_on_exception=False) as span:
try:
yield span
except BaseException as exc:
span.set_attribute("error.type", error_type_of(exc))
span.set_status(Status(StatusCode.ERROR, type(exc).__name__))
raise
def db_operation(op):
"""Декоратор логической операции БД: CLIENT span «db <op>» (если есть родитель) и
гистограмма db.client.operation.duration{db.operation.name, error.type}."""
def wrap(func):
@functools.wraps(func)
def inner(*args, **kwargs):
started = time.perf_counter()
attrs = {"db.system.name": DB_SYSTEM, "db.operation.name": op}
err = None
try:
with child_span("db " + op, SpanKind.CLIENT,
dict(attrs, **{"db.namespace": DB_NAMESPACE, "server.address": "db"})):
return func(*args, **kwargs)
except BaseException as exc:
err = error_type_of(exc)
raise
finally:
if err:
attrs["error.type"] = err
db_duration.record(time.perf_counter() - started, attrs)
return inner
return wrap
def observe_pool(pool, pool_name):
"""Наблюдаемые метрики пула psycopg_pool (semantic conventions db.client.connection.*)."""
base = {"db.client.connection.pool.name": pool_name, "db.system.name": DB_SYSTEM}
def count(options):
s = pool.get_stats()
size, available = s.get("pool_size", 0), s.get("pool_available", 0)
yield metrics.Observation(max(0, size - available), dict(base, **{"db.client.connection.state": "used"}))
yield metrics.Observation(available, dict(base, **{"db.client.connection.state": "idle"}))
def maximum(options):
yield metrics.Observation(pool.get_stats().get("pool_max", 0), base)
def pending(options):
yield metrics.Observation(pool.get_stats().get("requests_waiting", 0), base)
def timeouts(options):
yield metrics.Observation(pool.get_stats().get("requests_errors", 0), base)
meter.create_observable_up_down_counter("db.client.connection.count", [count], unit="{connection}",
description="Connections in the pool by state (used/idle)")
meter.create_observable_up_down_counter("db.client.connection.max", [maximum], unit="{connection}",
description="Pool max size")
meter.create_observable_up_down_counter("db.client.connection.pending_requests", [pending],
unit="{request}", description="Requests waiting for a connection")
meter.create_observable_counter("db.client.connection.timeouts", [timeouts], unit="{timeout}",
description="Pool requests that failed (timeout waiting for a connection)")
# --------------------------------------------------------------------------
# W3C Trace Context: перенос через outbox/AMQP
# --------------------------------------------------------------------------
def inject_dict():
"""{'traceparent': ..., 'tracestate': ...} текущего контекста (пусто, если span нет)."""
carrier = {}
propagate.inject(carrier)
return {k: v for k, v in carrier.items() if k in ("traceparent", "tracestate") and v}
def extract(carrier):
return propagate.extract(carrier or {})
+128
View File
@@ -0,0 +1,128 @@
#!/usr/bin/env python3
"""Преобразование одного изображения в отдельном ПРОЦЕССЕ с жёсткими лимитами.
python transform.py <input> <output_dir> <content_type> <max_pixels>
-> stdout: JSON {"variants": [...]} ; код выхода — класс ошибки.
Worker запускает его через subprocess с таймаутом JOB_TIMEOUT_SECONDS (wall clock), а сам
процесс до импорта Pillow ограничивает себе адресное пространство (RLIMIT_AS) и CPU-время
(RLIMIT_CPU). «Бомба», которую не поймали проверки заголовка, убивает только этот процесс,
а не worker с его соединениями и арендами.
Коды выхода: 0 — успех; 3 — invalid_image; 4 — image_too_large; 5 — resource_limit
(MemoryError). Убит сигналом (SIGXCPU/SIGKILL) -> resource_limit; таймаут — решает worker.
Варианты (contracts/README.md, «Фоновая обработка»):
thumbnail — JPEG q=85, вписан в 256x256 с сохранением пропорций, без увеличения;
размеры считаются целочисленно с округлением вниз, минимум 1 px
(320x200 -> 256x160); EXIF orientation применяется; alpha -> на белый фон;
crop — JPEG q=85, центрированный квадрат 128x128 (маленькие исходники увеличиваются);
optimized — WebP q=80 method=4, вписан в 1280x1280 без увеличения; alpha сохраняется.
Во все варианты НЕ переносятся EXIF/XMP/ICC/комментарии. Одного «не передавать exif=» мало:
Pillow при save() берёт часть метаданных из im.info (так JPEG-комментарий доходил до
thumbnail и crop — аудит F07). Поэтому перед сохранением info очищается полностью, а тест
проверяет сырые байты результата (маркеры COM/APP1/APP2, чанки EXIF/XMP/ICCP).
Прозрачность: RGBA/LA/PA и ЛЮБОЙ режим с tRNS (P, RGB, L — аудит F06). Цвет считается sRGB.
"""
import json
import os
import resource
import sys
MEMORY_LIMIT_MB = int(os.environ.get("TRANSFORM_MEMORY_LIMIT_MB", "768"))
CPU_LIMIT_SECONDS = int(os.environ.get("TRANSFORM_CPU_SECONDS", "30"))
THUMB = 256
CROP = 128
OPTIMIZED = 1280
JPEG_QUALITY = 85
WEBP_QUALITY = 80
EXIT_INVALID, EXIT_TOO_LARGE, EXIT_RESOURCE = 3, 4, 5
def fit_within(w, h, box):
"""Вписать (w, h) в box x box без увеличения; целочисленно, вниз, минимум 1."""
if w <= box and h <= box:
return w, h
if w >= h:
return box, max(1, h * box // w)
return max(1, w * box // h), box
def fail(code, error, detail=""):
print(json.dumps({"error": error, "detail": detail[:200]}))
sys.stdout.flush()
os._exit(code)
def main():
src, out_dir, content_type, max_pixels = sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4])
limit = MEMORY_LIMIT_MB * 1024 * 1024
resource.setrlimit(resource.RLIMIT_AS, (limit, limit))
resource.setrlimit(resource.RLIMIT_CPU, (CPU_LIMIT_SECONDS, CPU_LIMIT_SECONDS + 1))
import warnings
from PIL import Image, ImageOps
# Больше max_pixels — ошибка, а не предупреждение (по умолчанию Pillow только warn до 2x).
Image.MAX_IMAGE_PIXELS = max_pixels
warnings.simplefilter("error", Image.DecompressionBombWarning)
fmt = {"image/png": "PNG", "image/jpeg": "JPEG"}.get(content_type)
if fmt is None:
fail(EXIT_INVALID, "invalid_image", "unsupported content type")
try:
im = Image.open(src, formats=(fmt,))
w0, h0 = im.size
if w0 * h0 > max_pixels:
fail(EXIT_TOO_LARGE, "image_too_large", "%dx%d" % (w0, h0))
orientation = im.getexif().get(0x0112, 1)
swap = orientation in (5, 6, 7, 8)
ow, oh = (h0, w0) if swap else (w0, h0) # размеры ПОСЛЕ применения EXIF orientation
if fmt == "JPEG":
# draft: декодер JPEG сразу уменьшает в 2/4/8 раз, но не меньше 1280 по обеим
# сторонам — памяти нужно в 4–64 раза меньше, качество вариантов не страдает.
im.draft("RGB", (OPTIMIZED, OPTIMIZED))
im.load()
if orientation in range(2, 9):
im = ImageOps.exif_transpose(im)
# tRNS бывает не только у палитры: у RGB и L это «прозрачный цвет» (аудит F06).
has_alpha = im.mode in ("RGBA", "LA", "PA") or "transparency" in im.info
work = im.convert("RGBA") if has_alpha else im.convert("RGB")
del im
# Промежуточная копия <= 1280: из неё делаются все варианты (экономия памяти и CPU).
mw, mh = fit_within(ow, oh, OPTIMIZED)
if work.size != (mw, mh):
work = work.resize((mw, mh), Image.LANCZOS, reducing_gap=3.0)
if has_alpha:
flat = Image.new("RGB", work.size, (255, 255, 255))
flat.paste(work, mask=work.getchannel("A"))
else:
flat = work
work.info = {} # без метаданных источника (EXIF, XMP, ICC, comment...)
flat.info = {}
variants = []
tw, th = fit_within(ow, oh, THUMB)
thumb = flat if flat.size == (tw, th) else flat.resize((tw, th), Image.LANCZOS)
path = os.path.join(out_dir, "thumbnail.jpg")
thumb.info = {}
thumb.save(path, "JPEG", quality=JPEG_QUALITY, optimize=True)
variants.append({"name": "thumbnail", "path": path, "content_type": "image/jpeg", "width": tw, "height": th})
crop = ImageOps.fit(flat, (CROP, CROP), method=Image.LANCZOS, centering=(0.5, 0.5))
crop.info = {}
path = os.path.join(out_dir, "crop.jpg")
crop.save(path, "JPEG", quality=JPEG_QUALITY, optimize=True)
variants.append({"name": "crop", "path": path, "content_type": "image/jpeg", "width": CROP, "height": CROP})
path = os.path.join(out_dir, "optimized.webp")
work.save(path, "WEBP", quality=WEBP_QUALITY, method=4)
variants.append({"name": "optimized", "path": path, "content_type": "image/webp", "width": mw, "height": mh})
except MemoryError:
fail(EXIT_RESOURCE, "resource_limit", "memory limit %d MiB" % MEMORY_LIMIT_MB)
except (Image.DecompressionBombError, Image.DecompressionBombWarning) as exc:
fail(EXIT_TOO_LARGE, "image_too_large", type(exc).__name__)
except Exception as exc:
# Битые/усечённые данные: OSError, SyntaxError, ValueError, struct.error...
fail(EXIT_INVALID, "invalid_image", type(exc).__name__)
print(json.dumps({"variants": variants, "source": [ow, oh]}))
return 0
if __name__ == "__main__":
sys.exit(main())
+620
View File
@@ -0,0 +1,620 @@
#!/usr/bin/env python3
"""Worker обработки вложений (compose-сервис `worker`, отдельный процесс от API).
WORKER_CONCURRENCY потоков-потребителей; у каждого своё соединение AMQP, prefetch=1
(не больше одного неподтверждённого сообщения на поток) и своё соединение PostgreSQL.
Итого одновременно в работе не больше WORKER_CONCURRENCY заданий на контейнер.
Обработка одного сообщения (at-least-once, ack только после устойчивого эффекта):
1. разбор по jobs.schema.json; мусор -> basic.reject(requeue=False) -> DLQ;
2. claim в транзакции (src/jobs.py): по строке jobs решаем, нужна ли работа. ready/failed,
чужая живая аренда, ранний дубль -> ack без работы. Иначе processing, attempt+1,
lease_token (fencing) и lease_until, COMMIT;
3. пока идёт работа, отдельный поток продлевает аренду (heartbeat) не дольше
JOB_TIMEOUT_SECONDS: зависший процесс аренду теряет, долгий, но живой — нет;
4. staging -> временный файл (лимит байт = size_bytes из БД, проверка SHA-256);
5. transform.py в подпроцессе (RLIMIT_AS, RLIMIT_CPU, таймаут) -> thumbnail/crop/optimized;
6. PUT оригинала и вариантов по ДЕТЕРМИНИРОВАННЫМ ключам attachments/<id>/v<ver>/<name>:
повтор перезаписывает те же объекты, второго набора не появляется;
7. complete: processing -> ready + attachment_variants одной транзакцией и только со своим
lease_token; иначе (аренду забрали) — ничего не пишем;
8. удаление staging (после COMMIT), затем ack. Крах до ack -> redelivery -> claim видит
ready -> no-op ack.
Ошибки: постоянные -> failed(error_code); временные -> queued с backoff+jitter через outbox
(relay опубликует в срок) или failed(retry_exhausted). Нет доступа к БД -> сообщение
возвращается в очередь (nack) после паузы; если так и не записалось — reaper/redrive.
Учебные отказы (WORKER_FAULT_INJECTION=1): filename вида fault-<point>.png задаёт точку:
crash-after-claim, crash-after-s3-put, crash-after-commit (os._exit один раз на job),
transient-<N> (временная ошибка в первых N попытках), transient-always (до replay),
bug (непредусмотренное исключение в 1-й попытке),
slow (пауза FAULT_SLOW_SECONDS после claim, аренда продлевается).
Lab6 (src/telemetry.py):
* каждое сообщение — CONSUMER span «attachments.process.v1 process», родитель — контекст
из AMQP headers (traceparent от relay «send»), запасной вариант — поля traceparent/tracestate
тела (jobs.schema.json). Внутри: db jobs.claim, worker.fetch_staging (s3 GetObject),
worker.transform (подпроцесс), s3 PutObject x4, db jobs.complete, s3 DeleteObject staging;
* метрики: messenger.jobs.processed{messenger.job.type, messenger.job.outcome, error.type},
messenger.job.duration{type, outcome} (s, от claim до итога), messenger.job.queue_wait (s, от
next_attempt_at до claim), messenger.attachment.time_to_ready{outcome} (s, от durable acceptance
= jobs.created_at до COMMIT ready/failed), messenger.worker.busy / messenger.worker.capacity
(мгновенно) и messenger.worker.busy_time (s, счётчик: rate/capacity = точная загрузка).
"""
import concurrent.futures
import hashlib
import json
import logging
import os
import shutil
import signal
import subprocess
import sys
import tempfile
import threading
import time
import psycopg
from psycopg.rows import dict_row
import common
import jobs
import objstore
import telemetry
from objstore import ObjectMissing, StorageUnavailable
from telemetry import SpanKind, Status, StatusCode
log = logging.getLogger("worker")
CONCURRENCY = common.env_int("WORKER_CONCURRENCY", 2)
PREFETCH = common.env_int("WORKER_PREFETCH", 1)
LEASE_SECONDS = common.env_int("JOB_LEASE_SECONDS", 30)
JOB_TIMEOUT = common.env_float("JOB_TIMEOUT_SECONDS", 60)
RETRY_BASE = common.env_float("JOB_RETRY_BASE_SECONDS", 2)
RETRY_MAX = common.env_float("JOB_RETRY_MAX_SECONDS", 60)
MAX_UPLOAD_BYTES = common.env_int("MAX_UPLOAD_BYTES", 10485760)
MAX_IMAGE_PIXELS = common.env_int("MAX_IMAGE_PIXELS", 40000000)
REQUEUE_PAUSE = common.env_float("WORKER_REQUEUE_PAUSE_SECONDS", 2)
WORK_DIR = os.environ.get("WORKER_TMP_DIR") or None
FAULT_INJECTION = os.environ.get("WORKER_FAULT_INJECTION", "0") == "1"
FAULT_SLOW_SECONDS = common.env_float("FAULT_SLOW_SECONDS", 20)
TRANSFORM = os.path.join(os.path.dirname(os.path.abspath(__file__)), "transform.py")
HEARTBEAT = "/tmp/worker.heartbeat"
EXT = {"image/jpeg": "jpg", "image/webp": "webp", "image/png": "png"}
TRANSFORM_ERRORS = {3: "invalid_image", 4: "image_too_large", 5: "resource_limit"}
OBJ = objstore.ObjectStore(objstore.make_client(), os.environ.get("S3_BUCKET", "messenger-attachments"))
STOP = threading.Event()
# --- Lab6: метрики worker ---
_m = telemetry.meter
JOBS_PROCESSED = _m.create_counter("messenger.jobs.processed", unit="{job}",
description="Job messages handled by the worker, by outcome")
JOB_DURATION = _m.create_histogram("messenger.job.duration", unit="s",
description="Processing time of a claimed job attempt (claim -> outcome)")
QUEUE_WAIT = _m.create_histogram("messenger.job.queue_wait", unit="s",
description="Time a due job waited before a worker claimed it")
TIME_TO_READY = _m.create_histogram("messenger.attachment.time_to_ready", unit="s",
description="From durable acceptance (enqueue COMMIT) to ready/failed COMMIT")
BUSY_TIME = _m.create_counter("messenger.worker.busy_time", unit="s",
description="Cumulative consumer time spent handling messages (utilization = rate / capacity)")
_BUSY = [0]
_BUSY_LOCK = threading.Lock()
def _busy(delta):
with _BUSY_LOCK:
_BUSY[0] += delta
_m.create_observable_gauge("messenger.worker.busy", [lambda o: [telemetry.metrics.Observation(_BUSY[0])]],
unit="{consumer}", description="Consumers currently processing a job")
_m.create_observable_gauge("messenger.worker.capacity", [lambda o: [telemetry.metrics.Observation(CONCURRENCY)]],
unit="{consumer}", description="Configured consumer threads (WORKER_CONCURRENCY)")
JOB_ATTRS = {"messenger.job.type": jobs.JOB_TYPE}
class JobError(Exception):
def __init__(self, code, detail=""):
super().__init__(code)
self.code = code
self.detail = detail
class LeaseLost(Exception):
pass
class Lease:
"""Продление аренды отдельным соединением раз в LEASE_SECONDS/3, но не дольше единого
срока задания (JOB_TIMEOUT_SECONDS от claim): после него аренда больше не продлевается
и reaper вернёт задание в очередь, даже если процесс жив, но завис.
Аудит F13: срок — общий бюджет на чтение staging -> transform -> запись результатов.
check() перед каждым шагом с побочным эффектом прерывает задание, если срок вышел
(processing_timeout, обычный retry), и больше не продлевает аренду после срока."""
def __init__(self, conninfo, job, deadline):
self.conninfo = conninfo
self.job = job
self.lost = False
self.deadline = deadline
self._stop = threading.Event()
self._thread = threading.Thread(target=self._loop, daemon=True)
def __enter__(self):
self._thread.start()
return self
def __exit__(self, *exc):
self._stop.set()
self._thread.join(timeout=5)
def left(self):
return self.deadline - time.monotonic()
def check(self, conn=None):
"""Перед каждым побочным эффектом: флаг фонового heartbeat И синхронная проверка
(продление) аренды в БД. Иначе замороженный процесс после разморозки успел бы
сделать шаг до того, как фоновый поток заметит потерю аренды."""
if self.lost:
raise LeaseLost()
if self.left() <= 0:
raise JobError("processing_timeout", "job deadline %.0fs exceeded" % JOB_TIMEOUT)
if conn is not None:
with conn.transaction():
ok = jobs.heartbeat(conn, self.job["job_id"], self.job["lease_token"], LEASE_SECONDS)
if not ok:
self.lost = True
raise LeaseLost()
def _loop(self):
conn = None
while not self._stop.wait(max(1.0, LEASE_SECONDS / 3)):
if time.monotonic() > self.deadline:
log.warning("job %s exceeded hard deadline, lease is no longer renewed", self.job["job_id"],
extra={"event": "job.deadline_exceeded", "job_id": str(self.job["job_id"])})
return
try:
if conn is None or conn.closed:
conn = psycopg.connect(self.conninfo, autocommit=True)
if not jobs.heartbeat(conn, self.job["job_id"], self.job["lease_token"], LEASE_SECONDS):
self.lost = True
log.warning("lease lost for job %s", self.job["job_id"],
extra={"event": "job.lease_lost", "job_id": str(self.job["job_id"])})
return
except psycopg.Error as exc:
log.warning("lease heartbeat failed (%s)", type(exc).__name__,
extra={"event": "job.heartbeat_failed", "error.type": type(exc).__name__})
conn = None
if conn is not None:
conn.close()
def sha256_file(path):
h = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(1024 * 1024), b""):
h.update(chunk)
return h.hexdigest()
class Consumer(threading.Thread):
def __init__(self, index):
super().__init__(name="consumer-%d" % index, daemon=True)
self.conninfo = common.database_conninfo()
self.db = None
self.last_beat = time.monotonic()
self.pool = concurrent.futures.ThreadPoolExecutor(max_workers=1)
# ------------------------------------------------------------------ AMQP
def run(self):
while not STOP.is_set():
conn = common.connect_broker(log, STOP)
if conn is None:
return
try:
ch = conn.channel()
ch.basic_qos(prefetch_count=PREFETCH)
log.info("%s consuming %s owner=%s", self.name, common.QUEUE, common.OWNER,
extra={"event": "worker.consuming"})
for method, props, body in ch.consume(common.QUEUE, inactivity_timeout=1):
self.last_beat = time.monotonic()
if STOP.is_set():
break
if method is None:
continue
outcome = self.run_job(conn, body, getattr(props, "headers", None) or {},
bool(getattr(method, "redelivered", False)))
if outcome == "ack":
ch.basic_ack(method.delivery_tag)
elif outcome == "reject":
ch.basic_reject(method.delivery_tag, requeue=False) # -> DLX -> DLQ
else:
self.pause(conn, REQUEUE_PAUSE)
ch.basic_nack(method.delivery_tag, requeue=True)
ch.cancel()
conn.close()
except Exception as exc:
log.warning("%s broker loop error (%s), reconnecting", self.name, type(exc).__name__,
extra={"event": "broker.loop_error", "error.type": type(exc).__name__})
try:
conn.close()
except Exception:
pass
STOP.wait(1)
def pause(self, conn, seconds):
end = time.monotonic() + seconds
while time.monotonic() < end:
conn.process_data_events(time_limit=min(0.5, end - time.monotonic()))
self.last_beat = time.monotonic()
def run_job(self, conn, body, headers=None, redelivered=False):
"""Работа в отдельном потоке; этот поток обслуживает heartbeat AMQP-соединения."""
future = self.pool.submit(self.traced_message, body, headers or {}, redelivered)
# Lab6 (найдено по метрикам инцидента 1): process_data_events(time_limit=0.5) ждал полные
# 0.5 с и после конца задания — потребитель брал не больше 2 заданий/с (utilization 41 %).
# Пустой threadsafe-callback по завершении будит цикл AMQP сразу.
future.add_done_callback(lambda _f: conn.add_callback_threadsafe(lambda: None))
while not future.done():
conn.process_data_events(time_limit=0.5)
self.last_beat = time.monotonic()
try:
return future.result()
except Exception:
log.exception("unexpected worker error", extra={"event": "worker.unexpected_error"})
return "requeue"
# ------------------------------------------------------------------ DB
def database(self):
if self.db is None or self.db.closed:
self.db = psycopg.connect(self.conninfo, row_factory=dict_row)
return self.db
def drop_db(self):
try:
if self.db is not None:
self.db.close()
except Exception:
pass
self.db = None
# ------------------------------------------------------------------ job
@staticmethod
def _parent_context(body, headers):
carrier = {}
for key in ("traceparent", "tracestate"):
value = headers.get(key)
if isinstance(value, bytes):
value = value.decode("ascii", "replace")
if isinstance(value, str) and value:
carrier[key] = value
if "traceparent" not in carrier:
try:
raw = json.loads(body.decode("utf-8"))
for key in ("traceparent", "tracestate"):
if isinstance(raw.get(key), str):
carrier[key] = raw[key]
except Exception:
pass
return telemetry.extract(carrier)
def traced_message(self, body, headers, redelivered):
"""CONSUMER span вокруг обработки + метрики исхода. res['outcome'] заполняет обработка."""
res = {"outcome": "unknown", "error": None}
span = telemetry.tracer.start_span(
"%s process" % common.QUEUE, kind=SpanKind.CONSUMER, context=self._parent_context(body, headers),
attributes={"messaging.system": "rabbitmq", "messaging.operation.type": "process",
"messaging.operation.name": "process", "messaging.destination.name": common.QUEUE,
"messaging.rabbitmq.destination.routing_key": common.ROUTING_KEY,
"messaging.message.body.size": len(body), "messaging.message.redelivered": redelivered,
"messenger.worker.owner": common.OWNER})
_busy(1)
busy_started = time.perf_counter()
try:
with telemetry.trace.use_span(span, end_on_exit=False):
action = self.process_message(body, res, span)
return action
except BaseException as exc:
res["outcome"], res["error"] = "crashed", type(exc).__name__
span.record_exception(exc)
raise
finally:
_busy(-1)
BUSY_TIME.add(time.perf_counter() - busy_started)
span.set_attribute("messenger.job.outcome", res["outcome"])
attrs = dict(JOB_ATTRS, **{"messenger.job.outcome": res["outcome"]})
if res["error"]:
attrs["error.type"] = res["error"]
span.set_attribute("error.type", res["error"])
if res["outcome"] in ("failed", "rejected", "requeued", "crashed"):
span.set_status(Status(StatusCode.ERROR, res["error"] or res["outcome"]))
JOBS_PROCESSED.add(1, attrs)
span.end()
def process_message(self, body, res=None, span=None):
res = res if res is not None else {}
try:
msg = jobs.parse_message(body)
except jobs.InvalidMessage as exc:
log.warning("invalid message rejected to DLQ (%s)", exc,
extra={"event": "job.rejected", "reason": str(exc)})
res.update(outcome="rejected", error="invalid_message")
return "reject"
if span is not None:
span.set_attribute("messaging.message.id", "%s:%s" % (msg["job_id"], msg["attempt"]))
span.set_attribute("messenger.job.id", msg["job_id"])
span.set_attribute("messenger.attachment.id", msg["attachment_id"])
span.set_attribute("messenger.job.message_attempt", msg["attempt"])
try:
db = self.database()
with db.transaction():
action, job = jobs.claim(db, msg, common.OWNER, LEASE_SECONDS)
except psycopg.Error as exc:
log.warning("claim failed, message requeued (%s)", type(exc).__name__,
extra={"event": "job.requeued", "error.type": type(exc).__name__, "job_id": msg["job_id"]})
self.drop_db()
res.update(outcome="requeued", error="db_unavailable")
return "requeue"
if action == "reject":
log.warning("message for job %s rejected to DLQ (%s)", msg["job_id"], job,
extra={"event": "job.rejected", "job_id": msg["job_id"], "reason": str(job)})
res.update(outcome="rejected", error=str(job))
return "reject"
if action == "ack":
res.update(outcome="duplicate")
return "ack"
QUEUE_WAIT.record(float(job.get("eligible_wait_s") or 0.0), JOB_ATTRS)
if span is not None:
span.set_attribute("messenger.job.attempt", job["attempt"])
span.set_attribute("messenger.job.queue_wait_s", round(float(job.get("eligible_wait_s") or 0.0), 3))
log.info("job %s attempt %d claimed (attachment %s)", job["job_id"], job["attempt"], job["attachment_id"],
extra={"event": "job.claimed", "job_id": str(job["job_id"]),
"attachment_id": str(job["attachment_id"]), "attempt": job["attempt"]})
started = time.perf_counter()
try:
return self.execute(db, job, res)
except psycopg.Error as exc:
# Результат не записан; аренда истечёт, reaper вернёт задание. Сообщение — назад.
log.warning("database error during job %s (%s)", job["job_id"], type(exc).__name__,
extra={"event": "job.requeued", "job_id": str(job["job_id"]), "error.type": type(exc).__name__})
self.drop_db()
res.update(outcome="requeued", error="db_unavailable")
return "requeue"
finally:
JOB_DURATION.record(time.perf_counter() - started,
dict(JOB_ATTRS, **{"messenger.job.outcome": res.get("outcome", "unknown")}))
def fault_point(self, job):
if not FAULT_INJECTION:
return None
name = job["filename"] or ""
if not name.startswith("fault-"):
return None
return name[len("fault-"):].rsplit(".", 1)[0]
def crash_once(self, db, job, point, wanted):
if point != wanted:
return
with db.transaction():
seen = db.execute(
"""SELECT 1 FROM job_events WHERE job_id = %s AND event = 'fault_injected'
AND detail->>'point' = %s""", (job["job_id"], point)).fetchone()
if seen:
return
jobs.add_event(db, job["job_id"], "fault_injected", job["attempt"], common.OWNER, {"point": point})
log.warning("FAULT INJECTION %s job=%s: process exits now", point, job["job_id"],
extra={"event": "fault.injected", "fault.point": point, "job_id": str(job["job_id"])})
telemetry.shutdown(1000) # успеть отправить spans/logs до «краха» (учебный сценарий)
os._exit(86)
def execute(self, db, job, res=None):
res = res if res is not None else {}
point = self.fault_point(job)
started = time.monotonic()
with Lease(self.conninfo, job, started + JOB_TIMEOUT) as lease:
try:
self.crash_once(db, job, point, "crash-after-claim")
if point == "slow" and job["attempt"] == 1:
log.warning("FAULT INJECTION slow job=%s sleeping %.0fs", job["job_id"], FAULT_SLOW_SECONDS)
time.sleep(FAULT_SLOW_SECONDS)
if point == "bug" and job["attempt"] == 1:
raise RuntimeError("injected programming error")
if point and point.startswith("transient-"):
n = point.split("-", 1)[1]
if (n == "always" and job["replay_count"] == 0) or (n.isdigit() and job["attempt"] <= int(n)):
raise JobError("storage_unavailable", "injected transient error")
lease.check(db)
variants = self.do_work(db, job, lease)
self.crash_once(db, job, point, "crash-after-s3-put")
lease.check(db)
except LeaseLost:
with db.transaction():
jobs.add_event(db, job["job_id"], "aborted_lease_lost", job["attempt"], common.OWNER)
res.update(outcome="lease_lost")
log.warning("job %s attempt %d: lease lost, work aborted", job["job_id"], job["attempt"],
extra={"event": "job.lease_lost", "job_id": str(job["job_id"]), "attempt": job["attempt"]})
return "ack"
except JobError as err:
with db.transaction():
result, delay = jobs.fail_or_retry(db, job, err.code, err.detail, common.OWNER,
RETRY_BASE, RETRY_MAX)
res.update(outcome=result, error=err.code)
self._record_terminal(job, result)
log.warning("job %s attempt %d: %s (%s) -> %s%s", job["job_id"], job["attempt"], err.code,
err.detail, result, " in %.1fs" % delay if delay else "",
extra={"event": "job.retry_scheduled" if result == "retry" else "job." + result,
"job_id": str(job["job_id"]), "attempt": job["attempt"],
"error_code": err.code, "retry_delay_s": round(delay or 0, 3)})
return "ack"
except psycopg.Error:
raise # нет БД: сообщение назад в очередь (process_message)
except Exception as exc:
# Непредусмотренная ошибка (баг, неожиданный вывод transform): временная ошибка
# с обычным retry/backoff, а не «висящее» processing до истечения аренды.
log.exception("job %s attempt %d: unexpected error", job["job_id"], job["attempt"],
extra={"event": "job.unexpected_error", "job_id": str(job["job_id"]),
"attempt": job["attempt"]})
with db.transaction():
result, delay = jobs.fail_or_retry(db, job, "processing_failed", type(exc).__name__,
common.OWNER, RETRY_BASE, RETRY_MAX)
res.update(outcome=result, error="processing_failed")
self._record_terminal(job, result)
return "ack"
with db.transaction():
result = jobs.complete(db, job, variants, common.OWNER)
res.update(outcome=result)
self._record_terminal(job, result)
self.crash_once(db, job, point, "crash-after-commit")
log.info("job %s attempt %d -> %s in %.0fms", job["job_id"], job["attempt"], result,
(time.monotonic() - started) * 1000,
extra={"event": "job.completed" if result == "ready" else "job." + result,
"job_id": str(job["job_id"]), "attachment_id": str(job["attachment_id"]),
"attempt": job["attempt"], "duration_ms": round((time.monotonic() - started) * 1000, 1),
"time_to_ready_s": round(job.get("time_to_ready_s") or 0.0, 3)})
if result == "ready":
self.cleanup_staging(db, job)
return "ack"
@staticmethod
def _record_terminal(job, result):
if result == "ready" and job.get("time_to_ready_s") is not None:
TIME_TO_READY.record(job["time_to_ready_s"], dict(JOB_ATTRS, outcome="ready"))
elif result == "failed" and job.get("time_to_terminal_s") is not None:
TIME_TO_READY.record(job["time_to_terminal_s"], dict(JOB_ATTRS, outcome="failed"))
def cleanup_staging(self, db, job):
"""Staging удаляется только после COMMIT ready. Не вышло — доберёт janitor."""
key = job["staging_key"]
if not key:
return
try:
OBJ.delete(key)
except StorageUnavailable:
log.warning("staging cleanup postponed for %s", job["attachment_id"],
extra={"event": "staging.cleanup_postponed", "attachment_id": str(job["attachment_id"])})
return
with db.transaction():
db.execute("UPDATE attachments SET staging_key = NULL WHERE id = %s AND status = 'ready'",
(job["attachment_id"],))
jobs.add_event(db, job["job_id"], "staging_deleted", job["attempt"], common.OWNER)
def do_work(self, db, job, lease):
tmpdir = tempfile.mkdtemp(prefix="job-", dir=WORK_DIR)
try:
src = os.path.join(tmpdir, "source")
with telemetry.child_span("worker.fetch_staging", attributes={"messenger.size_bytes": job["size_bytes"]}):
self.fetch_staging(job, src, lease)
lease.check(db)
with telemetry.child_span("worker.transform", attributes={
"messenger.content_type": job["content_type"], "messenger.pipeline_version": job["pipeline_version"],
"messenger.image.pixels": (job["width"] or 0) * (job["height"] or 0)}):
produced = self.transform(job, src, tmpdir, lease)
lease.check(db) # последняя проверка перед записью в конечный prefix
ver = job["pipeline_version"]
base = "attachments/%s/v%d/" % (job["attachment_id"], ver)
if job["object_key"] != base + "original":
raise JobError("staging_corrupted", "unexpected object key")
variants = []
for v in produced:
path = v["path"]
variants.append({"name": v["name"], "key": base + "%s.%s" % (v["name"], EXT[v["content_type"]]),
"content_type": v["content_type"], "width": v["width"], "height": v["height"],
"size_bytes": os.path.getsize(path), "sha256": sha256_file(path), "path": path})
try:
# Сначала все объекты, потом COMMIT в БД: ready никогда не ссылается на
# отсутствующий объект. Ключи детерминированы — повтор перезаписывает их же.
with open(src, "rb") as f:
OBJ.put(job["object_key"], f, job["size_bytes"], job["content_type"])
for v in variants:
with open(v["path"], "rb") as f:
OBJ.put(v["key"], f, v["size_bytes"], v["content_type"])
except StorageUnavailable:
raise JobError("storage_unavailable", "put result")
return variants
finally:
shutil.rmtree(tmpdir, ignore_errors=True)
def fetch_staging(self, job, path, lease):
key = job["staging_key"]
if not key:
raise JobError("staging_missing", "staging already removed")
limit = min(job["size_bytes"], MAX_UPLOAD_BYTES)
try:
resp = OBJ.open(key)
except ObjectMissing:
raise JobError("staging_missing", "no staging object")
except StorageUnavailable:
raise JobError("storage_unavailable", "get staging")
h = hashlib.sha256()
size = 0
try:
with open(path, "wb") as f:
for chunk in resp.stream(objstore.STREAM_CHUNK):
if lease.left() <= 0: # медленный S3 не растягивает задание сверх срока
raise JobError("processing_timeout", "staging read exceeded job deadline")
size += len(chunk)
if size > limit:
raise JobError("staging_corrupted", "staging larger than metadata")
h.update(chunk)
f.write(chunk)
except JobError:
raise
except Exception as exc:
raise JobError("storage_unavailable", "read staging: %s" % type(exc).__name__)
finally:
resp.close()
resp.release_conn()
if size != job["size_bytes"] or h.hexdigest() != job["sha256"]:
raise JobError("staging_corrupted", "size/sha256 differ from accepted upload")
def transform(self, job, src, tmpdir, lease):
out = os.path.join(tmpdir, "out")
os.mkdir(out)
left = lease.left()
if left <= 0: # бюджет исчерпан — transform даже не запускаем (аудит F13)
raise JobError("processing_timeout", "no time left for transform")
try:
proc = subprocess.run(
[sys.executable, TRANSFORM, src, out, job["content_type"], str(MAX_IMAGE_PIXELS)],
capture_output=True, timeout=left, check=False)
except subprocess.TimeoutExpired:
raise JobError("processing_timeout", "transform exceeded %.0fs" % left)
if proc.returncode < 0:
raise JobError("resource_limit", "transform killed by signal %d" % -proc.returncode)
if proc.returncode in TRANSFORM_ERRORS:
raise JobError(TRANSFORM_ERRORS[proc.returncode], proc.stdout.decode(errors="replace")[:200])
if proc.returncode != 0:
raise JobError("processing_failed", "transform exit %d" % proc.returncode)
result = json.loads(proc.stdout)
names = sorted(v["name"] for v in result["variants"])
if names != sorted(jobs.VARIANT_NAMES):
raise JobError("processing_failed", "unexpected variants")
return result["variants"]
def main():
telemetry.setup("messenger-worker")
signal.signal(signal.SIGTERM, lambda *_: STOP.set())
signal.signal(signal.SIGINT, lambda *_: STOP.set())
log.info("worker starting owner=%s concurrency=%d prefetch=%d lease=%ds timeout=%.0fs fault_injection=%s",
common.OWNER, CONCURRENCY, PREFETCH, LEASE_SECONDS, JOB_TIMEOUT, FAULT_INJECTION,
extra={"event": "worker.started"})
consumers = [Consumer(i) for i in range(CONCURRENCY)]
for c in consumers:
c.start()
while not STOP.is_set():
# healthcheck: файл обновляется, только пока все потребители живы и не зависли.
if all(c.is_alive() and time.monotonic() - c.last_beat < 30 for c in consumers):
common.touch(HEARTBEAT)
STOP.wait(2)
log.info("SIGTERM: finishing in-flight jobs", extra={"event": "worker.draining"})
for c in consumers:
c.join(timeout=JOB_TIMEOUT + 30)
log.info("worker stopped", extra={"event": "worker.stopped"})
telemetry.shutdown()
return 0
if __name__ == "__main__":
sys.exit(main())
+161
View File
@@ -0,0 +1,161 @@
#!/usr/bin/env python3
"""Регрессии по внешнему аудиту (HTTP-уровень): F02, F05, F08, F09, F17.
python3 student-tests/api_negative_lab5.py --output evidence/api-negative-lab5.json
F08 непарный суррогат (JSON "\\ud800") в display_name / password / title / text -> 400, не 500;
то же в filename (%ED%A0%80 — невалидный UTF-8) -> 400
F17 HEAD / OPTIONS / неизвестный метод -> 405 JSON с X-Request-Id и X-Instance-Id (у HEAD без тела)
F05 PNG с байтом фильтра 5 и 255, interlaced PNG с плохим фильтром -> 415, строка не создана
F09 объект ready-вложения испорчен в S3 (та же длина) -> content 503, а не 200 с чужими байтами
F02 4 progressive 4:4:4 + 1 progressive 4:2:0 + 1 baseline JPEG ~40 Мпикс одновременно -> все 202
и ready; RestartCount/OOMKilled реплик API не изменились
"""
import argparse
import http.client
import json
import struct
import subprocess
import uuid
import zlib
from urllib.parse import urlsplit
from lab5lib import (Client, Log, SAMPLE_PNG, check, compose, container_ids, ops, sql, upload, wait_status)
def api_state():
out = {}
for cid in container_ids("api"):
r = subprocess.run(["docker", "inspect", "-f", "{{.Name}} {{.RestartCount}} {{.State.OOMKilled}}", cid],
capture_output=True, text=True).stdout.split()
out[r[0].lstrip("/")] = {"restarts": int(r[1]), "oom_killed": r[2] == "true"}
return out
def raw(base, method, path, body=None, headers=None):
u = urlsplit(base)
conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=15)
conn.request(method, path, body=body, headers=headers or {})
r = conn.getresponse()
data = r.read()
conn.close()
return r.status, dict((k.lower(), v) for k, v in r.getheaders()), data
def png(w, h, raw_rows, interlace=0):
def chunk(k, d):
return struct.pack(">I", len(d)) + k + d + struct.pack(">I", zlib.crc32(k + d) & 0xFFFFFFFF)
return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, interlace))
+ chunk(b"IDAT", zlib.compress(raw_rows)) + chunk(b"IEND", b""))
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--output")
args = p.parse_args()
log = Log("audit regressions: unicode, protocol errors, PNG filters, download integrity, progressive JPEG")
c = Client(args.base_url, timeout=60)
alice, bob, _eve, chat = c.bootstrap()
res = {}
# --- F08 -------------------------------------------------------------------------
bad = '"\\ud800"'
cases = {
"display_name": ("/api/v1/users", None,
'{"username":"u_%s","display_name":%s,"password":"Passw0rd-long-1"}' % (uuid.uuid4().hex[:10], bad)),
"password": ("/api/v1/users", None,
'{"username":"u_%s","display_name":"x","password":%s}' % (uuid.uuid4().hex[:10], '"Passw0rd-long-\\ud800"')),
"chat title": ("/api/v1/chats", alice, '{"title":%s,"member_ids":["%s"]}' % (bad, alice["id"])),
"message text": ("/api/v1/chats/%s/messages" % chat["id"], alice, '{"text":%s}' % bad),
}
f08 = {}
for name, (path, actor, body) in cases.items():
h = {"Content-Type": "application/json", "Idempotency-Key": uuid.uuid4().hex}
if actor:
h["Authorization"] = "Bearer " + actor["token"]
st, hd, data = raw(args.base_url, "POST", path, body.encode(), h)
code = json.loads(data)["error"]["code"] if data.startswith(b"{") else None
f08[name] = {"status": st, "code": code}
check(st == 400 and code == "invalid_request", "F08 %s: %s %s" % (name, st, code))
r = c.call("POST", "/api/v1/chats/%s/attachments?filename=%%ED%%A0%%80.png" % chat["id"], 400, actor=alice,
raw=SAMPLE_PNG, headers={"Content-Type": "image/png"})
f08["filename %ED%A0%80"] = {"status": r["status"]}
res["F08"] = f08
log.step("F08 lone surrogates -> 400", **f08)
# --- F17 -------------------------------------------------------------------------
f17 = {}
for method, path in (("HEAD", "/health/live"), ("OPTIONS", "/api/v1/chats"), ("BREW", "/health/live"),
("TRACE", "/health/live")):
st, hd, data = raw(args.base_url, method, path)
item = {"status": st, "x_request_id": bool(hd.get("x-request-id")), "x_instance_id": bool(hd.get("x-instance-id")),
"content_type": hd.get("content-type"), "body_bytes": len(data)}
if method != "HEAD":
item["code"] = json.loads(data)["error"]["code"]
item["request_id_matches"] = json.loads(data)["error"]["request_id"] == hd.get("x-request-id")
check(item["request_id_matches"], "F17 request_id")
check(st == 405 and item["x_request_id"] and item["x_instance_id"], "F17 %s: %s" % (method, item))
check(method != "HEAD" or len(data) == 0, "HEAD must have no body")
f17[method] = item
res["F17"] = f17
log.step("F17 unsupported methods -> 405 JSON", **f17)
# --- F05 -------------------------------------------------------------------------
f05 = {}
import sys
sys.path.insert(0, str(__import__("lab5lib").ROOT / "src"))
import images
w, h = 13, 11
passes = images._png_passes(w, h, 24, 1)
adam = bytearray(b"".join((b"\x00" + bytes(rb - 1)) * rows for rows, rb in passes))
adam[sum(rr * bb for rr, bb in passes[:4]) + passes[4][1] * 2] = 9
samples = {"filter 5 (1x1)": png(1, 1, b"\x05\x01\x02\x03"),
"filter 255 in row 57 (10x100)": png(10, 100, b"".join((b"\xff" if i == 57 else b"\x00") + bytes(30)
for i in range(100))),
"Adam7, filter 9 in pass 5": png(w, h, bytes(adam), interlace=1)}
for name, data in samples.items():
fname = "badfilter-%s.png" % uuid.uuid4().hex[:8]
r = c.call("POST", "/api/v1/chats/%s/attachments?filename=%s" % (chat["id"], fname), 415, actor=alice,
raw=data, headers={"Content-Type": "image/png"})
rows = int(sql("SELECT count(*) FROM attachments WHERE filename = '%s'" % fname)[0][0])
check(rows == 0, "F05 row created")
f05[name] = {"status": r["status"], "bytes": len(data), "rows_created": rows}
res["F05"] = f05
log.step("F05 bad PNG filters -> 415, no job", **f05)
# --- F09 -------------------------------------------------------------------------
att = upload(c, alice, chat, SAMPLE_PNG, "integrity.png")
ready = wait_status(c, bob, att["id"], {"ready", "failed"}, 60)
check(ready["status"] == "ready", "F09 not ready")
key = ops("inspect", att["id"])["attachment"]["object_key"]
compose("--profile", "tools", "run", "--rm", "-T", "checks", "/app/student-tests/s3_tamper.py", key)
st, hd, data = raw(args.base_url, "GET", "/api/v1/attachments/%s/content" % att["id"],
headers={"Authorization": "Bearer " + bob["token"]})
thumb = c.call("GET", "/api/v1/attachments/%s/content?variant=thumbnail" % att["id"], actor=bob)
tv = [v for v in ready["variants"] if v["name"] == "thumbnail"][0]
import hashlib
res["F09"] = {"attachment_id": att["id"], "tampered_original_status": st,
"code": json.loads(data)["error"]["code"] if st >= 400 else None,
"untouched_thumbnail_status": thumb["status"],
"thumbnail_sha_ok": hashlib.sha256(thumb["bytes"]).hexdigest() == tv["sha256"]}
check(st == 503 and res["F09"]["thumbnail_sha_ok"], "F09: %s" % res["F09"])
log.step("F09 corrupted object -> 503, intact variant still 200", **res["F09"])
# --- F02 -------------------------------------------------------------------------
before = api_state()
proc = compose("--profile", "tools", "run", "--rm", "-T", "checks", "/app/student-tests/progressive_upload.py",
"--base-url", "http://lb:8080", "--output", "/app/evidence/progressive-upload.json", ok=False,
timeout=600)
after = api_state()
res["F02"] = {"checks_exit": proc.returncode, "api_before": before, "api_after": after,
"tail": proc.stdout.strip().splitlines()[-1:]}
check(proc.returncode == 0 and before == after and not any(v["oom_killed"] for v in after.values()),
"F02: %s" % res["F02"])
log.step("F02 concurrent ~40 Mpx progressive JPEG: all ready, API not restarted", **res["F02"])
log.save(args.output, results=res)
print("PASS: F02, F05, F08, F09, F17 regressions")
if __name__ == "__main__":
main()
+72
View File
@@ -0,0 +1,72 @@
#!/usr/bin/env python3
"""Upload -> остановка ИМЕННО обслужившей upload реплики -> download через другую.
python3 student-tests/attachment_failover.py [--output evidence/attachment-failover.json]
Для каждой API-реплики по очереди: загрузить файл так, чтобы его обслужила эта реплика
(round-robin LB, повторяем до попадания), остановить её scripts/stop-one.sh
(SIGTERM, контейнер остаётся остановленным), затем 5 раз скачать оригинал через LB и
проверить SHA-256 и что отвечает уже другая реплика. Восстановление — scripts/start-all.sh.
Доказывает, что на API нет обязательного локального файла оригинала.
"""
import argparse
import hashlib
import json
import os
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check # noqa: E402
CONTENT = (ROOT / "tests/fixtures/sample.png").read_bytes()
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--output")
args = ap.parse_args()
c = Client(args.base_url, timeout=30)
alice, bob, _eve, chat = c.bootstrap()
instances = set()
for _ in range(10):
instances.add(c.call("GET", "/health/ready")["headers"]["X-Instance-Id"])
check(len(instances) >= 2, "need >=2 replicas")
rounds = []
for target in sorted(instances):
for _ in range(20): # round-robin: попадаем в нужную реплику за пару попыток
r = c.call("POST", "/api/v1/chats/%s/attachments?filename=failover.png" % chat["id"], 202, actor=alice,
raw=CONTENT, headers={"Content-Type": "image/png"}, schema="Attachment")
if r["headers"]["X-Instance-Id"] == target:
break
else:
raise SystemExit("could not hit replica " + target)
att = c.wait_ready(alice, r["json"]) # lab5: 202 queued -> ждём ready, затем отказ реплики
stop = subprocess.run([str(ROOT / "scripts/stop-one.sh")], env=dict(os.environ, TARGET_INSTANCE_ID=target),
capture_output=True, text=True, timeout=60)
check(stop.returncode == 0, "stop-one failed")
downloads = []
for _ in range(5):
d = c.call("GET", "/api/v1/attachments/%s/content" % att["id"], actor=bob)
downloads.append({"instance": d["headers"]["X-Instance-Id"],
"sha256_ok": hashlib.sha256(d["bytes"]).hexdigest() == att["sha256"] == hashlib.sha256(CONTENT).hexdigest(),
"ms": round(d["elapsed"] * 1000, 1)})
meta = c.call("GET", "/api/v1/attachments/" + att["id"], actor=bob, schema="Attachment")["json"]
ok = all(x["sha256_ok"] and x["instance"] != target for x in downloads) and meta["status"] == "ready"
rounds.append({"uploaded_by": target, "stopped": target, "downloads": downloads, "pass": ok})
print(json.dumps(rounds[-1]), flush=True)
subprocess.run([str(ROOT / "scripts/start-all.sh")], capture_output=True, timeout=120, check=True)
time.sleep(4) # HAProxy: rise 2 * inter 1s
summary = {"replicas": sorted(instances), "rounds": rounds, "pass": all(r["pass"] for r in rounds)}
print(json.dumps({"pass": summary["pass"], "rounds": len(rounds)}))
if args.output:
Path(args.output).write_text(json.dumps(summary, indent=1))
return 0 if summary["pass"] else 1
if __name__ == "__main__":
sys.exit(main())
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env python3
"""Негативные и граничные сценарии вложений (из lab4; в lab5 upload -> 202, затем ready). Запуск на учебном стенде:
python3 student-tests/attachments_negative.py [--base-url http://localhost:8080] [--output evidence/attachments-negative.json]
Использует публичный tests/client.py: каждый ответ проверяется на код, X-Request-Id,
X-Instance-Id и (для ошибок) формат {"error":{code,message,request_id}}. Отдельно
проверяется, что ни один пользовательский ввод не дал 5xx. Все файлы синтетические и
генерируются на лету (большие в Git не хранятся).
"""
import argparse
import hashlib
import json
import os
import struct
import sys
import uuid
import zlib
from pathlib import Path
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check # noqa: E402
PNG = (ROOT / "tests/fixtures/sample.png").read_bytes()
JPEG = (ROOT / "student-tests/fixtures/sample.jpg").read_bytes()
MAX_BYTES = 10 * 1024 * 1024
results = []
def chunk(ctype, data):
return struct.pack(">I", len(data)) + ctype + data + struct.pack(">I", zlib.crc32(ctype + data) & 0xFFFFFFFF)
def png(width, height, raw, color_type=2, depth=8):
ihdr = struct.pack(">IIBBBBB", width, height, depth, color_type, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", raw) + chunk(b"IEND", b"")
def noise_png(target_bytes):
"""Несжимаемый RGB PNG размером чуть меньше target_bytes (zlib level 0)."""
width = 1024
row = 1 + width * 3
height = (target_bytes - 200) // (row + 6 * 0 + 1)
while True:
raw = b"".join(b"\x00" + os.urandom(width * 3) for _ in range(height))
data = png(width, height, zlib.compress(raw, 0))
if len(data) <= target_bytes:
return data
height -= 16
class Suite:
def __init__(self, c):
self.c = c
def case(self, name, method, path, expected, actor=None, **kw):
try:
r = self.c.call(method, path, expected, actor=actor, **kw)
code = r["json"]["error"]["code"] if r["json"] and "error" in r["json"] else None
results.append({"case": name, "expected": expected, "status": r["status"], "error_code": code, "pass": True})
return r
except Failure as exc:
results.append({"case": name, "expected": expected, "error": str(exc), "pass": False})
return None
def upload(self, name, actor, chat, data, expected, ctype="image/png", filename="f.png", raw_query=None):
q = raw_query if raw_query is not None else "filename=" + quote(filename, safe="")
return self.case(name, "POST", "/api/v1/chats/%s/attachments?%s" % (chat["id"], q), expected,
actor=actor, raw=data, headers={"Content-Type": ctype},
schema="Attachment" if expected == 202 else None)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--output")
args = ap.parse_args()
c = Client(args.base_url, timeout=60)
s = Suite(c)
alice, bob, eve, chat = c.bootstrap()
chat2 = c.call("POST", "/api/v1/chats", 201, actor=alice,
body={"title": "второй чат", "member_ids": [alice["id"], bob["id"]]}, schema="Chat")["json"]
eve_chat = c.call("POST", "/api/v1/chats", 201, actor=eve,
body={"title": "чат Евы", "member_ids": [eve["id"]]}, schema="Chat")["json"]
# --- позитивные контрольные ---
ok_png = s.upload("valid PNG fixture", alice, chat, PNG, 202)
ok_jpg = s.upload("valid JPEG", bob, chat, JPEG, 202, ctype="image/jpeg", filename="photo.jpg")
uni = s.upload("unicode filename", alice, chat, PNG, 202, filename="фото отпуска 🙂.png")
if uni:
check(uni["json"]["filename"] == "фото отпуска 🙂.png", "unicode filename changed")
def ready(r): # lab5: upload -> 202 queued, байты доступны после ready
if r:
c.wait_ready(alice if r["json"]["owner_id"] == alice["id"] else bob, r["json"])
for r in (ok_png, ok_jpg):
ready(r)
if ok_jpg:
d = c.call("GET", "/api/v1/attachments/%s/content" % ok_jpg["json"]["id"], actor=alice)
check(d["bytes"] == JPEG and d["headers"].get_content_type() == "image/jpeg", "jpeg download mismatch")
check(d["headers"].get("X-Content-Type-Options") == "nosniff", "nosniff missing")
near = noise_png(MAX_BYTES)
big = s.upload("PNG near 10 MiB limit (%d B)" % len(near), alice, chat, near, 202, filename="big.png")
if big:
check(big["json"]["sha256"] == hashlib.sha256(near).hexdigest(), "big sha mismatch")
ready(big)
d = c.call("GET", "/api/v1/attachments/%s/content" % big["json"]["id"], actor=bob)
check(hashlib.sha256(d["bytes"]).hexdigest() == big["json"]["sha256"], "big download mismatch")
# --- размер и пиксели ---
s.upload("too large: 10 MiB + 1 B", alice, chat, near + b"\0" * (MAX_BYTES + 1 - len(near)), 413)
s.upload("pixel bomb header 100000x100000", alice, chat, png(100000, 100000, zlib.compress(b"\0" * 1000)), 413)
s.upload("PNG 7000x6000 = 42 Mpx (> 40 Mpx)", alice, chat, png(7000, 6000, zlib.compress(b"\0" * 1000)), 413)
s.upload("zlib bomb: 100x100 header, 50 MB inflated", alice, chat,
png(100, 100, zlib.compress(b"\0" * 50_000_000, 9), color_type=0), 415)
# --- повреждённые изображения ---
flipped = bytearray(PNG); flipped[5000] ^= 0xFF
s.upload("corrupted PNG (byte flipped, bad CRC)", alice, chat, bytes(flipped), 415)
s.upload("truncated PNG", alice, chat, PNG[:-4000], 415)
s.upload("PNG without IEND", alice, chat, PNG[:-12], 415)
s.upload("PNG with appended ZIP (polyglot)", alice, chat, PNG + b"PK\x03\x04" + os.urandom(64), 415)
s.upload("truncated JPEG", alice, chat, JPEG[:len(JPEG) // 2], 415, ctype="image/jpeg")
s.upload("JPEG header only", alice, chat, JPEG[:200], 415, ctype="image/jpeg")
s.upload("empty body", alice, chat, b"", 415)
# --- подмена MIME ---
s.upload("JPEG bytes declared image/png", alice, chat, JPEG, 415)
s.upload("PNG bytes declared image/jpeg", alice, chat, PNG, 415, ctype="image/jpeg")
s.upload("text declared image/png", alice, chat, b"<html><script>alert(1)</script></html>" * 4, 415)
s.upload("GIF declared image/png", alice, chat, b"GIF89a" + os.urandom(200), 415)
s.upload("PNG declared text/html", alice, chat, PNG, 415, ctype="text/html")
s.upload("PNG declared image/svg+xml", alice, chat, PNG, 415, ctype="image/svg+xml")
s.upload("multipart/form-data instead of raw", alice, chat, b"--x\r\n\r\n" + PNG + b"\r\n--x--", 415,
ctype="multipart/form-data; boundary=x")
# --- опасные filename ---
for label, query in (("../etc/passwd", "filename=" + quote("../passwd.png", safe="")),
("slash", "filename=" + quote("a/b.png", safe="")),
("backslash", "filename=" + quote("a\\b.png", safe="")),
("NUL", "filename=a%00.png"),
("newline", "filename=a%0A.png"),
("bidi override U+202E", "filename=" + quote("‮gnp.exe", safe="")),
("..", "filename=.."),
("empty", "filename="),
("whitespace only", "filename=%20%20"),
("256 code points", "filename=" + quote("я" * 256, safe="")),
("missing filename", ""),
("filename twice", "filename=a.png&filename=b.png"),
("invalid UTF-8", "filename=%FF%FE.png")):
s.upload("filename: " + label, alice, chat, PNG, 400, raw_query=query)
# --- доступ и чужие объекты ---
eve_att = s.upload("eve uploads to her own chat", eve, eve_chat, PNG, 202)
s.upload("non-member uploads to alice chat", eve, chat, PNG, 404)
s.case("upload without session", "POST", "/api/v1/chats/%s/attachments?filename=a.png" % chat["id"], 401,
raw=PNG, headers={"Content-Type": "image/png"})
s.upload("upload to unknown chat", alice, {"id": str(uuid.uuid4())}, PNG, 404)
if eve_att and ok_png:
eid, aid = eve_att["json"]["id"], ok_png["json"]["id"]
s.case("foreign attachment metadata", "GET", "/api/v1/attachments/" + eid, 404, actor=alice)
s.case("foreign attachment content", "GET", "/api/v1/attachments/%s/content" % eid, 404, actor=alice)
s.case("eve reads alice attachment", "GET", "/api/v1/attachments/%s/content" % aid, 404, actor=eve)
key = lambda: {"Idempotency-Key": uuid.uuid4().hex} # noqa: E731
s.case("message with foreign attachment_id", "POST", "/api/v1/chats/%s/messages" % chat["id"], 404,
actor=alice, body={"text": "x", "attachment_ids": [eid]}, headers=key())
s.case("message mixing own and foreign ids", "POST", "/api/v1/chats/%s/messages" % chat["id"], 404,
actor=alice, body={"text": "x", "attachment_ids": [aid, eid]}, headers=key())
s.case("attachment of OTHER chat of the same user", "POST", "/api/v1/chats/%s/messages" % chat2["id"], 404,
actor=alice, body={"text": "x", "attachment_ids": [aid]}, headers=key())
s.case("unknown attachment_id", "POST", "/api/v1/chats/%s/messages" % chat["id"], 404, actor=alice,
body={"text": "x", "attachment_ids": [str(uuid.uuid4())]}, headers=key())
s.case("malformed attachment_id", "POST", "/api/v1/chats/%s/messages" % chat["id"], 400, actor=alice,
body={"text": "x", "attachment_ids": ["not-a-uuid"]}, headers=key())
s.case("duplicate attachment_ids", "POST", "/api/v1/chats/%s/messages" % chat["id"], 400, actor=alice,
body={"text": "x", "attachment_ids": [aid, aid]}, headers=key())
s.case("11 attachment_ids", "POST", "/api/v1/chats/%s/messages" % chat["id"], 400, actor=alice,
body={"text": "x", "attachment_ids": [str(uuid.uuid4()) for _ in range(11)]}, headers=key())
s.case("attachment_ids not a list", "POST", "/api/v1/chats/%s/messages" % chat["id"], 400, actor=alice,
body={"text": "x", "attachment_ids": aid}, headers=key())
s.case("empty text without attachments", "POST", "/api/v1/chats/%s/messages" % chat["id"], 400,
actor=alice, body={"text": " "}, headers=key())
m = s.case("empty text with attachment (bob links alice's file)", "POST",
"/api/v1/chats/%s/messages" % chat["id"], 201, actor=bob,
body={"text": "", "attachment_ids": [aid]}, headers=key(), schema="Message")
if m:
check(m["json"]["attachment_ids"] == [aid], "attachment_ids lost")
k = key()
s.case("idempotent send with attachments", "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
actor=alice, body={"attachment_ids": [aid], "text": "повтор"}, headers=k, schema="Message")
s.case("same key, same body (key order changed)", "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
actor=alice, body={"text": "повтор", "attachment_ids": [aid]}, headers=k, schema="Message")
s.case("same key, different attachment_ids -> 409", "POST", "/api/v1/chats/%s/messages" % chat["id"], 409,
actor=alice, body={"text": "повтор", "attachment_ids": []}, headers=k)
s.case("variant=thumbnail (ready, lab5)", "GET",
"/api/v1/attachments/%s/content?variant=thumbnail" % aid, 200, actor=bob)
s.case("variant=bogus", "GET", "/api/v1/attachments/%s/content?variant=bogus" % aid, 400, actor=bob)
s.case("variant=original", "GET", "/api/v1/attachments/%s/content?variant=original" % aid, 200, actor=bob)
s.case("malformed attachment id in path", "GET", "/api/v1/attachments/zzz", 400, actor=bob)
s.case("unknown attachment id", "GET", "/api/v1/attachments/" + str(uuid.uuid4()), 404, actor=bob)
failed = [r for r in results if not r["pass"]]
server_errors = [r for r in results if r.get("status", 0) >= 500]
for r in results:
print(("PASS " if r["pass"] else "FAIL ") + "%-55s -> %s %s" % (
r["case"], r.get("status", "-"), r.get("error_code") or r.get("error", "")))
summary = {"cases": len(results), "failed": len(failed), "server_errors_5xx": len(server_errors),
"pass": not failed and not server_errors}
print(json.dumps(summary, ensure_ascii=False))
if args.output:
Path(args.output).write_text(json.dumps({"summary": summary, "results": results}, ensure_ascii=False, indent=1))
return 0 if summary["pass"] else 1
if __name__ == "__main__":
sys.exit(main())
+99
View File
@@ -0,0 +1,99 @@
#!/usr/bin/env python3
"""Права пользователей RabbitMQ (минимальные привилегии). Хост-оркестратор:
python3 student-tests/broker_permissions.py --output evidence/broker-permissions.json
Внутри контейнеров relay, worker и ops (каждый — со СВОИМ BROKER_URL_FILE) выполняется
проба (--probe): publish в exchange attachments (с mandatory и неизвестным routing key —
сообщение никуда не попадает, но право write проверяется), basic.get из рабочей очереди и
из DLQ (право read), queue.declare (право configure). Ожидаемая матрица:
relay — publish; worker — read рабочей очереди; ops — publish + read DLQ; configure — никто.
Также: пользователя guest нет; порты брокера на хост не опубликованы.
"""
import argparse
import json
import subprocess
import sys
from pathlib import Path
EXPECT = {
"relay": {"publish": True, "get_work_queue": False, "get_dlq": False, "declare_queue": False},
"worker": {"publish": False, "get_work_queue": True, "get_dlq": False, "declare_queue": False},
"ops": {"publish": True, "get_work_queue": False, "get_dlq": True, "declare_queue": False},
}
def probe():
sys.path.insert(0, "/app/src")
import pika
import common
out = {}
conn = pika.BlockingConnection(common.broker_parameters())
def attempt(name, fn):
ch = conn.channel()
try:
fn(ch)
out[name] = True
except pika.exceptions.UnroutableError:
out[name] = True # write разрешён, просто нет binding
except pika.exceptions.ChannelClosedByBroker as exc:
out[name] = False if exc.reply_code == 403 else "error %d" % exc.reply_code
finally:
if ch.is_open:
ch.close()
def publish(ch):
ch.confirm_delivery()
ch.basic_publish(common.EXCHANGE, "permission.check.unbound", b"{}", mandatory=True)
def get(queue):
def fn(ch):
m, _p, _b = ch.basic_get(queue, auto_ack=False)
if m is not None:
ch.basic_nack(m.delivery_tag, requeue=True)
return fn
attempt("publish", publish)
attempt("get_work_queue", get(common.QUEUE))
attempt("get_dlq", get(common.DLQ))
attempt("declare_queue", lambda ch: ch.queue_declare("evil-queue", durable=True))
conn.close()
print(json.dumps(out))
def main():
p = argparse.ArgumentParser()
p.add_argument("--probe", action="store_true")
p.add_argument("--output")
args = p.parse_args()
if args.probe:
return probe()
root = Path(__file__).resolve().parents[1]
script = (root / "student-tests/broker_permissions.py").read_text()
results, ok = {}, True
runners = {"relay": ["docker", "compose", "exec", "-T", "relay", "python", "-", "--probe"],
"worker": ["docker", "compose", "exec", "-T", "worker", "python", "-", "--probe"],
"ops": ["docker", "compose", "--profile", "tools", "run", "--rm", "-T", "--entrypoint", "python",
"ops", "-", "--probe"]}
for user, cmd in runners.items():
r = subprocess.run(cmd, input=script, capture_output=True, text=True, cwd=root, timeout=120)
got = json.loads(r.stdout.strip().splitlines()[-1])
results[user] = {"got": got, "expected": EXPECT[user], "pass": got == EXPECT[user]}
ok &= got == EXPECT[user]
print("%s %-6s %s" % ("PASS" if got == EXPECT[user] else "FAIL", user, got))
users = subprocess.run(["docker", "compose", "exec", "-T", "broker", "rabbitmqctl", "-q", "list_users"],
capture_output=True, text=True, cwd=root).stdout.split()
ports = subprocess.run(["docker", "compose", "port", "broker", "5672"], capture_output=True, text=True, cwd=root)
results["guest_absent"] = "guest" not in users
results["broker_port_published_to_host"] = bool(ports.stdout.strip())
ok &= results["guest_absent"] and not results["broker_port_published_to_host"]
print("guest absent:", results["guest_absent"], "| port 5672 on host:", results["broker_port_published_to_host"])
if args.output:
Path(args.output).write_text(json.dumps(results, ensure_ascii=False, indent=1) + "\n")
print("PASS" if ok else "FAIL")
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main() or 0)
+124
View File
@@ -0,0 +1,124 @@
#!/usr/bin/env python3
"""Уровень 4: ограниченная конкуренция/prefetch, очистка staging, память worker под всплеском.
python3 student-tests/burst.py --count 24 --output evidence/burst.json
N несжимаемых PNG 1500x1500 (~6.8 MB) загружаются 8 потоками. Во время обработки раз в
секунду снимается память контейнеров worker (docker stats). По job_events считаются:
максимальное число одновременно обрабатываемых заданий (claimed..ready), задержка очереди
(enqueued -> claimed) и время до ready. Ожидание: одновременно <= WORKER_REPLICAS x
WORKER_CONCURRENCY (prefetch=1 на потребителя), staging всех заданий удалён.
Иллюстрация на одной машине, не статистика.
"""
import argparse
import concurrent.futures
import datetime as dt
import json
import statistics
import subprocess
import threading
import time
from lab5lib import Client, Log, check, compose, noise_png_fast, queues, sql, upload, wait_status
def ts(text):
return dt.datetime.fromisoformat(text.replace("Z", "+00:00"))
def mem_sampler(stop, samples):
while not stop.is_set():
ids = compose("ps", "-q", "worker").stdout.split()
out = subprocess.run(["docker", "stats", "--no-stream", "--format", "{{.Name}} {{.MemUsage}} {{.CPUPerc}}"]
+ ids, capture_output=True, text=True).stdout
for line in out.splitlines():
name, used, _slash, limit, cpu = line.split()[:5]
samples.append({"name": name, "used": used, "limit": limit, "cpu": cpu})
stop.wait(1)
def mib(text):
num = float("".join(ch for ch in text if ch.isdigit() or ch == "."))
return num / 1024 if text.endswith("KiB") else num * 1024 if text.endswith("GiB") else num
def pct(values, p):
values = sorted(values)
return round(values[min(len(values) - 1, int(round(p / 100 * (len(values) - 1))))], 3)
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--count", type=int, default=24)
p.add_argument("--output")
args = p.parse_args()
log = Log("burst of uploads: bounded worker concurrency")
c = Client(args.base_url, timeout=60)
alice, bob, _eve, chat = c.bootstrap()
consumers = compose("exec", "-T", "broker", "rabbitmqctl", "-q", "-p", "messenger", "list_consumers",
"queue_name", "prefetch_count", "ack_required", "--formatter", "json").stdout
consumers = json.loads(consumers)
log.step("consumers", count=len(consumers), prefetch=sorted({x["prefetch_count"] for x in consumers}))
images = [noise_png_fast(1500, 1500) for _ in range(4)]
log.step("generated images", bytes=[len(x) for x in images])
stop = threading.Event()
samples = []
sampler = threading.Thread(target=mem_sampler, args=(stop, samples), daemon=True)
sampler.start()
t0 = time.monotonic()
with concurrent.futures.ThreadPoolExecutor(8) as pool:
atts = list(pool.map(lambda i: upload(c, alice, chat, images[i % 4], "burst-%d.png" % i),
range(args.count)))
t_up = time.monotonic() - t0
q = queues()["attachments.process.v1"]
log.step("all uploads accepted (202)", count=len(atts), seconds=round(t_up, 2), queue_right_after=q)
for a in atts:
st = wait_status(c, bob, a["id"], {"ready", "failed"}, timeout=180, interval=1)
check(st["status"] == "ready", "burst job failed")
total = time.monotonic() - t0
stop.set()
sampler.join()
ids = ",".join("'%s'" % a["id"] for a in atts)
rows = sql("""SELECT j.attachment_id, e.event, to_char(e.at AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"')
FROM job_events e JOIN jobs j ON j.id = e.job_id
WHERE j.attachment_id IN (%s) AND e.event IN ('enqueued','claimed','ready') ORDER BY e.id""" % ids)
per = {}
for att_id, ev, at in rows:
per.setdefault(att_id, {})[ev] = ts(at)
intervals = [(v["claimed"], v["ready"]) for v in per.values()]
points = sorted([(a, 1) for a, _ in intervals] + [(b, -1) for _, b in intervals], key=lambda x: (x[0], x[1]))
cur = peak = 0
for _, d in points:
cur += d
peak = max(peak, cur)
lag = [(v["claimed"] - v["enqueued"]).total_seconds() for v in per.values()]
to_ready = [(v["ready"] - v["enqueued"]).total_seconds() for v in per.values()]
work = [(v["ready"] - v["claimed"]).total_seconds() for v in per.values()]
staging_left = sql("SELECT count(*) FROM attachments WHERE id IN (%s) AND staging_key IS NOT NULL" % ids)[0][0]
limit = len(consumers)
by_name = {}
for s in samples:
by_name[s["name"]] = max(by_name.get(s["name"], 0), mib(s["used"]))
result = {
"count": args.count, "image_bytes": len(images[0]), "upload_seconds": round(t_up, 2),
"total_seconds_to_all_ready": round(total, 2),
"throughput_jobs_per_s": round(args.count / total, 2),
"consumers": limit, "prefetch_per_consumer": sorted({x["prefetch_count"] for x in consumers}),
"max_concurrent_processing": peak,
"queue_lag_s": {"p50": pct(lag, 50), "p95": pct(lag, 95), "max": round(max(lag), 3)},
"enqueued_to_ready_s": {"p50": pct(to_ready, 50), "p95": pct(to_ready, 95), "max": round(max(to_ready), 3)},
"processing_s": {"p50": pct(work, 50), "max": round(max(work), 3), "mean": round(statistics.mean(work), 3)},
"worker_peak_mem_mib": {k: round(v, 1) for k, v in by_name.items()},
"worker_mem_limit": samples[0]["limit"] if samples else None,
"staging_left": int(staging_left),
}
check(peak <= limit, "concurrency exceeded consumers x prefetch")
check(result["staging_left"] == 0, "staging not cleaned")
log.step("result", **result)
log.save(args.output, result=result)
print("PASS: %d jobs, max concurrent %d <= %d consumers" % (args.count, peak, limit))
if __name__ == "__main__":
main()
+32
View File
@@ -0,0 +1,32 @@
#!/usr/bin/env python3
"""Проверка диапазона дат cursor: некорректная дата должна давать 400, а не 500."""
import base64
import json
import sys
import uuid
from pathlib import Path
from urllib.parse import quote
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client, arguments, run
def main():
args = arguments(__doc__)
client = Client(args.base_url, ca_file=args.ca_file)
alice, _bob, _eve, chat = client.bootstrap()
checks = 0
for kind, scope, path in (
("messages", chat["id"], "/api/v1/chats/" + chat["id"] + "/messages"),
("chats", alice["id"], "/api/v1/chats"),
):
for timestamp, expected in ((-10**17, 400), (-62135596800000001, 400), (0, 200)):
payload = {"k": kind, "s": scope, "t": timestamp, "i": str(uuid.uuid4())}
cursor = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
client.call("GET", path + "?cursor=" + quote(cursor, safe=""), expected, actor=alice)
checks += 1
print("PASS: %d cursor date boundary checks; invalid dates return 400." % checks)
if __name__ == "__main__":
run(main)
+103
View File
@@ -0,0 +1,103 @@
#!/usr/bin/env python3
"""Lab6: dashboard импортирован provisioning-ом и все его запросы работают на реальных данных.
python3 student-tests/dashboard_check.py --output evidence/dashboard-check.json
* Grafana отдаёт dashboard uid=messenger-overview (provisioned, папка Messenger) и 3 datasource;
* каждый PromQL панели выполняется через Grafana (ошибка синтаксиса/имени = FAIL); для
ключевых панелей результат обязан быть непустым (метрика реально существует);
* LogQL и TraceQL панелей выполняются в Loki/Tempo без ошибок.
Перед проверкой — прогрев 40 с (сообщения, чтение, upload до ready): панели с rate()/increase()
за 1 мин пусты, если за последнюю минуту не было трафика (например, сразу после пересоздания worker).
"""
import argparse
import json
import sys
import time
from pathlib import Path
import obslib
from lab5lib import SAMPLE_PNG, Client, upload, wait_status
from traffic import Traffic
ROOT = Path(__file__).resolve().parents[1]
# Панели, данные которых есть всегда после smoke-трафика (остальные — ошибки/алерты, могут быть пусты).
MUST_HAVE_DATA = {
"RPS бизнес-запросов", "p95 API (5m)", "RPS по маршруту", "Ответы по классу статуса",
"Задержка API p50/p95/p99 (из histogram)", "p95 по маршруту", "Запросы в обработке (saturation API)",
"HAProxy: UP-реплики и очередь LB", "Задания по исходу (в минуту)", "Глубина очереди: PostgreSQL и RabbitMQ",
"Возраст старейшего задания и lag", "Saturation worker: занятость потребителей",
"Пул соединений API: used / idle / max", "Операции БД p95 по операции (API)", "S3 p95 по операции",
"CPU, ядер (cgroup контейнера)", "Память контейнеров приложений", "Память: доля лимита",
"Память telemetry-стека (RSS)", "Collector: принято / отправлено / потеряно (spans)", "Collector: логи",
"Collector: очередь экспортёров", "SDK: заполнение очереди BatchSpanProcessor", "Time to ready p95",
"Ready lag очереди", "Relay: публикации outbox", "Ожидание в очереди p95 (до claim)",
}
def main():
p = argparse.ArgumentParser()
p.add_argument("--output")
p.add_argument("--warmup", type=int, default=40)
args = p.parse_args()
if args.warmup:
c = Client(timeout=30)
alice, _bob, _eve, chat = c.bootstrap()
tr = Traffic(c, alice, chat, threads=2, think=0.3, upload_every=3).start()
att = upload(c, alice, chat, SAMPLE_PNG, "warmup.png")
wait_status(c, alice, att["id"], ("ready",), timeout=60)
time.sleep(args.warmup)
tr.stop()
print("warmup:", tr.window(0, args.warmup + 60))
dash = json.loads((ROOT / "infra/grafana/dashboards/messenger.json").read_text(encoding="utf-8"))
got = obslib.grafana("/api/dashboards/uid/" + dash["uid"])
assert got and got["dashboard"]["uid"] == dash["uid"], "dashboard is not provisioned"
meta = got["meta"]
ds = sorted(d["uid"] for d in obslib.grafana("/api/datasources"))
assert {"prometheus", "loki", "tempo"} <= set(ds), ds
health = {uid: obslib.grafana("/api/datasources/uid/%s/health" % uid) for uid in ("prometheus", "loki", "tempo")}
report = {"dashboard": {"uid": dash["uid"], "title": got["dashboard"]["title"], "provisioned": meta.get("provisioned"),
"folder": meta.get("folderTitle"), "panels": len(dash["panels"])},
"datasources": ds, "datasource_health": {k: (v or {}).get("status") for k, v in health.items()},
"panels": []}
failed = []
now = time.time()
for panel in dash["panels"]:
if panel["type"] == "row":
continue
for t in panel.get("targets", []):
uid = t["datasource"]["uid"]
item = {"panel": panel["title"], "ref": t["refId"], "datasource": uid}
try:
if uid == "prometheus":
expr = t["expr"].replace('instance=~"$instance"', 'instance=~".*"')
res = obslib.prom_query(expr)
item["series"] = len(res)
elif uid == "loki":
item["lines"] = len(obslib.loki_query(t["expr"], now - 3600, now, limit=20))
else:
r = obslib.tempo_search(t["query"], now - 3600, now, limit=5)
item["traces"] = len((r or {}).get("traces") or [])
item["ok"] = True
except Exception as exc:
item["ok"], item["error"] = False, str(exc)[:200]
failed.append(item)
report["panels"].append(item)
empty_required = sorted({i["panel"] for i in report["panels"] if i["panel"] in MUST_HAVE_DATA
and i.get("series", 1) == 0 and i["ref"] == "A"})
report["query_errors"] = failed
report["empty_required_panels"] = empty_required
report["pass"] = not failed and not empty_required and report["datasource_health"] == {
"prometheus": "OK", "loki": "OK", "tempo": "OK"}
for i in report["panels"]:
print("%-4s %-55s %-10s %s" % ("ok" if i["ok"] else "ERR", i["panel"][:55], i["datasource"],
i.get("series", i.get("lines", i.get("traces", i.get("error"))))))
print(json.dumps({k: report[k] for k in ("dashboard", "datasource_health", "query_errors",
"empty_required_panels", "pass")}, ensure_ascii=False))
if args.output:
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
return 0 if report["pass"] else 1
if __name__ == "__main__":
sys.exit(main())
+69
View File
@@ -0,0 +1,69 @@
#!/usr/bin/env python3
"""Lab6: скорость разбора backlog worker-ами (до/после исправления цикла AMQP в worker.run_job).
python3 student-tests/drain_bench.py --count 240 --label after-fix --output evidence/drain-bench-after.json
worker останавливаются, через API принимаются --count маленьких PNG (64x48, 202 queued), worker
запускаются; измеряется время, пока все вложения не станут ready, и по Prometheus — пропускная
способность (jobs/s), utilization потребителей и CPU worker в окне разбора.
"""
import argparse
import concurrent.futures
import sys
import time
from lab5lib import Client, Failure, Log, check, compose, png, sql, upload
import obslib
def main():
p = argparse.ArgumentParser()
p.add_argument("--count", type=int, default=240)
p.add_argument("--label", default="run")
p.add_argument("--output")
args = p.parse_args()
log = Log("worker drain benchmark (%s)" % args.label)
c = Client(timeout=30)
alice, _bob, _eve, chat = c.bootstrap()
compose("stop", "worker")
imgs = [png(64, 48, color=(i % 256, (i * 7) % 256, 90)) for i in range(args.count)]
with concurrent.futures.ThreadPoolExecutor(8) as ex:
ids = list(ex.map(lambda img: upload(c, alice, chat, img, "bench.png")["id"], imgs))
log.step("backlog created with workers stopped", uploads=len(ids))
t0 = time.time()
compose("up", "-d", "--no-deps", "--no-recreate", "--wait", "worker", timeout=200)
t_up = time.time()
while True:
left = int(sql("SELECT count(*) FROM attachments WHERE chat_id = '%s' AND status <> 'ready'" % chat["id"])[0][0])
if left == 0:
break
check(time.time() - t0 < 600, "drain timeout")
time.sleep(0.5)
t1 = time.time()
drain = t1 - t_up
time.sleep(25) # метрики экспортируются раз в 10 с
w = max(30, int(t1 - t_up) + 15)
res = {
"uploads": len(ids), "drain_seconds_after_workers_up": round(drain, 1),
"jobs_per_second_wallclock": round(len(ids) / drain, 2),
"workers_x_concurrency": obslib.prom_value("sum(last_over_time(messenger_worker_capacity[30s]))"),
"utilization_peak_1m": round(obslib.prom_value(
"max_over_time((sum(rate(messenger_worker_busy_time_seconds_total[30s])) / sum(last_over_time(messenger_worker_capacity[30s])))[%ds:5s])" % w), 3),
"job_duration_p50_s": round(obslib.prom_value(
'histogram_quantile(0.5, sum by (le) (increase(messenger_job_duration_seconds_bucket{messenger_job_outcome="ready"}[%ds])))' % w), 3),
"worker_cpu_cores_peak": round(obslib.prom_value(
'max_over_time(sum(rate(container_cpu_time_seconds_total{job="messenger-worker"}[30s]))[%ds:5s])' % w), 3),
}
log.step("drained", **res)
log.save(args.output, label=args.label, **res)
print("PASS: %s drained %d jobs in %.1fs (%.1f jobs/s)" % (args.label, len(ids), drain, len(ids) / drain))
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except Failure as exc:
print("FAIL:", exc)
compose("up", "-d", "--no-deps", "--no-recreate", "worker", ok=False)
sys.exit(1)
+264
View File
@@ -0,0 +1,264 @@
#!/usr/bin/env python3
"""Отказ/замена API-реплики ПОД НАГРУЗКОЙ: RPS, ошибки, время обнаружения и восстановления (lab3, уровень 4).
Что делает:
* CONCURRENCY потоков в closed-loop шлют смесь запросов через LB: POST сообщения
(с Idempotency-Key) и GET истории (limit=20) в пропорции 1:1;
* после неуспешного/неопределённого POST поток повторяет ТОТ ЖЕ ключ и тело (как
требует контракт), поэтому подтверждённых дублей быть не должно;
* на секунде --action-at запускается --action (например, docker stop/kill контейнера
или scripts/rolling-update.sh), его stdout/stderr пишутся в отдельный лог;
* параллельно каждые 200 мс опрашивается CSV статистики HAProxy: фиксируются моменты
UP -> DOWN / DOWN -> UP серверов backend (время обнаружения отказа LB);
* в конце читается вся история чата (тем же токеном) и проверяется: все подтверждённые
сообщения на месте, дублей нет.
Метрики (все времена — от старта action):
errors_total / error_rate — неуспешные попытки (HTTP != ожидаемого, timeout, разрыв);
error_window_s — от первой до последней ошибки после старта action;
recovery_s — конец окна ошибок (дальше все запросы успешны), 0 если ошибок нет;
post_action_ok_rps/capacity_ratio — успешный RPS после действия и его доля от базового;
lb_down_detected_s — когда HAProxy пометил сервер DOWN;
target_last_seen_s — последний ответ от остановленной реплики.
Ограничения: closed-loop генератор (coordinated omission), клиент на том же хосте, что и
стенд; цифры RPS сравнимы только между прогонами этого же скрипта на этом же ноутбуке.
"""
import argparse
import csv
import io
import json
import shlex
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import uuid
from collections import Counter, defaultdict
from pathlib import Path
from urllib.parse import quote
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client # noqa: E402
TIMEOUT = 2.0
def percentile(values, p):
if not values:
return None
s = sorted(values)
return round(s[min(len(s) - 1, int(round(p / 100 * (len(s) - 1))))] * 1000, 1)
class Bench:
def __init__(self, a):
self.a = a
self.base = a.base_url.rstrip("/")
self.lock = threading.Lock()
self.t0 = None
self.stop = threading.Event()
self.per_sec = defaultdict(lambda: {"ok": 0, "err": 0, "inst": Counter(), "ver": Counter()})
self.errors = [] # (t, kind)
self.lat = [] # успешные задержки, с
self.confirmed = {} # message id -> text
self.retried_posts = 0
self.lb_events = []
self.inst_last_seen = {}
def now(self):
return time.monotonic() - self.t0
def record(self, ok, dt, inst=None, ver=None, kind=None):
t = self.now()
with self.lock:
b = self.per_sec[int(t)]
if ok:
b["ok"] += 1
self.lat.append(dt)
if inst:
b["inst"][inst] += 1
self.inst_last_seen[inst] = t
if ver:
b["ver"][ver] += 1
else:
b["err"] += 1
self.errors.append((round(t, 3), kind))
def request(self, method, path, body=None, headers=None, expected=200):
h = {"Authorization": "Bearer " + self.token}
h.update(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(self.base + path, data=data, method=method, headers=h)
start = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
payload = json.loads(r.read())
ok = r.status == expected
self.record(ok, time.monotonic() - start, r.headers.get("X-Instance-Id"),
r.headers.get("X-App-Version"), None if ok else "http_%d" % r.status)
return payload if ok else None
except urllib.error.HTTPError as e:
self.record(False, 0, kind="http_%d" % e.code)
except Exception as e: # noqa: BLE001
self.record(False, 0, kind=type(e).__name__)
return None
def worker(self, n):
chat_path = "/api/v1/chats/" + self.chat["id"] + "/messages"
key = text = None
i = 0
while not self.stop.is_set():
i += 1
if i % 2:
if key is None: # новый логический запрос; после ошибки ключ НЕ меняется
key = "bench-%d-%s" % (n, uuid.uuid4().hex)
text = "Нагрузка " + key
else:
with self.lock:
self.retried_posts += 1
msg = self.request("POST", chat_path, {"text": text}, {"Idempotency-Key": key}, 201)
if msg is not None:
with self.lock:
self.confirmed[msg["id"]] = msg["text"]
key = None
else:
self.request("GET", chat_path + "?limit=20")
def poll_lb(self):
prev = {}
while not self.stop.is_set():
try:
with urllib.request.urlopen(self.a.stats_url, timeout=1) as r:
rows = list(csv.reader(io.StringIO(r.read().decode().lstrip("# "))))
head = rows[0]
ix = {k: head.index(k) for k in ("pxname", "svname", "status", "addr")}
for row in rows[1:]:
if len(row) <= ix["addr"] or row[ix["pxname"]] != "be_api" or row[ix["svname"]] == "BACKEND":
continue
sv, st, addr = row[ix["svname"]], row[ix["status"]].split(" ")[0], row[ix["addr"]]
if sv in prev and prev[sv] != (st, addr):
self.lb_events.append({"t": round(self.now(), 2), "server": sv, "addr": addr,
"from": prev[sv][0], "to": st})
prev[sv] = (st, addr)
except Exception: # noqa: BLE001 — статистика вспомогательная
pass
time.sleep(0.2)
def history(self):
c, path, items = self.client, "/api/v1/chats/" + self.chat["id"] + "/messages?limit=100", []
while True:
page = c.call("GET", path, actor=self.alice, schema="MessagePage")["json"]
items += page["items"]
if page["next_cursor"] is None:
return items
path = "/api/v1/chats/" + self.chat["id"] + "/messages?limit=100&cursor=" + quote(page["next_cursor"], safe="")
def run(self):
a = self.a
self.client = Client(self.base, timeout=10)
self.alice, _bob, _eve, self.chat = self.client.bootstrap()
self.token = self.alice["token"]
self.t0 = time.monotonic()
threads = [threading.Thread(target=self.worker, args=(n,), daemon=True) for n in range(a.concurrency)]
threads.append(threading.Thread(target=self.poll_lb, daemon=True))
for t in threads:
t.start()
time.sleep(a.action_at)
action = {"command": a.action, "started_s": round(self.now(), 3)}
log = open(a.action_log, "w", encoding="utf-8") if a.action_log else subprocess.DEVNULL
proc = subprocess.Popen(shlex.split(a.action), stdout=log, stderr=subprocess.STDOUT)
rc = proc.wait(timeout=a.duration)
action.update(finished_s=round(self.now(), 3), exit_code=rc)
remaining = a.duration - self.now()
if remaining > 0:
time.sleep(remaining)
self.stop.set()
for t in threads:
t.join(timeout=TIMEOUT + 1)
return self.summarize(action)
def summarize(self, action):
a, t_act = self.a, action["started_s"]
secs = sorted(self.per_sec)
base = [self.per_sec[s]["ok"] for s in secs if 1 <= s < int(t_act)] # 1-я секунда — прогрев
baseline = sum(base) / len(base) if base else 0
after = [(round(t - t_act, 3), k) for t, k in self.errors if t >= t_act]
# Восстановление = конец окна ошибок: после этого момента все запросы до конца
# прогона успешны. Если ошибок не было — 0. Мощность после отказа меряем отдельно:
# при меньшем числе реплик RPS законно ниже (лимиты CPU на реплику).
recovery = after[-1][0] if after else 0.0
tail_secs = [s for s in secs if int(action.get("finished_s", t_act)) + 2 <= s < a.duration - 1]
post = [self.per_sec[s]["ok"] for s in tail_secs]
post_rps = sum(post) / len(post) if post else 0
writes_after = any(self.per_sec[s]["ok"] > 0 for s in tail_secs)
target = a.target_instance
hist = self.history()
ids = [m["id"] for m in hist]
texts = [m["text"] for m in hist]
lost = [i for i in self.confirmed if i not in set(ids)]
timeline = [{"t": s, "ok": self.per_sec[s]["ok"], "err": self.per_sec[s]["err"],
"instances": dict(self.per_sec[s]["inst"]), "versions": dict(self.per_sec[s]["ver"])}
for s in secs]
total_ok = sum(b["ok"] for b in self.per_sec.values())
total_err = len(self.errors)
summary = {
"label": a.label,
"concurrency": a.concurrency, "duration_s": a.duration, "request_timeout_s": TIMEOUT,
"action": action,
"baseline_ok_rps": round(baseline, 1),
"overall_ok_rps": round(total_ok / a.duration, 1),
"requests_ok": total_ok, "errors_total": total_err,
"error_rate": round(total_err / max(1, total_ok + total_err), 5),
"errors_by_kind": dict(Counter(k for _, k in self.errors)),
"error_window_s": [after[0][0], after[-1][0]] if after else None,
"recovery_s": recovery,
"post_action_ok_rps": round(post_rps, 1),
"capacity_ratio": round(post_rps / baseline, 2) if baseline else None,
"latency_ok_ms": {"p50": percentile(self.lat, 50), "p95": percentile(self.lat, 95),
"p99": percentile(self.lat, 99)},
"target_instance": target,
"target_last_seen_s": (round(self.inst_last_seen[target] - t_act, 3)
if target in self.inst_last_seen else None),
"lb_events": [dict(e, t=round(e["t"] - t_act, 2)) for e in self.lb_events],
"posts_retried_same_key": self.retried_posts,
"confirmed_messages": len(self.confirmed),
"history_messages": len(hist), "lost_confirmed": len(lost),
"duplicate_ids": len(ids) - len(set(ids)), "duplicate_texts": len(texts) - len(set(texts)),
"timeline": timeline,
}
summary["pass"] = (summary["lost_confirmed"] == 0 and summary["duplicate_ids"] == 0
and summary["duplicate_texts"] == 0 and action["exit_code"] == 0
and writes_after and recovery <= 10)
return summary
def main():
p = argparse.ArgumentParser(description="Отказ/замена реплики под нагрузкой")
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--stats-url", default="http://127.0.0.1:8404/stats;csv")
p.add_argument("--concurrency", type=int, default=8)
p.add_argument("--duration", type=float, default=40)
p.add_argument("--action-at", type=float, default=10)
p.add_argument("--action", required=True, help="команда без shell, например 'docker stop -t 20 <id>'")
p.add_argument("--action-log")
p.add_argument("--target-instance", help="X-Instance-Id реплики, которую останавливает action")
p.add_argument("--label", default="")
p.add_argument("--output")
a = p.parse_args()
s = Bench(a).run()
brief = {k: v for k, v in s.items() if k != "timeline"}
print(json.dumps(brief, ensure_ascii=False, indent=2))
if a.output:
Path(a.output).write_text(json.dumps(s, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print("PASS" if s["pass"] else "FAIL")
return 0 if s["pass"] else 1
if __name__ == "__main__":
sys.exit(main())
Binary file not shown.

After

Width:  |  Height:  |  Size: 8.1 KiB

+130
View File
@@ -0,0 +1,130 @@
#!/usr/bin/env python3
"""Конкурентная идемпотентность через разные реплики (lab3, уровни 3–4).
Сценарий на каждый раунд:
A) PARALLEL запросов одновременно отправляют ОДИН И ТОТ ЖЕ ключ и одинаковое тело.
Ожидаем: все 201, у всех один и тот же Message.id, ответы пришли от >=2 реплик,
в истории ровно одно сообщение с этим текстом.
B) Тот же ключ, но половина запросов с другим телом. Ожидаем: побеждает ровно одно
тело; запросы с ним — 201 и один id, запросы с другим телом — 409; дублей нет.
Каждый запрос — отдельное TCP-соединение, поэтому HAProxy (roundrobin) раскладывает их
по репликам. Токены только в памяти; синтетические пользователи создаются заново.
python3 student-tests/idempotency_concurrency.py --rounds 20 --parallel 16
"""
import argparse
import json
import sys
import threading
import urllib.error
import urllib.request
import uuid
from collections import Counter
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client # noqa: E402 (публичный клиент тестов: bootstrap пользователей/чата)
def post(base, token, chat_id, key, text, barrier, out, idx):
data = json.dumps({"text": text}).encode()
req = urllib.request.Request(
base + "/api/v1/chats/" + chat_id + "/messages", data=data, method="POST",
headers={"Authorization": "Bearer " + token, "Content-Type": "application/json",
"Idempotency-Key": key, "Connection": "close"})
barrier.wait()
try:
with urllib.request.urlopen(req, timeout=10) as r:
out[idx] = (r.status, json.loads(r.read()), r.headers.get("X-Instance-Id"), text)
except urllib.error.HTTPError as e:
out[idx] = (e.code, None, e.headers.get("X-Instance-Id"), text)
except Exception as e: # noqa: BLE001 — считаем любую сетевую ошибку
out[idx] = (0, repr(e), None, text)
def burst(base, token, chat_id, key, texts):
barrier = threading.Barrier(len(texts))
out = [None] * len(texts)
threads = [threading.Thread(target=post, args=(base, token, chat_id, key, t, barrier, out, i))
for i, t in enumerate(texts)]
for t in threads:
t.start()
for t in threads:
t.join()
return out
def history_texts(c, actor, chat):
from urllib.parse import quote
texts, path = [], "/api/v1/chats/" + chat["id"] + "/messages?limit=100"
while True:
page = c.call("GET", path, actor=actor, schema="MessagePage")["json"]
texts += [m["text"] for m in page["items"]]
if page["next_cursor"] is None:
return texts
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100&cursor=" + quote(page["next_cursor"], safe="")
def main():
p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--rounds", type=int, default=20)
p.add_argument("--parallel", type=int, default=16)
p.add_argument("--output")
a = p.parse_args()
base = a.base_url.rstrip("/")
c = Client(base)
alice, _bob, _eve, chat = c.bootstrap()
token = alice["token"]
problems, instances = [], Counter()
stats = {"same_body": Counter(), "conflicting_body": Counter()}
for rnd in range(a.rounds):
# A) одинаковое тело
key, text = "same-" + uuid.uuid4().hex, "Конкурентный повтор " + uuid.uuid4().hex
res = burst(base, token, chat["id"], key, [text] * a.parallel)
stats["same_body"].update(str(r[0]) for r in res)
ids = {r[1]["id"] for r in res if r[0] == 201}
seen = {r[2] for r in res if r[2]}
instances.update(r[2] for r in res if r[2])
if any(r[0] != 201 for r in res) or len(ids) != 1:
problems.append("round %d same-body: statuses=%s ids=%d" % (rnd, Counter(r[0] for r in res), len(ids)))
if len(seen) < 2:
problems.append("round %d: only %d replica(s) answered" % (rnd, len(seen)))
# B) тот же ключ, два разных тела вперемешку
key = "mixed-" + uuid.uuid4().hex
t1, t2 = "Тело A " + key, "Тело B " + key
res = burst(base, token, chat["id"], key, [t1, t2] * (a.parallel // 2))
stats["conflicting_body"].update(str(r[0]) for r in res)
winners = {r[3] for r in res if r[0] == 201}
ids = {r[1]["id"] for r in res if r[0] == 201}
bad = [r[0] for r in res if r[0] not in (201, 409)]
losers_ok = all(r[0] == 409 for r in res if r[3] not in winners)
if len(winners) != 1 or len(ids) != 1 or bad or not losers_ok:
problems.append("round %d mixed-body: winners=%d ids=%d bad=%s" % (rnd, len(winners), len(ids), bad))
texts = history_texts(c, alice, chat)
dupes = [t for t, n in Counter(texts).items() if n > 1]
if dupes:
problems.append("duplicated messages in history: %d" % len(dupes))
summary = {
"rounds": a.rounds, "parallel_per_burst": a.parallel,
"requests_total": a.rounds * a.parallel * 2,
"status_counts": {k: dict(v) for k, v in stats.items()},
"replicas_answered": len(instances), "requests_per_replica": sorted(instances.values()),
"messages_in_history": len(texts), "expected_messages": a.rounds * 2,
"duplicates": len(dupes), "problems": problems,
}
if len(texts) != a.rounds * 2:
problems.append("history has %d messages, expected %d" % (len(texts), a.rounds * 2))
print(json.dumps(summary, ensure_ascii=False, indent=2))
if a.output:
Path(a.output).write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print("PASS" if not problems else "FAIL")
return 1 if problems else 0
if __name__ == "__main__":
sys.exit(main())
+208
View File
@@ -0,0 +1,208 @@
#!/usr/bin/env python3
"""Lab6, инцидент 2: медленная БД (долгая блокировка горячей таблицы) против медленного обработчика.
python3 student-tests/incident_db_slow.py --output evidence/incident-db-slow.json
Методика:
0. API пересоздаётся с FAULT_INJECTION=1 (точка slow-handler доступна только по заголовку
X-Fault-Inject; обычные запросы не меняются). Эталон «медленный КОД»: 3 запроса истории с
X-Fault-Inject: slow-handler (sleep 1.5 с в span handler.compute, БД не трогается).
1. Нагрузка traffic.py (4 потока, история + сообщения, без upload), 40 с базовой линии.
2. ОТКАЗ: отдельная сессия psql (как «забытая» миграция) берёт LOCK TABLE sessions IN ACCESS
EXCLUSIVE MODE и держит его. Каждый аутентифицированный запрос ждёт блокировку до
statement_timeout (5 с) или PoolTimeout (3 с) -> 503. Readiness (SELECT 1 отдельным
соединением) остаётся 200: реплики в LB, отказ виден в метриках API, а не LB.
3. Ждём firing MessengerHighErrorRate{source=api} и MessengerDbSlow; через 20 с — снятие
блокировки (pg_terminate_backend); ждём resolved обоих.
Диагностика по сохранённым наблюдениям: trace ошибки (длинный db span, короткий остальной код)
vs trace slow-handler (длинный handler.compute, короткие db spans); гистограммы
db.client.operation.duration и http.server.request.duration, пул (used/pending), логи
event=db.unavailable с trace_id, pg_stat_activity (wait_event_type=Lock).
"""
import argparse
import subprocess
import sys
import time
from lab5lib import ROOT, Client, Failure, Log, check, recreate, sql
from traffic import Traffic
import obslib
ALERTS = ("MessengerHighErrorRate", "MessengerDbSlow")
def alert_states():
out = {}
for a in obslib.prom_alerts():
name = a["labels"].get("alertname")
key = name + ("{source=%s}" % a["labels"]["source"] if "source" in a["labels"] else "")
if out.get(key) != "firing":
out[key] = a["state"]
return out
def series(expr, start, end, step=15):
out = {}
for r in obslib.prom_range(expr, start, end, step):
key = ",".join("%s=%s" % kv for kv in sorted(r["metric"].items()) if kv[0] != "__name__") or "value"
out[key] = [[round(float(t) - start), round(float(v), 4)] for t, v in r["values"] if v not in ("NaN",)]
return out
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--output")
p.add_argument("--baseline", type=int, default=40)
args = p.parse_args()
log = Log("incident 2: slow database (table lock) vs slow handler code")
recreate("api", {"FAULT_INJECTION": "1"})
time.sleep(6) # HAProxy видит новые реплики (DNS hold 2 с, rise 2)
log.step("api recreated with FAULT_INJECTION=1 (slow-handler only by header)")
c = Client(args.base_url, timeout=30)
alice, bob, _eve, chat = c.bootstrap()
for i in range(3):
c.message(alice, chat, "warmup %d" % i)
# ---- эталон «медленный обработчик»
slow = []
for _ in range(3):
r = c.call("GET", "/api/v1/chats/%s/messages?limit=20" % chat["id"], actor=alice,
headers={"X-Fault-Inject": "slow-handler"})
slow.append(r["headers"]["X-Trace-Id"])
normal = c.call("GET", "/api/v1/chats/%s/messages?limit=20" % chat["id"], actor=alice)["headers"]["X-Trace-Id"]
slow_spans = obslib.wait_trace(slow[0], lambda s: any(x["name"] == "handler.compute" for x in s))
normal_spans = obslib.wait_trace(normal, lambda s: any(x["name"].startswith("db ") for x in s))
hc = [s for s in slow_spans if s["name"] == "handler.compute"][0]
db_ms = sum(s["duration_ms"] for s in slow_spans if s["name"].startswith("db "))
log.step("reference: slow handler trace", trace_id=slow[0], server_ms=slow_spans[0]["duration_ms"],
handler_compute_ms=hc["duration_ms"], db_spans_total_ms=round(db_ms, 1))
log.step("alerts before experiment", states=alert_states())
t_wall0 = time.time()
tr = Traffic(c, alice, chat, threads=4, think=0.2, upload_every=0).start()
time.sleep(args.baseline)
base = tr.window(5, args.baseline)
base_db_p95 = obslib.prom_value("messenger:db_operation_seconds:p95_2m")
log.step("baseline", db_p95_s=base_db_p95, **base)
# ---- отказ: блокировка
t_lock = time.time()
lock = subprocess.Popen(
["docker", "compose", "exec", "-T", "db", "sh", "-c",
'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -v ON_ERROR_STOP=1 -q'],
cwd=ROOT, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, text=True)
lock.stdin.write("BEGIN; LOCK TABLE sessions IN ACCESS EXCLUSIVE MODE; SELECT pg_sleep(600); COMMIT;\n")
lock.stdin.close()
log.step("FAULT: LOCK TABLE sessions IN ACCESS EXCLUSIVE MODE held by a separate session")
waits, fired, seen = None, {}, {}
deadline = time.monotonic() + 300
while time.monotonic() < deadline and not all(k in fired for k in ("MessengerHighErrorRate{source=api}", "MessengerDbSlow")):
st = alert_states()
for k, v in st.items():
if seen.get(k) != v:
log.step("alert %s -> %s" % (k, v))
seen[k] = v
if v == "firing" and k not in fired:
fired[k] = round(time.time() - t_lock, 1)
if waits is None and time.time() - t_lock > 20:
waits = sql("SELECT coalesce(wait_event_type,'-'), coalesce(wait_event,'-'), count(*) FROM pg_stat_activity "
"WHERE datname = current_database() AND state = 'active' AND pid <> pg_backend_pid() GROUP BY 1, 2 ORDER BY 3 DESC")
log.step("pg_stat_activity during incident", active_by_wait=[[w[0], w[1], int(w[2])] for w in waits])
time.sleep(5)
check("MessengerHighErrorRate{source=api}" in fired and "MessengerDbSlow" in fired, "alerts fired: %s" % fired)
snap = {
"api_5xx_ratio": obslib.prom_value("messenger:http_error_ratio:rate2m"),
"db_p95_s": obslib.prom_value("messenger:db_operation_seconds:p95_2m"),
"db_p95_by_op_s": {r["metric"].get("db_operation_name"): round(float(r["value"][1]), 3) for r in obslib.prom_query(
'histogram_quantile(0.95, sum by (le, db_operation_name) (rate(db_client_operation_duration_seconds_bucket{job="messenger-api"}[1m])))')
if r["value"][1] != "NaN"},
"pool_used": obslib.prom_value('sum(db_client_connection_count{job="messenger-api", db_client_connection_state="used"})'),
"pool_pending": obslib.prom_value('sum(db_client_connection_pending_requests{job="messenger-api"})'),
"error_types_rps": {r["metric"].get("error_type"): round(float(r["value"][1]), 2) for r in obslib.prom_query(
'sum by (error_type) (rate(http_server_request_duration_seconds_count{job="messenger-api", http_response_status_class="5xx"}[1m]))')},
"lb_up_servers": obslib.prom_value('haproxy_backend_active_servers{proxy="be_api"}'),
}
log.step("alerts firing", detect_s=fired, **snap)
time.sleep(20)
during = tr.window(t_lock - t_wall0, time.time() - t_wall0)
log.step("client view during lock", **during)
# ---- восстановление
t_release = time.time()
killed = sql("SELECT count(pg_terminate_backend(pid)) FROM pg_stat_activity WHERE query ILIKE '%pg_sleep(600)%' "
"AND pid <> pg_backend_pid()")
lock.wait(timeout=30)
log.step("RECOVERY: lock holder terminated", terminated=int(killed[0][0]), lock_s=round(t_release - t_lock, 1))
resolved = {}
deadline = time.monotonic() + 400
while time.monotonic() < deadline and len(resolved) < len(fired):
st = alert_states()
for k in fired:
if k not in resolved and st.get(k, "inactive") == "inactive":
resolved[k] = round(time.time() - t_release, 1)
log.step("alert %s resolved" % k, after_release_s=resolved[k])
time.sleep(5)
check(len(resolved) == len(fired), "alerts resolved: %s" % resolved)
time.sleep(10)
tr.stop()
after = tr.window(time.time() - t_wall0 - 10, time.time() - t_wall0)
log.step("after recovery", **after)
# ---- трасса и логи ошибки
found = obslib.tempo_search('{ resource.service.name = "messenger-api" && kind = server && status = error }',
t_lock, t_release + 5, limit=10)
tids = [t["traceID"] for t in (found or {}).get("traces", [])]
check(tids, "error traces in Tempo for the lock window")
err_spans = obslib.wait_trace(tids[0])
db_err = [s for s in err_spans if s["name"].startswith("db ")]
worst = max(db_err, key=lambda s: s["duration_ms"]) if db_err else None
server_ms = max(s["duration_ms"] for s in err_spans)
log.step("error trace during lock", trace_id=tids[0], server_ms=server_ms,
slowest_db_span=worst and worst["name"], slowest_db_ms=worst and worst["duration_ms"],
db_share=round(sum(s["duration_ms"] for s in db_err) / server_ms, 3) if db_err else None,
error_type=[s["attrs"].get("error.type") for s in err_spans if s["kind"] == "SPAN_KIND_SERVER"])
dlogs = obslib.loki_query('{service_name="messenger-api"} | event="db.unavailable"', t_lock, t_release + 10, limit=500)
sample = dlogs[0] if dlogs else {}
log.step("API logs event=db.unavailable (Loki)", count=len(dlogs),
sample_trace_id=sample.get("labels", {}).get("trace_id"), sample_error_type=sample.get("labels", {}).get("error_type"),
sample=sample.get("line", "")[:120])
recreate("api")
log.step("api restored with FAULT_INJECTION=0")
end = time.time()
evidence = {
"timeline_s": {"lock_taken": 0, "alerts_firing": fired, "lock_released": round(t_release - t_lock, 1),
"alerts_resolved_after_release": resolved},
"snapshot_firing": snap,
"pg_stat_activity": waits,
"traffic_by_10s": tr.summary_by(10),
"trace_slow_handler": obslib.tree(slow_spans),
"trace_normal": obslib.tree(normal_spans),
"trace_db_lock_error": obslib.tree(err_spans),
"prometheus": {
"api_5xx_ratio": series("messenger:http_error_ratio:rate2m", t_wall0, end),
"lb_5xx_ratio": series("messenger:lb_error_ratio:rate2m", t_wall0, end),
"db_p95_s": series("messenger:db_operation_seconds:p95_2m", t_wall0, end),
"http_p95_s": series("messenger:http_latency_seconds:p95_5m", t_wall0, end),
"pool_used": series('sum(db_client_connection_count{job="messenger-api", db_client_connection_state="used"})', t_wall0, end),
"pool_pending": series('sum(db_client_connection_pending_requests{job="messenger-api"})', t_wall0, end),
"pool_wait_p95_s": series('histogram_quantile(0.95, sum by (le) (rate(db_client_connection_wait_time_seconds_bucket{job="messenger-api"}[1m])))', t_wall0, end),
"alerts": series('max by (alertname, source, alertstate) (ALERTS{alertname=~"MessengerHighErrorRate|MessengerDbSlow|MessengerDbPoolSaturated|MessengerApiLatencyHigh"})', t_wall0, end),
},
}
log.save(args.output, **evidence)
print("PASS: DB lock detected %s; resolved after release %s" % (fired, resolved))
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except Failure as exc:
print("FAIL:", exc)
try:
sql("SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE query ILIKE '%pg_sleep(600)%' AND pid <> pg_backend_pid()")
recreate("api")
except Exception:
pass
sys.exit(1)
+164
View File
@@ -0,0 +1,164 @@
#!/usr/bin/env python3
"""Lab6, инцидент 1: остановка всех worker под нагрузкой -> рост возраста заданий -> alert -> восстановление.
python3 student-tests/incident_worker_stop.py --output evidence/incident-worker-stop.json
Методика (повторяемая): смешанная нагрузка traffic.py (4 потока: история + сообщение, каждый
4-й цикл — upload 64x48 PNG); 45 с базовой линии; `docker compose stop worker`; ждём firing
MessengerQueueLagGrowing (ready lag > 30 с, не убывает, for 1m); ещё 20 с; `docker compose up worker`;
ждём, пока backlog = 0 и alert снят (resolved). Диагностика — ТОЛЬКО по сохранённым наблюдениям:
ряды Prometheus (lag, backlog, RabbitMQ ready, processed по исходам, time to ready), события
alerts (ряд ALERTS), трасса upload из окна отказа (разрыв send -> process), логи worker в Loki.
"""
import argparse
import sys
import time
from lab5lib import Client, Failure, Log, check, compose, sql
from traffic import Traffic
import obslib
ALERT = "MessengerQueueLagGrowing"
def alert_state(name):
states = [a["state"] for a in obslib.prom_alerts() if a["labels"].get("alertname") == name]
return "firing" if "firing" in states else ("pending" if "pending" in states else "inactive")
def wait_alert(name, wanted, timeout, log, every=5):
deadline = time.monotonic() + timeout
last = None
while time.monotonic() < deadline:
st = alert_state(name)
if st != last:
log.step("alert %s -> %s" % (name, st))
last = st
if st in wanted:
return st
time.sleep(every)
raise Failure("alert %s did not reach %s in %ss (last %s)" % (name, wanted, timeout, last))
def series(expr, start, end, step=15):
out = {}
for r in obslib.prom_range(expr, start, end, step):
key = ",".join("%s=%s" % kv for kv in sorted(r["metric"].items()) if kv[0] != "__name__") or "value"
out[key] = [[round(float(t) - start), round(float(v), 3)] for t, v in r["values"]]
return out
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--output")
p.add_argument("--baseline", type=int, default=45)
args = p.parse_args()
log = Log("incident 1: all workers stopped under load")
c = Client(args.base_url, timeout=30)
alice, bob, _eve, chat = c.bootstrap()
check(alert_state(ALERT) == "inactive", "alert must be inactive before the experiment")
t_wall0 = time.time()
tr = Traffic(c, alice, chat, threads=4, think=0.2, upload_every=4).start()
log.step("traffic started", threads=4, think_s=0.2, upload_every=4)
time.sleep(args.baseline)
base = tr.window(5, args.baseline)
log.step("baseline", **base)
t_stop = time.time()
compose("stop", "worker")
log.step("FAULT: docker compose stop worker",
running=compose("ps", "-q", "--status", "running", "worker").stdout.split())
wait_alert(ALERT, ("firing",), 300, log)
t_fire = time.time()
lag_at_fire = obslib.prom_value("max(messenger_jobs_ready_lag_seconds)")
backlog_at_fire = obslib.prom_value('max(messenger_jobs_count{messenger_job_status="queued"})')
rmq_ready = obslib.prom_value('sum(rabbitmq_detailed_queue_messages_ready{queue="attachments.process.v1"})')
log.step("alert firing", detect_s=round(t_fire - t_stop, 1), ready_lag_s=lag_at_fire,
queued_jobs_db=backlog_at_fire, rabbitmq_ready=rmq_ready)
time.sleep(20)
outage_api = tr.window(t_stop - t_wall0, time.time() - t_wall0)
log.step("API during worker outage", **outage_api)
t_start = time.time()
compose("up", "-d", "--no-deps", "--no-recreate", "--wait", "worker", timeout=200)
log.step("RECOVERY: docker compose up worker", outage_s=round(t_start - t_stop, 1))
# Снятие alert и опустошение backlog фиксируются независимо: alert снимается, как только
# lag перестаёт расти (система восстанавливается), backlog может дренироваться дольше.
t_drain = t_resolved = None
deadline = time.monotonic() + 420
while (t_drain is None or t_resolved is None) and time.monotonic() < deadline:
if t_resolved is None and alert_state(ALERT) == "inactive":
t_resolved = time.time()
log.step("alert resolved", after_worker_start_s=round(t_resolved - t_start, 1),
ready_lag_s=obslib.prom_value("max(messenger_jobs_ready_lag_seconds)"))
if t_drain is None and (obslib.prom_value("max(messenger_jobs_ready_lag_seconds)", default=99) or 0) < 5:
t_drain = time.time()
log.step("backlog drained: ready lag < 5 s", after_worker_start_s=round(t_drain - t_start, 1),
queued_jobs_db=obslib.prom_value('max(messenger_jobs_count{messenger_job_status="queued"})'))
time.sleep(3)
check(t_drain and t_resolved, "recovery not observed")
time.sleep(15)
tr.stop()
after = tr.window(max(t_resolved, t_drain) - t_wall0, time.time() - t_wall0)
log.step("after recovery", **after)
# ---- доказательства из хранилищ (только сохранённые наблюдения)
rows = sql("SELECT a.status, count(*) FROM attachments a WHERE a.chat_id = '%s' GROUP BY 1 ORDER BY 1" % chat["id"])
statuses = {r[0]: int(r[1]) for r in rows}
check(set(statuses) == {"ready"}, "all uploads of the experiment are ready: %s" % statuses)
# трасса upload, принятого посередине отказа
mid = [aid for (t, aid) in tr.uploads if t_stop - t_wall0 + 10 <= t <= t_start - t_wall0 - 5]
check(mid, "uploads during outage")
tp = sql("SELECT o.payload->>'traceparent' FROM outbox o JOIN jobs j ON j.id = o.job_id "
"WHERE j.attachment_id = '%s' ORDER BY o.id LIMIT 1" % mid[len(mid) // 2])[0][0]
trace_id = tp.split("-")[1]
spans = obslib.wait_trace(trace_id, lambda s: any(x["name"] == "attachments.process.v1 process" for x in s))
send = [s for s in spans if s["name"] == "attachments send"][0]
proc = [s for s in spans if s["name"] == "attachments.process.v1 process"][0]
queue_gap = round(proc["start"] - send["end"], 1)
log.step("trace of an upload accepted during outage", trace_id=trace_id, publish_to_consume_gap_s=queue_gap,
process_ms=proc["duration_ms"], queue_wait_attr_s=proc["attrs"].get("messenger.job.queue_wait_s"))
wlogs = obslib.loki_query('{service_name="messenger-worker"} | event=~"worker.(draining|stopped|started)"',
t_wall0, time.time(), limit=50)
log.step("worker lifecycle logs (Loki)", events=[(round(w["ts"] - t_stop, 1), w["labels"].get("event"),
w["labels"].get("service_instance_id")) for w in wlogs])
end = time.time()
evidence = {
"timeline_s": {"worker_stopped": 0, "alert_firing": round(t_fire - t_stop, 1),
"worker_started": round(t_start - t_stop, 1), "backlog_drained": round(t_drain - t_stop, 1),
"alert_resolved": round(t_resolved - t_stop, 1)},
"traffic_by_10s": tr.summary_by(10),
"attachments_final": statuses,
"trace_tree": obslib.tree(spans),
"prometheus": {
"ready_lag_s": series("max(messenger_jobs_ready_lag_seconds)", t_wall0, end),
"oldest_queued_age_s": series('max(messenger_jobs_oldest_age_seconds{messenger_job_status="queued"})', t_wall0, end),
"queued_jobs_db": series('max(messenger_jobs_count{messenger_job_status="queued"})', t_wall0, end),
"rabbitmq_ready": series('sum(rabbitmq_detailed_queue_messages_ready{queue="attachments.process.v1"})', t_wall0, end),
"jobs_per_min_by_outcome": series("sum by (messenger_job_outcome) (increase(messenger_jobs_processed_total[1m]))", t_wall0, end),
"time_to_ready_p95_s": series('histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[1m])))', t_wall0, end),
"worker_utilization": series("sum(rate(messenger_worker_busy_time_seconds_total[1m])) / sum(last_over_time(messenger_worker_capacity[30s]))", t_wall0, end),
"worker_cpu_cores": series('sum by (instance) (rate(container_cpu_time_seconds_total{job="messenger-worker"}[1m]))', t_wall0, end),
"api_5xx_ratio": series("messenger:http_error_ratio:rate2m", t_wall0, end),
"alerts": series('max by (alertname, alertstate) (ALERTS{alertname="%s"})' % ALERT, t_wall0, end),
},
"queries": {
"ready_lag": "max(messenger_jobs_ready_lag_seconds) [s]",
"backlog": 'max(messenger_jobs_count{messenger_job_status="queued"}) [jobs]',
"alert": "max(messenger_jobs_ready_lag_seconds) > 30 and deriv(max(messenger_jobs_ready_lag_seconds)[2m:15s]) >= 0, for 1m",
},
}
log.save(args.output, **evidence)
print("PASS: worker outage detected in %.0fs, alert resolved %.0fs after restart, drained %.0fs after restart; API 5xx during outage %.2f%%" % (
t_fire - t_stop, t_resolved - t_start, t_drain - t_start, 100 * outage_api.get("error_ratio_5xx", 0)))
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except Failure as exc:
print("FAIL:", exc)
sys.exit(1)
+120
View File
@@ -0,0 +1,120 @@
#!/usr/bin/env python3
"""Аудит F01: очистка staging janitor и операторский replay не теряют исходник принятой работы.
python3 student-tests/janitor_replay_race.py --output evidence/janitor-replay-race.json
Готовим три failed-вложения (fault-transient-always -> retry_exhausted; worker на время теста
с WORKER_FAULT_INJECTION=1). Перед каждым сценарием «старим» ровно одно вложение (updated_at
на 2 суток назад > STAGING_RETENTION_SECONDS), чтобы janitor считал его staging просроченным.
C (опасное чередование из аудита): janitor уже выбрал кандидата (учебная пауза
JANITOR_PAUSE_AFTER_SELECT_SECONDS), в это время replay коммитится. Ожидаем: janitor под
блокировкой перепроверяет, видит queued и ПРОПУСКАЕТ (staging_skipped_changed); staging
не освобождён; задание доходит до ready.
A (replay -> janitor): replay принят, janitor вложение не трогает, ready.
B (janitor -> replay): janitor снимает staging_key и удаляет объект; replay получает
refused_staging_expired — принятой работы без исходника не возникает.
Инвариант во всех случаях: не бывает «replay принят, а staging удалён».
"""
import argparse
import json
import subprocess
import time
from lab5lib import (Client, Log, SAMPLE_PNG, check, compose, events, ops, recreate, sql, upload, wait_status,
ROOT)
FAULT_ENV = {"WORKER_FAULT_INJECTION": "1", "JOB_RETRY_BASE_SECONDS": "1", "JOB_RETRY_MAX_SECONDS": "4"}
def run_janitor():
t = time.monotonic()
out = compose("exec", "-T", "janitor", "python", "/app/src/janitor.py", "--once").stdout
return json.loads(out.strip().splitlines()[-1]), round(time.monotonic() - t, 2)
def replay(att_id):
proc = compose("exec", "-T", "janitor", "python", "/app/src/ops.py", "replay", att_id, "--reason", "race test",
ok=False)
return json.loads(proc.stdout)["replay"][0]["result"]
def age(att_id):
sql("UPDATE attachments SET updated_at = now() - interval '2 days' WHERE id = '%s'" % att_id)
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--output")
args = p.parse_args()
log = Log("janitor staging cleanup vs operator replay")
c = Client(args.base_url, timeout=30)
alice, bob, _eve, chat = c.bootstrap()
recreate("worker", FAULT_ENV)
res = {}
try:
ids = [upload(c, alice, chat, SAMPLE_PNG, "fault-transient-always.png")["id"] for _ in range(3)]
for i in ids:
st = wait_status(c, bob, i, {"failed", "ready"}, 120)
check(st["status"] == "failed" and st["error_code"] == "retry_exhausted", "expected retry_exhausted")
z, x, y = ids
log.step("three failed attachments prepared", ids=ids)
# --- C: janitor выбрал кандидата -> replay закоммитился -> janitor удаляет? -----------
# Это чередование, которое аудит воспроизвёл на старом коде (исходник терялся).
age(z)
jn = subprocess.Popen(["docker", "compose", "exec", "-T", "-e", "JANITOR_PAUSE_AFTER_SELECT_SECONDS=4",
"janitor", "python", "/app/src/janitor.py", "--once"],
cwd=ROOT, stdout=subprocess.PIPE, text=True)
time.sleep(2.0) # janitor уже выбрал z и стоит в паузе
replay_out = replay(z) # replay коммитится между выборкой и захватом
jrep = json.loads(jn.communicate(timeout=60)[0].strip().splitlines()[-1])
ready = wait_status(c, bob, z, {"ready", "failed"}, 60)
ev = events(ops("inspect", z))
res["C_janitor_selected_then_replay"] = {
"attachment_id": z, "janitor_candidates_included_z": z in jrep["staging_candidates"],
"replay": replay_out, "janitor_staging_skipped_changed": jrep["staging_skipped_changed"],
"janitor_staging_failed_expired": jrep["staging_failed_expired"],
"final": ready["status"], "janitor_released_staging": "staging_released" in ev, "events": ev}
check(z in jrep["staging_candidates"] and replay_out == "replayed"
and jrep["staging_skipped_changed"] >= 1 and "staging_released" not in ev
and ready["status"] == "ready", "C: %s" % res["C_janitor_selected_then_replay"])
log.step("C: janitor selected z, replay committed, janitor rechecked under lock and skipped -> ready",
**res["C_janitor_selected_then_replay"])
# --- A: replay, потом janitor --------------------------------------------------
age(x)
r = replay(x)
jrep, _ = run_janitor()
info = ops("inspect", x)
res["A_replay_then_janitor"] = {"attachment_id": x, "replay": r,
"staging_object_present": bool(info["s3_staging_objects"]) or
info["attachment"]["status"] in ("processing", "ready")}
ready = wait_status(c, bob, x, {"ready", "failed"}, 60)
res["A_replay_then_janitor"]["final"] = ready["status"]
check(r == "replayed" and ready["status"] == "ready", "A: %s" % res["A_replay_then_janitor"])
log.step("A: replay first -> janitor leaves it -> ready", **res["A_replay_then_janitor"])
# --- B: janitor, потом replay --------------------------------------------------
age(y)
jrep, _ = run_janitor()
r = replay(y)
info = ops("inspect", y)
res["B_janitor_then_replay"] = {"attachment_id": y, "janitor_staging_failed_expired": jrep["staging_failed_expired"],
"replay": r, "status": info["attachment"]["status"],
"staging_key": info["attachment"]["staging_key"],
"staging_objects": info["s3_staging_objects"],
"events": events(info)[-3:]}
check(jrep["staging_failed_expired"] >= 1 and r == "refused_staging_expired"
and info["attachment"]["status"] == "failed", "B: %s" % res["B_janitor_then_replay"])
log.step("B: janitor first -> replay refused, no job without source", **res["B_janitor_then_replay"])
finally:
recreate("worker")
log.step("workers restored to .env configuration")
log.save(args.output, results=res)
print("PASS: janitor cleanup and replay never lose the source of accepted work")
if __name__ == "__main__":
main()
+175
View File
@@ -0,0 +1,175 @@
"""Общие помощники проверок lab5 (запускаются на хосте, управляют стендом через docker compose).
Токены сессий живут только в памяти процесса и не печатаются. В evidence пишутся ID,
статусы, времена и события заданий — без секретов и содержимого файлов.
"""
import datetime as dt
import json
import os
import random
import struct
import subprocess
import sys
import time
import zlib
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check # noqa: E402,F401
SAMPLE_PNG = (ROOT / "tests/fixtures/sample.png").read_bytes()
def now():
return dt.datetime.now(dt.timezone.utc).strftime("%H:%M:%S.%f")[:-3]
class Log:
def __init__(self, name):
self.name = name
self.steps = []
self.started = time.monotonic()
def step(self, text, **data):
item = {"t": round(time.monotonic() - self.started, 2), "utc": now(), "step": text}
item.update(data)
self.steps.append(item)
print("[%7.2fs] %s %s" % (item["t"], text, json.dumps(data, ensure_ascii=False) if data else ""), flush=True)
def save(self, path, **extra):
if not path:
return
out = {"scenario": self.name, "date_utc": dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds"),
"steps": self.steps}
out.update(extra)
Path(path).parent.mkdir(parents=True, exist_ok=True)
Path(path).write_text(json.dumps(out, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
def compose(*args, env=None, timeout=300, ok=True):
full_env = dict(os.environ)
full_env.update(env or {})
proc = subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, text=True,
env=full_env, timeout=timeout)
if ok and proc.returncode != 0:
raise Failure("docker compose %s failed: %s" % (" ".join(args[:3]), proc.stderr.strip()[-400:]))
return proc
def recreate(service, env=None):
"""Пересоздать сервис с переопределёнными переменными (shell env важнее .env)."""
compose("up", "-d", "--no-deps", "--force-recreate", "--wait", service, env=env, timeout=400)
def sql(query):
proc = subprocess.run(
["docker", "compose", "exec", "-T", "db", "sh", "-c",
'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -tA -F "|" -v ON_ERROR_STOP=1'],
cwd=ROOT, input=query, capture_output=True, text=True, timeout=60)
if proc.returncode != 0:
raise Failure("psql failed: " + proc.stderr.strip()[-300:])
return [line.split("|") for line in proc.stdout.strip().splitlines() if line]
def ops(*args, ok=True):
proc = compose("--profile", "tools", "run", "--rm", "-T", "ops", *args, ok=False, timeout=120)
if ok and proc.returncode not in (0, 3):
raise Failure("ops %s failed: %s" % (args[0], proc.stderr.strip()[-400:]))
try:
return json.loads(proc.stdout)
except ValueError:
raise Failure("ops output is not JSON: " + proc.stdout[-300:] + proc.stderr[-300:])
def queues():
proc = compose("exec", "-T", "broker", "rabbitmqctl", "-q", "-p", "messenger", "list_queues", "name",
"messages", "messages_ready", "messages_unacknowledged", "consumers", "--formatter", "json")
return {q["name"]: {k: q[k] for k in ("messages", "messages_ready", "messages_unacknowledged", "consumers")}
for q in json.loads(proc.stdout)}
def container_ids(service, running_only=True):
args = ["ps", "-q"] + (["--status", "running"] if running_only else []) + [service]
return [x for x in compose(*args).stdout.split() if x]
def upload(c, actor, chat, data, filename="photo.png", ctype="image/png", expected=202):
return c.call("POST", "/api/v1/chats/%s/attachments?filename=%s" % (chat["id"], filename), expected,
actor=actor, raw=data, headers={"Content-Type": ctype},
schema="Attachment" if expected == 202 else None)["json"]
def get_att(c, actor, att_id):
return c.call("GET", "/api/v1/attachments/" + att_id, actor=actor, schema="Attachment")["json"]
def wait_status(c, actor, att_id, statuses, timeout=90, interval=0.3):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
att = get_att(c, actor, att_id)
if att["status"] in statuses:
return att
time.sleep(interval)
raise Failure("attachment %s did not reach %s in %ss (last %s)" % (att_id, statuses, timeout, att["status"]))
def wait_until(fn, timeout, interval=0.5, what="condition"):
deadline = time.monotonic() + timeout
last = None
while time.monotonic() < deadline:
last = fn()
if last:
return last
time.sleep(interval)
raise Failure("timeout waiting for " + what)
def events(info):
return [e["event"] for e in info["events"]]
def invariants(info):
"""Ключ эффекта: ровно 3 варианта и 4 конечных объекта на (attachment, v1), staging убран."""
names = sorted(v["name"] for v in info["variants"])
finals = [o[0] for o in info["s3_final_objects"]]
return {
"variants": names,
"variants_ok": names == ["crop", "optimized", "thumbnail"],
"final_objects": len(finals),
"final_objects_ok": len(finals) == 4,
"staging_left": info["attachment"]["staging_key"] is not None,
"job_status": info["jobs"][0]["status"],
"attempt": info["jobs"][0]["attempt"],
}
def png(width, height, rgba=False, noise=False, color=(40, 120, 200), seed=1):
"""PNG стандартной библиотекой: шум (несжимаемый) или заливка."""
channels = 4 if rgba else 3
rng = random.Random(seed)
rows = []
if noise:
for _ in range(height):
rows.append(b"\x00" + bytes(rng.getrandbits(8) for _ in range(width * channels)))
else:
px = bytes(color[:3]) + (b"\x80" if rgba else b"")
row = b"\x00" + px * width
rows = [row] * height
raw = b"".join(rows)
def chunk(kind, data):
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
ihdr = struct.pack(">IIBBBBB", width, height, 8, 6 if rgba else 2, 0, 0, 0)
return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw, 6))
+ chunk(b"IEND", b""))
def noise_png_fast(width, height, seed=1):
"""Несжимаемый PNG через os.urandom (быстро для больших размеров)."""
raw = b"".join(b"\x00" + os.urandom(width * 3) for _ in range(height))
def chunk(kind, data):
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw, 1)) + chunk(b"IEND", b"")
+80
View File
@@ -0,0 +1,80 @@
#!/usr/bin/env python3
"""Уровень 4: зависший processing (lease) и fencing опоздавшего worker.
python3 student-tests/lease_takeover.py --output evidence/lease-takeover.json
Worker пересоздаются с WORKER_FAULT_INJECTION=1, JOB_LEASE_SECONDS=10, FAULT_SLOW_SECONDS=25.
1. upload fault-slow.png: worker берёт задание и «долго работает» (продлевает аренду);
2. пока аренда продлевается, второй worker задание не трогает (долгий != зависший);
3. docker pause контейнера-владельца: процесс жив, но заморожен — аренду никто не продлевает;
4. через ~lease reaper (relay) переводит задание в queued, второй worker берёт его -> ready;
5. docker unpause: опоздавший worker обнаруживает потерю аренды и ничего не записывает
(aborted_lease_lost / commit_rejected_lease_lost); вариантов по-прежнему 3, объектов 4.
"""
import argparse
import subprocess
import time
from lab5lib import (Client, Log, SAMPLE_PNG, check, compose, container_ids, events, get_att, invariants, ops,
recreate, upload, wait_status, wait_until)
ENV = {"WORKER_FAULT_INJECTION": "1", "JOB_LEASE_SECONDS": "10", "FAULT_SLOW_SECONDS": "25"}
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--output")
args = p.parse_args()
log = Log("lease expiry of a frozen worker and fencing of its late result")
c = Client(args.base_url, timeout=30)
alice, bob, _eve, chat = c.bootstrap()
recreate("worker", ENV)
log.step("workers recreated", env=ENV, workers=[x[:12] for x in container_ids("worker")])
paused = None
try:
att = upload(c, alice, chat, SAMPLE_PNG, "fault-slow.png")
info = wait_until(lambda: (lambda i: i if i["jobs"][0]["status"] == "processing" else None)(
ops("inspect", att["id"])), 30, 0.5, "processing")
owner = info["jobs"][0]["lease_owner"]
lease1 = info["jobs"][0]["lease_until"]
log.step("claimed", attachment_id=att["id"], lease_owner=owner, lease_until=lease1)
time.sleep(8)
info = ops("inspect", att["id"])
check(info["jobs"][0]["status"] == "processing" and info["jobs"][0]["lease_owner"] == owner, "long job stolen")
log.step("long-running job keeps its lease (heartbeat)", lease_until=info["jobs"][0]["lease_until"],
status=info["jobs"][0]["status"])
host = owner.split(":")[0]
paused = [cid for cid in container_ids("worker") if cid.startswith(host)][0]
subprocess.run(["docker", "pause", paused], check=True, capture_output=True)
t_pause = time.monotonic()
log.step("owner container paused (frozen, no heartbeat)", container=paused[:12])
ready = wait_status(c, bob, att["id"], {"ready", "failed"}, timeout=90)
took = round(time.monotonic() - t_pause, 1)
info = ops("inspect", att["id"])
check(ready["status"] == "ready", "not ready after lease expiry")
new_owner = [e["actor"] for e in info["events"] if e["event"] == "claimed"][-1]
check(new_owner.split(":")[0] != host, "must be taken by the other worker")
log.step("lease expired -> requeued -> other worker finished", seconds_after_pause=took,
new_owner=new_owner, events=events(info))
subprocess.run(["docker", "unpause", paused], check=True, capture_output=True)
paused_id, paused = paused, None
log.step("owner container unpaused")
info = wait_until(lambda: (lambda i: i if {"aborted_lease_lost", "commit_rejected_lease_lost", "error_ignored_lease_lost"} & set(events(i))
else None)(ops("inspect", att["id"])), 60, 1, "late worker fenced")
inv = invariants(info)
after = get_att(c, bob, att["id"])
check(inv["variants_ok"] and inv["final_objects_ok"] and after["status"] == "ready", "invariants")
check(after["variants"] == ready["variants"], "late worker changed published result")
log.step("late worker fenced, result unchanged", events=events(info), invariants=inv)
log.save(args.output, attachment_id=att["id"], paused_container=paused_id[:12], events=info["events"],
invariants=inv)
finally:
if paused:
subprocess.run(["docker", "unpause", paused], capture_output=True)
recreate("worker")
print("PASS: frozen worker loses lease, job recovered, late result fenced")
if __name__ == "__main__":
main()
+172
View File
@@ -0,0 +1,172 @@
#!/usr/bin/env python3
"""Шторм входов: много параллельных POST /auth/sessions с неверным паролем через LB.
Зачем: scrypt (N=2^15, r=8) берёт ~32 MiB на одну проверку пароля, лимит API-реплики
256 MiB. Без ограничения параллельных проверок несколько одновременных входов
приводят к OOM-kill реплики. Скрипт показывает, переживают ли реплики такой шторм.
Что измеряется:
* статусы ответов шторма (ожидаем 401 и, при перегрузке, 503 с Retry-After) и
ответы не в JSON-формате ошибки контракта (например HTML-страницы HAProxy);
* «жертва»: параллельный поток раз в 50 мс читает /users/me действующим токеном —
обычные пользователи не должны получать ошибки из-за шторма входов;
* состояние API-контейнеров до/после: OOMKilled, RestartCount, StartedAt.
Пример: python3 student-tests/login_flood.py --parallel 24 --duration 20 --output evidence/login-flood.json
"""
import argparse
import base64
import json
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
from collections import Counter
TIMEOUT = 10.0
def http(base, method, path, headers=None, body=None):
data = json.dumps(body).encode() if body is not None else None
h = dict(headers or {})
if data is not None:
h["Content-Type"] = "application/json"
req = urllib.request.Request(base + path, data=data, method=method, headers=h)
try:
with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
return r.status, r.headers, r.read()
except urllib.error.HTTPError as e:
return e.code, e.headers, e.read()
def is_contract_error(headers, raw):
if not (headers.get("Content-Type") or "").startswith("application/json"):
return False
try:
err = json.loads(raw)["error"]
return bool(err["code"] and err["message"] and err["request_id"])
except (ValueError, KeyError, TypeError):
return False
def api_containers():
ids = subprocess.run(["docker", "compose", "ps", "-a", "-q", "api"], capture_output=True,
text=True, check=True).stdout.split()
out = {}
for cid in ids:
info = json.loads(subprocess.run(["docker", "inspect", cid], capture_output=True, text=True,
check=True).stdout)[0]
out[info["Name"].lstrip("/")] = {
"status": info["State"]["Status"], "oom_killed": info["State"]["OOMKilled"],
"restart_count": info["RestartCount"], "started_at": info["State"]["StartedAt"]}
return out
def oom_events(since):
"""Имена контейнеров, получивших OOM с момента since (unix time): флаг OOMKilled
сбрасывается после рестарта по restart-policy, поэтому смотрим события Docker."""
out = subprocess.run(["docker", "events", "--since", str(int(since)), "--until", str(int(time.time()) + 1),
"--filter", "type=container", "--filter", "event=oom",
"--format", "{{.Actor.Attributes.name}}"], capture_output=True, text=True).stdout
return sorted(Counter(out.split()).items())
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--parallel", type=int, default=24)
p.add_argument("--duration", type=float, default=20)
p.add_argument("--output")
a = p.parse_args()
base = a.base_url.rstrip("/")
username = "flood_" + uuid.uuid4().hex[:10]
password = "correct-horse-" + uuid.uuid4().hex[:8]
st, _, _ = http(base, "POST", "/api/v1/users",
body={"username": username, "display_name": "Flood", "password": password})
assert st == 201, st
basic = base64.b64encode(("%s:%s" % (username, password)).encode()).decode()
st, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic})
assert st == 201, st
token = json.loads(raw)["token"]
bad = base64.b64encode(("%s:wrong-password-123" % username).encode()).decode()
before = api_containers()
wall0 = time.time()
stop = threading.Event()
lock = threading.Lock()
flood, victim = Counter(), Counter()
non_json_errors = Counter()
retry_after_503 = [0, 0] # [503 всего, из них с Retry-After]
def record(counter, status, headers, raw):
with lock:
counter[str(status)] += 1
if status >= 400 and not is_contract_error(headers, raw):
non_json_errors[str(status)] += 1
if status == 503 and counter is flood:
retry_after_503[0] += 1
retry_after_503[1] += bool(headers.get("Retry-After"))
def flooder():
while not stop.is_set():
try:
record(flood, *http(base, "POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + bad}))
except Exception as exc: # обрыв соединения, timeout
with lock:
flood["exc:" + type(exc).__name__] += 1
def prober():
while not stop.is_set():
try:
record(victim, *http(base, "GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token}))
except Exception as exc:
with lock:
victim["exc:" + type(exc).__name__] += 1
time.sleep(0.05)
threads = [threading.Thread(target=flooder, daemon=True) for _ in range(a.parallel)]
threads.append(threading.Thread(target=prober, daemon=True))
t0 = time.monotonic()
for t in threads:
t.start()
time.sleep(a.duration)
stop.set()
for t in threads:
t.join(TIMEOUT + 1)
elapsed = time.monotonic() - t0
time.sleep(3) # дать restart-policy отработать, если реплика упала
after = api_containers()
restarted = [n for n in after if n in before and (
after[n]["restart_count"] != before[n]["restart_count"]
or after[n]["started_at"] != before[n]["started_at"])]
victim_ok = victim.get("200", 0)
victim_total = sum(victim.values())
summary = {
"parallel": a.parallel, "duration_s": round(elapsed, 1),
"flood_statuses": dict(flood), "flood_rps": round(sum(flood.values()) / elapsed, 1),
"flood_503_with_retry_after": "%d/%d" % (retry_after_503[1], retry_after_503[0]),
"victim_statuses": dict(victim),
"victim_error_rate": round(1 - victim_ok / victim_total, 4) if victim_total else None,
"non_contract_error_bodies": dict(non_json_errors),
"containers_before": before, "containers_after": after,
"oom_events": dict(oom_events(wall0)),
"restarted": restarted,
}
summary["pass"] = (not summary["oom_events"] and not restarted and victim_total > 0
and victim_ok == victim_total and not non_json_errors)
text = json.dumps(summary, ensure_ascii=False, indent=2)
print(text)
if a.output:
with open(a.output, "w", encoding="utf-8") as f:
f.write(text + "\n")
return 0 if summary["pass"] else 1
if __name__ == "__main__":
raise SystemExit(main())
+206
View File
@@ -0,0 +1,206 @@
#!/usr/bin/env python3
"""Lab6, уровни 3 и 4: корреляция сигналов на контролируемых запросах (всё через Grafana).
python3 student-tests/obs_correlation.py --output evidence/obs-correlation.json [--retry]
1. Сообщение: по X-Trace-Id ответа найден trace в Tempo (SERVER span маршрута-шаблона + db spans),
по X-Request-Id — структурный лог event=http.request в Loki с тем же trace_id/span_id.
2. Upload -> ready: ОДИН trace связывает API (POST .../attachments, db, s3 PutObject staging,
PRODUCER «create») -> relay (PRODUCER «attachments send», parent = create) -> worker (CONSUMER
«process», parent = send; db jobs.claim, fetch/transform, s3 PutObject x4, db jobs.complete,
s3 DeleteObject). traceparent в outbox совпадает с trace. Лог worker job.completed — с тем же trace_id.
3. --retry: worker пересоздаётся с WORKER_FAULT_INJECTION=1; fault-transient-1.png — 1-я попытка
получает временную ошибку (retry_scheduled), 2-я — ready; обе попытки и повторная публикация
relay находятся в том же trace. После теста worker возвращается в обычный режим.
4. Утечки: пароль, токен, текст сообщения и filename не встречаются ни в Loki, ни в трассах;
у метрик приложений нет labels user_id/chat_id/... и значений-UUID.
"""
import argparse
import json
import re
import sys
import time
import uuid
from pathlib import Path
from lab5lib import SAMPLE_PNG, Client, Failure, Log, check, ops, recreate, wait_status
import obslib
FORBIDDEN_LABELS = {"user_id", "chat_id", "message_id", "attachment_id", "request_id", "job_id", "url",
"url_full", "url_path", "filename", "text", "trace_id", "span_id"}
UUID_RE = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")
def by_name(spans, name, service=None):
return [s for s in spans if s["name"] == name and (service is None or s["service"] == service)]
def one(spans, name, service=None):
found = by_name(spans, name, service)
check(found, "span %r (%s) not found" % (name, service))
return found[0]
def loki_lines(query, t0, retries=15):
for _ in range(retries):
lines = obslib.loki_query(query, t0 - 30, time.time() + 5, limit=200)
if lines:
return lines
time.sleep(2)
return []
def main():
p = argparse.ArgumentParser()
p.add_argument("--base-url", default=None)
p.add_argument("--output")
p.add_argument("--retry", action="store_true", help="also prove retry chain (recreates worker)")
args = p.parse_args()
log = Log("lab6 signal correlation: request -> trace -> log, upload -> relay -> worker")
c = Client(args.base_url, timeout=30)
t0 = time.time()
alice, bob, eve, chat = c.bootstrap()
marker = "lab6-marker-" + uuid.uuid4().hex
leak_strings = {"message_text": marker, "password": alice["registration"]["password"],
"token": alice["token"]}
result = {}
# ---------------------------------------------------------------- 1. сообщение
r = c.message(alice, chat, marker)
rid, tid, inst = r["headers"]["X-Request-Id"], r["headers"].get("X-Trace-Id"), r["headers"]["X-Instance-Id"]
check(tid and re.fullmatch(r"[0-9a-f]{32}", tid), "X-Trace-Id header missing")
log.step("message sent", request_id=rid, trace_id=tid, instance=inst)
spans = obslib.wait_trace(tid, lambda s: by_name(s, "db add_message"))
server = one(spans, "POST /api/v1/chats/{chat_id}/messages", "messenger-api")
db = one(spans, "db add_message")
check(server["kind"] == "SPAN_KIND_SERVER" and db["kind"] == "SPAN_KIND_CLIENT", "span kinds")
check(server["attrs"].get("http.route") == "/api/v1/chats/{chat_id}/messages", "route template in span")
check(server["attrs"].get("http.response.status_code") in (201, "201"), "status code in span")
check(server["instance"] == inst, "span instance = X-Instance-Id")
log.step("message trace in Tempo", spans=len(spans), server_ms=server["duration_ms"],
db_spans=[s["name"] for s in spans if s["name"].startswith("db ")])
result["message_trace_tree"] = obslib.tree(spans)
lines = loki_lines('{service_name="messenger-api"} | request_id="%s"' % rid, t0)
check(lines, "API log with request_id not found in Loki")
rec = lines[-1]
check(rec["labels"].get("trace_id") == tid, "log trace_id differs from X-Trace-Id")
check(rec["labels"].get("span_id") == server["span_id"], "log span_id differs from server span")
check(rec["labels"].get("event") == "http.request", "log event")
log.step("structured API log in Loki", event=rec["labels"].get("event"), trace_id=rec["labels"].get("trace_id"),
span_id=rec["labels"].get("span_id"), severity=rec["labels"].get("severity_text"),
service_name=rec["labels"].get("service_name"), line=rec["line"][:120])
result["message"] = {"request_id": rid, "trace_id": tid, "loki_labels": sorted(rec["labels"])}
# ---------------------------------------------------------------- 2. upload -> worker
fname = "leakcheck-%s.png" % uuid.uuid4().hex[:10]
leak_strings["filename"] = fname
resp = c.call("POST", "/api/v1/chats/%s/attachments?filename=%s" % (chat["id"], fname), 202, actor=alice,
raw=SAMPLE_PNG, headers={"Content-Type": "image/png"}, schema="Attachment")
att, utid = resp["json"], resp["headers"]["X-Trace-Id"]
ready = wait_status(c, alice, att["id"], ("ready",), timeout=60)
log.step("upload accepted and ready", attachment_id=att["id"], trace_id=utid, status=ready["status"])
need = ["POST /api/v1/chats/{chat_id}/attachments", "attachment.process.v1 create", "attachments send",
"attachments.process.v1 process", "db jobs.complete"]
spans = obslib.wait_trace(utid, lambda s: all(by_name(s, n) for n in need) and by_name(s, "s3 DeleteObject"),
timeout=60)
srv = one(spans, need[0], "messenger-api")
create = one(spans, need[1], "messenger-api")
send = one(spans, need[2], "messenger-relay")
proc = one(spans, need[3], "messenger-worker")
check(create["kind"] == "SPAN_KIND_PRODUCER" and send["kind"] == "SPAN_KIND_PRODUCER", "producer kinds")
check(proc["kind"] == "SPAN_KIND_CONSUMER", "consumer kind")
check(send["parent_id"] == create["span_id"], "relay send span is child of API create span")
check(proc["parent_id"] == send["span_id"], "worker process span is child of relay send span")
puts = [s for s in by_name(spans, "s3 PutObject") if s["service"] == "messenger-worker"]
check(len(puts) == 4, "worker wrote original + 3 variants (got %d)" % len(puts))
check(by_name(spans, "s3 PutObject", "messenger-api"), "API staging PUT span")
services = sorted({s["service"] for s in spans})
check(services == ["messenger-api", "messenger-relay", "messenger-worker"], "services in trace %s" % services)
info = ops("inspect", att["id"])
job_id = info["jobs"][0]["id"]
tps = [o.get("traceparent") for o in info["outbox"]]
check(all(tp and tp.split("-")[1] == utid for tp in tps), "outbox traceparent belongs to upload trace")
gap_ms = round((proc["start"] - srv["end"]) * 1000, 1)
log.step("one trace upload -> relay -> worker", spans=len(spans), services=services, job_id=job_id,
outbox_traceparent=tps[0], process_parent_is_send=True, send_parent_is_create=True,
worker_s3_puts=len(puts), api_to_worker_gap_ms=gap_ms,
process_ms=proc["duration_ms"], outcome=proc["attrs"].get("messenger.job.outcome"))
result["upload_trace_tree"] = obslib.tree(spans)
wl = loki_lines('{service_name="messenger-worker"} | trace_id="%s"' % utid, t0)
events = [w["labels"].get("event") for w in wl]
check("job.claimed" in events and "job.completed" in events, "worker logs for job: %s" % events)
comp = [w for w in wl if w["labels"].get("event") == "job.completed"][0]
check(comp["labels"].get("job_id") == job_id, "job_id in worker log")
log.step("worker structured logs in Loki by trace_id", events=events, job_id=comp["labels"].get("job_id"),
span_id=comp["labels"].get("span_id"), line=comp["line"][:120])
result["upload"] = {"attachment_id": att["id"], "job_id": job_id, "trace_id": utid, "worker_log_events": events}
# ---------------------------------------------------------------- 3. retry в той же трассе
if args.retry:
env = {"WORKER_FAULT_INJECTION": "1", "JOB_RETRY_BASE_SECONDS": "1", "JOB_RETRY_MAX_SECONDS": "4"}
recreate("worker", env)
try:
resp = c.call("POST", "/api/v1/chats/%s/attachments?filename=fault-transient-1.png" % chat["id"], 202,
actor=alice, raw=SAMPLE_PNG, headers={"Content-Type": "image/png"}, schema="Attachment")
ratt, rtid = resp["json"], resp["headers"]["X-Trace-Id"]
wait_status(c, alice, ratt["id"], ("ready",), timeout=90)
spans = obslib.wait_trace(rtid, lambda s: len(by_name(s, "attachments.process.v1 process")) >= 2
and by_name(s, "db jobs.complete"), timeout=60)
procs = by_name(spans, "attachments.process.v1 process")
sends = by_name(spans, "attachments send")
creates = by_name(spans, "attachment.process.v1 create")
outcomes = [s["attrs"].get("messenger.job.outcome") for s in procs]
check(len(procs) == 2 and outcomes == ["retry", "ready"], "attempt outcomes %s" % outcomes)
check(len(sends) == 2 and len(creates) == 2, "two publications (initial + retry)")
retry_create = [s for s in creates if s["service"] == "messenger-worker"]
check(retry_create and retry_create[0]["parent_id"] in {x["span_id"] for x in spans}, "retry create in worker")
check(sends[1]["parent_id"] == retry_create[0]["span_id"], "second send is child of worker retry create")
check(procs[1]["parent_id"] == sends[1]["span_id"], "second attempt consumes second publication")
log.step("retry chain in one trace", trace_id=rtid, attempts=len(procs), outcomes=outcomes,
retry_delay_s=round(procs[1]["start"] - procs[0]["end"], 2),
error_type=procs[0]["attrs"].get("error.type"))
result["retry_trace_tree"] = obslib.tree(spans)
result["retry"] = {"trace_id": rtid, "outcomes": outcomes}
finally:
recreate("worker")
log.step("worker restored without fault injection")
# ---------------------------------------------------------------- 4. утечки
time.sleep(3)
leaks = {}
for name, value in leak_strings.items():
hits = obslib.loki_query('{service_name=~"messenger-.+"} |= `%s`' % value, t0 - 30, time.time() + 5, limit=5)
leaks["loki:" + name] = len(hits)
blobs = json.dumps([obslib.tempo_trace(t) for t in (tid, utid)], ensure_ascii=False)
for name, value in leak_strings.items():
leaks["tempo:" + name] = blobs.count(value)
check(all(v == 0 for v in leaks.values()), "telemetry leak: %s" % leaks)
labels = set(obslib.prom("labels", **{"match[]": '{job=~"messenger-.+"}'})["data"])
bad_labels = sorted(labels & FORBIDDEN_LABELS)
uuid_values = {}
for lab in sorted(labels - {"__name__"}):
vals = obslib.prom("label/%s/values" % lab, **{"match[]": '{job=~"messenger-.+"}'})["data"]
u = [v for v in vals if UUID_RE.search(v)]
if u:
uuid_values[lab] = u[:3]
check(not bad_labels and not uuid_values, "high-cardinality labels: %s %s" % (bad_labels, uuid_values))
log.step("no secrets/bodies in telemetry, no ID labels in metrics", leaks=leaks, metric_labels=sorted(labels))
result["leaks"] = leaks
result["metric_labels"] = sorted(labels)
log.save(args.output, **result)
if args.output:
Path(args.output).with_suffix(".trees.txt").write_text(
"\n".join(["# message trace %s" % tid] + result["message_trace_tree"] + ["", "# upload trace %s" % utid]
+ result["upload_trace_tree"] + (["", "# retry trace %s" % result["retry"]["trace_id"]]
+ result["retry_trace_tree"] if args.retry else [])) + "\n",
encoding="utf-8")
print("PASS: correlation request->trace->log and upload->relay->worker%s" % (" incl. retry" if args.retry else ""))
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except Failure as exc:
print("FAIL:", exc)
sys.exit(1)
+157
View File
@@ -0,0 +1,157 @@
"""Помощники lab6: запросы к Prometheus / Loki / Tempo ЧЕРЕЗ Grafana (datasource proxy).
Так проверка заодно подтверждает, что Grafana видит все три хранилища по provisioning.
Пароль admin Grafana читается из secrets/grafana_admin_password и нигде не печатается.
Только стандартная библиотека.
"""
import base64
import json
import os
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
GRAFANA = os.environ.get("GRAFANA_URL", "http://127.0.0.1:%s" % os.environ.get("GRAFANA_PORT", "3000"))
def _auth_header():
password = (ROOT / "secrets/grafana_admin_password").read_text(encoding="utf-8").strip()
return "Basic " + base64.b64encode(("admin:" + password).encode()).decode()
def grafana(path, params=None, timeout=20, accept="application/json"):
url = GRAFANA + path + ("?" + urllib.parse.urlencode(params, doseq=True) if params else "")
req = urllib.request.Request(url, headers={"Authorization": _auth_header(), "Accept": accept})
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
return json.loads(resp.read() or b"null")
except urllib.error.HTTPError as exc:
if exc.code == 404:
return None
raise RuntimeError("grafana %s -> HTTP %d: %s" % (path, exc.code, exc.read()[:300]))
# ------------------------------------------------------------------ Prometheus
def prom(path, **params):
return grafana("/api/datasources/proxy/uid/prometheus/api/v1/" + path, params)
def prom_query(expr, at=None):
params = {"query": expr}
if at is not None:
params["time"] = "%.3f" % at
data = prom("query", **params)
return data["data"]["result"]
def prom_value(expr, at=None, default=None):
res = prom_query(expr, at)
if not res:
return default
return float(res[0]["value"][1])
def prom_range(expr, start, end, step=15):
data = prom("query_range", query=expr, start="%.3f" % start, end="%.3f" % end, step=str(step))
return data["data"]["result"]
def prom_alerts():
return prom("alerts")["data"]["alerts"]
# ------------------------------------------------------------------ Loki
def loki_query(query, start, end, limit=100, direction="forward"):
data = grafana("/api/datasources/proxy/uid/loki/loki/api/v1/query_range",
{"query": query, "start": str(int(start * 1e9)), "end": str(int(end * 1e9)),
"limit": str(limit), "direction": direction})
out = []
for stream in data["data"]["result"]:
for ts, line, *meta in stream["values"]:
item = {"ts": int(ts) / 1e9, "line": line, "labels": stream["stream"]}
if meta:
item["metadata"] = meta[0]
out.append(item)
out.sort(key=lambda x: x["ts"])
return out
# ------------------------------------------------------------------ Tempo
def tempo_trace(trace_id):
"""Трасса в формате OTLP JSON (batches/resourceSpans) или None, если ещё не доступна."""
return grafana("/api/datasources/proxy/uid/tempo/api/traces/" + trace_id)
def tempo_search(traceql, start, end, limit=20):
return grafana("/api/datasources/proxy/uid/tempo/api/search",
{"q": traceql, "start": str(int(start)), "end": str(int(end)), "limit": str(limit)})
def _attr_value(v):
for key in ("stringValue", "intValue", "boolValue", "doubleValue"):
if key in v:
return v[key]
return v
def _hex(b64_or_hex):
if not b64_or_hex:
return ""
if len(b64_or_hex) in (16, 32) and all(c in "0123456789abcdef" for c in b64_or_hex):
return b64_or_hex
return base64.b64decode(b64_or_hex).hex()
def flatten_spans(trace):
"""[{service, name, kind, span_id, parent_id, start, end, duration_ms, status, attrs}]"""
spans = []
batches = (trace or {}).get("batches") or (trace or {}).get("resourceSpans") or []
for batch in batches:
res = {a["key"]: _attr_value(a["value"]) for a in batch.get("resource", {}).get("attributes", [])}
for scope in batch.get("scopeSpans") or batch.get("instrumentationLibrarySpans") or []:
for s in scope.get("spans", []):
start, end = int(s["startTimeUnixNano"]), int(s["endTimeUnixNano"])
spans.append({
"service": res.get("service.name"), "instance": res.get("service.instance.id"),
"name": s["name"], "kind": s.get("kind", ""), "span_id": _hex(s.get("spanId")),
"parent_id": _hex(s.get("parentSpanId")), "trace_id": _hex(s.get("traceId")),
"start": start / 1e9, "end": end / 1e9, "duration_ms": round((end - start) / 1e6, 3),
"status": (s.get("status") or {}).get("code", "STATUS_CODE_UNSET"),
"attrs": {a["key"]: _attr_value(a["value"]) for a in s.get("attributes", [])}})
spans.sort(key=lambda x: x["start"])
return spans
def wait_trace(trace_id, predicate=None, timeout=60, interval=2):
"""Ждём, пока трасса появится в Tempo (и удовлетворит predicate(spans))."""
deadline = time.monotonic() + timeout
spans = []
while time.monotonic() < deadline:
tr = tempo_trace(trace_id)
spans = flatten_spans(tr) if tr else []
if spans and (predicate is None or predicate(spans)):
return spans
time.sleep(interval)
return spans
def tree(spans):
"""Текстовое дерево трассы (для evidence): отступ = глубина, длительность, сервис."""
by_parent = {}
ids = {s["span_id"] for s in spans}
for s in spans:
by_parent.setdefault(s["parent_id"] if s["parent_id"] in ids else "", []).append(s)
t0 = min((s["start"] for s in spans), default=0)
lines = []
def walk(pid, depth):
for s in sorted(by_parent.get(pid, []), key=lambda x: x["start"]):
lines.append("%s%-44s %-17s +%8.1fms %9.1fms %s%s" % (
" " * depth, s["name"][:44], s["service"] or "", (s["start"] - t0) * 1000, s["duration_ms"],
s["kind"].replace("SPAN_KIND_", ""), " ERROR" if s["status"] == "STATUS_CODE_ERROR" else ""))
walk(s["span_id"], depth + 1)
walk("", 0)
return lines

Some files were not shown because too many files have changed in this diff Show More