forked from mtusi2026/mtusi2026lab6
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b4873fff59 | ||
|
|
c199f6632a |
+100
-10
@@ -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
|
||||
|
||||
@@ -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 содержит инструкцию именно моего решения.
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
@@ -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: {}
|
||||
@@ -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-пакетов образа |
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
@@ -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
@@ -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
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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
|
||||
@@ -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"
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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]
|
||||
@@ -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"]
|
||||
@@ -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"
|
||||
@@ -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"
|
||||
@@ -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
|
||||
@@ -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
|
||||
не вычисляются вовсе (ограничение учебного стенда: нет внешнего мониторинга мониторинга).
|
||||
@@ -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
|
||||
@@ -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
|
||||
);
|
||||
@@ -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);
|
||||
@@ -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),
|
||||
-- поэтому существующие ключи остаются валидными без пересчёта.
|
||||
@@ -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;
|
||||
@@ -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
|
||||
Executable
+323
@@ -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)))
|
||||
Executable
+24
@@ -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; }
|
||||
Executable
+50
@@ -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' ';')"
|
||||
Executable
+114
@@ -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
|
||||
Executable
+12
@@ -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
|
||||
Executable
+69
@@ -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"
|
||||
Executable
+40
@@ -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)
|
||||
Executable
+7
@@ -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
|
||||
Executable
+6
@@ -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
|
||||
Executable
+19
@@ -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
|
||||
Executable
+7
@@ -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
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
@@ -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())
|
||||
@@ -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
@@ -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
@@ -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
@@ -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())
|
||||
@@ -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())
|
||||
@@ -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
File diff suppressed because it is too large
Load Diff
+463
@@ -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
|
||||
@@ -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 {})
|
||||
@@ -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
@@ -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())
|
||||
@@ -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()
|
||||
@@ -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())
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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 |
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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"")
|
||||
@@ -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()
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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
Reference in New Issue
Block a user