Apply completed lab 6 implementation #5

Closed
Gavrikov.V.D_1BPI23218 wants to merge 1 commits from Gavrikov.V.D_1BPI23218/mtusi2026lab6:main into main
50 changed files with 7983 additions and 15 deletions
+2
View File
@@ -0,0 +1,2 @@
# Shell-скрипты запускаются в bash/sh: CRLF при checkout на Windows их ломает.
*.sh text eol=lf
+27
View File
@@ -0,0 +1,27 @@
# Первый этап: сборка приложения через Maven и JDK.
FROM maven:3.9.9-eclipse-temurin-21 AS build
# Рабочая папка внутри контейнера сборки.
WORKDIR /build
# Сначала копируем зависимости для ускорения повторной сборки.
COPY pom.xml .
RUN mvn -B -q dependency:go-offline
# Копируем исходный код и собираем JAR-файл.
COPY src src
RUN mvn -B -q package -DskipTests
# Второй этап: запускаем приложение в лёгком JRE-образе.
FROM eclipse-temurin:21.0.4_7-jre-jammy
WORKDIR /app
# cwebp (libwebp) — кодировщик варианта optimized в worker.
RUN apt-get update && apt-get install -y --no-install-recommends webp && rm -rf /var/lib/apt/lists/*
# OpenTelemetry Java agent 2.10.0: HTTP, JDBC, S3, RabbitMQ, логи Logback → OTLP; включается JAVA_TOOL_OPTIONS.
ADD https://repo1.maven.org/maven2/io/opentelemetry/javaagent/opentelemetry-javaagent/2.10.0/opentelemetry-javaagent-2.10.0.jar /app/opentelemetry-javaagent.jar
RUN chmod 644 /app/opentelemetry-javaagent.jar
# Переносим готовое приложение из этапа сборки.
COPY --from=build /build/target/messenger-1.0.0.jar /app/messenger.jar
# Запускаем контейнер не от root-пользователя.
RUN useradd --system --uid 10001 app
USER 10001
# Приложение слушает порт 8080.
EXPOSE 8080
# Команда запуска Spring Boot-приложения.
ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-jar","/app/messenger.jar"]
+244 -15
View File
@@ -1,37 +1,266 @@
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Гавриков В.Д БПИ2303
- Целевая оценка: **5**, трек 5 — **трек 2 «SLO и обнаружение инцидентов»**
- Commit/PR: после публикации
- Источники и помощь ИИ: OpenTelemetry Java agent 2.10.0 и `opentelemetry-api` (версия из BOM Spring Boot 3.3.5), OpenTelemetry Collector Contrib 0.115.1, Prometheus 3.0.1, Loki 3.3.2, Tempo 2.6.1, Grafana 11.4.0; остальное — как в lab5. Пороги burn-rate — Google SRE Workbook, глава «Alerting on SLOs». Реализация, тесты и отчёт подготовлены с помощью ИИ-ассистента (Claude Code); всё ниже проверено запуском на стенде.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужно: Docker Engine + Compose v2.24+, Python 3.9+. Проверено: macOS 14 (Apple M3 Pro, 11 CPU, 18 GiB), OrbStack, Docker 29.8.2, Compose 5.5.0.
```sh
# 1. Синтетические секреты в secrets/ (как в lab5 + пароль администратора Grafana; в Git их нет):
python3 scripts/init_secrets.py # Windows: py -3 scripts\init_secrets.py
# 2. Сборка и запуск всего стенда вместе с Collector, Prometheus, Loki, Tempo и Grafana (≈1 мин после сборки):
docker compose up -d --build --wait
# 3. Публичный smoke при включённой телеметрии:
make test
# 4. Эксперименты используют учебные отказы, по умолчанию выключенные (FAULT_INJECTION=0):
FAULT_INJECTION=1 docker compose up -d --wait
python3 tests/observability.py traces # уровни 3–4: запрос → trace + лог; upload → retry → S3/DB; проверка утечек (≈1 мин)
python3 tests/observability.py incidents # уровень 4: остановка worker, медленная БД, отказ backend телеметрии (≈9 мин)
python3 tests/observability.py slo # трек 2: всплеск, длительная деградация, отказ (≈19 мин)
docker compose up -d --wait # вернуть FAULT_INJECTION=0
# 5. Возможности lab5 — теми же командами, что в lab5:
python3 tests/attachments_negative.py --with-docker
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && docker compose start api-1 api-2
make test-persistence ACTION_SCRIPT=scripts/restart.sh
scripts/check-private-bucket.sh
```
Grafana: http://localhost:3000, пользователь `admin`, пароль — файл `secrets/grafana_admin_password`. Datasources (Prometheus, Loki, Tempo) и dashboard «Messenger — API, worker, очередь» (папка Messenger, uid `messenger-lab6`) создаются provisioning из `infra/grafana/provisioning`, вручную ничего не набирается. Alerts: Grafana → Alerting → Alert rules (источник Prometheus) или `docker compose exec -T prometheus wget -qO- http://localhost:9090/api/v1/alerts`. Наружу публикуются только nginx :8080 и Grafana :3000. `tests/observability.py` читает телеметрию через datasource proxy Grafana (`--grafana-url`, по умолчанию http://localhost:3000; пароль берёт из `secrets/`, не печатает) и вызывает `docker compose` в каталоге репозитория — запускайте его с теми же `COMPOSE_PROJECT_NAME`/`COMPOSE_FILE`, что и стенд.
Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных и истории телеметрии: `docker compose down -v` (секреты в `secrets/` остаются, см. lab5).
Порядок старта — как в lab5 (кроме nginx: стартует сразу после запуска реплик, не дожидаясь их healthy); добавлены prometheus (healthcheck `/-/ready`), loki (`/ready`), tempo → otel-collector → grafana. API и worker **не зависят** от Collector в `depends_on`: телеметрия не блокирует старт и работу, пока Collector недоступен, данные копятся в ограниченных буферах агента и отбрасываются. Миграция `V5__trace_context.sql` применяется контейнером `migration`, как и раньше.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
api-1 / api-2 (Spring Boot + OTel Java agent) ──┐ OTLP http/protobuf :4318
worker (тот же образ, режим worker, свой agent) ─┤ traces · metrics (раз в 10 с) · logs
▼
otel-collector: memory_limiter → batch → exporter (очередь ≤ 500 батчей, retry ≤ 60 с)
├──────────────────────────────┬─────────────────────────────┐
▼ ▼ ▼
Prometheus: метрики (OTLP receiver), Loki: логи (OTLP, trace_id/ Tempo: трассы (OTLP gRPC)
TSDB 7 дней, правила SLO и alerts span_id в structured metadata) блоки 7 дней
└──────────── Grafana: запросы к трём хранилищам, dashboard, alerts, переходы лог ↔ trace
upload: SERVER «POST /api/v1/chats/{id}/attachments» ─ outbox.traceparent (одна транзакция с jobs) ─► relay:
PRODUCER «attachments publish» (parent = upload) ─ AMQP header traceparent ─► worker: CONSUMER «attachments.process
process» (parent = producer) ─► S3.* / JDBC; retry: новый PRODUCER (parent = неудачная попытка) ─► CONSUMER попытки 2
```
| Роль | Service | Образ | Health | Volume | Назначение хранилища |
| --- | --- | --- | --- | --- | --- |
| Приём телеметрии | otel-collector | otel/opentelemetry-collector-contrib:0.115.1 | health_check :13133 (внутри сети) | — | не хранилище: приём OTLP, ограничение памяти, батчи, раздача по сигналам; очереди только в RAM и ограничены |
| Метрики | prometheus | prom/prometheus:v3.0.1 (`--web.enable-otlp-receiver`) | `/-/ready` | promdata, 7 дней | числовые ряды: RPS, histogram latency, jobs, очередь, пул, JVM; вычисление SLI/burn rate и alerts — «что и насколько сломано» |
| Логи | loki | grafana/loki:3.3.2 | `/ready` | lokidata, 168 ч | структурные события с trace_id/span_id, request_id, job_id — «что именно произошло с этим запросом/заданием» |
| Трассы | tempo | grafana/tempo:2.6.1 | — | tempodata, 168 ч | span одного запроса/задания через процессы — «где теряется время и на каком шаге ошибка» |
| Интерфейс | grafana | grafana/grafana:11.4.0 | — | grafanadata (только своя БД: пользователи) | ничего из сигналов не хранит: запросы к трём хранилищам, dashboard и datasources из provisioning |
**Инструментация.** Java agent 2.10.0 подключается через `JAVA_TOOL_OPTIONS=-javaagent:/app/opentelemetry-javaagent.jar` (jar скачивается в Dockerfile по закреплённой версии). Автоматически: server span Tomcat/Spring MVC и метрика `http.server.request.duration`, JDBC (sanitized SQL), пул Hikari, Lettuce (Redis), AWS SDK v2 (S3), RabbitMQ amqp-client (producer/consumer span и перенос `traceparent` в AMQP headers), logback → OTLP logs (с trace_id/span_id при активном span), JVM. Вручную через `opentelemetry-api`: метрики worker, время до ready, gauge очереди, атрибуты `job.attempt`/`job.outcome` и статус ERROR у consumer span при retry/failed, контекст в outbox. Контейнеры migration/jobctl/reconciler работают без агента (короткие CLI-процессы).
**Resource attributes:** `service.name` = messenger-api / messenger-worker, `service.version=6.0.0`, `service.instance.id` (UUID процесса от агента), `deployment.environment.name=lab`, `host.name` = hostname контейнера. В Prometheus: `job` = service.name, `instance` = service.instance.id, дополнительно продвинуты `service_instance_id`, `host_name`, `deployment_environment_name` (`otlp.promote_resource_attributes`).
**Соответствие сигналов контракту** ([contracts/observability.md](contracts/observability.md)):
| Сигнал контракта | Реальное имя | Единица | Атрибуты / labels | Источник |
| --- | --- | --- | --- | --- |
| HTTP requests, counter | `http_server_request_duration_seconds_count` | запросы | `http_request_method`, `http_route` — шаблон (`/api/v1/chats/{id}/messages`), `http_response_status_code`; класс статуса — `label_replace` в запросе | agent, semconv `http.server.request.duration` |
| HTTP duration | `http_server_request_duration_seconds_bucket` | с | те же; buckets 0.005 … 10 с (по semconv) | agent |
| Jobs processed / failed | `messenger_jobs_processed_total` | {job} | `job_type="attachment.process.v1"`, `outcome` = done / retry / failed / duplicate / fenced | `Worker.record` |
| Job processing duration | `messenger_job_duration_seconds_bucket` | с | `job_type`, `outcome`; buckets 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 30, 60 | `Worker.record` |
| API и worker logs | Loki `{service_name="messenger-api"}` / `{service_name="messenger-worker"}` | — | stream labels: `service_name`, `service_instance_id`, `deployment_environment_name`; structured metadata: `trace_id`, `span_id`, `severity_text`, `event`, `scope_name`; access log `event=http.request` с `http_route`, `http_request_method`, `http_response_status_code`, `request_id` | logback → agent |
| API и worker traces | Tempo, `service.name` | — | SERVER по шаблону маршрута, PRODUCER `attachments publish`, CONSUMER `attachments.process process` (`job.attempt`, `job.outcome`, ERROR при retry/failed), CLIENT JDBC/S3/Redis | agent + `Worker.tag` |
| Queue depth / oldest job age | `messenger_queue_depth`, `messenger_queue_oldest_age_seconds` | {job}, с | `queue="attachments.process"`; источник — таблица `jobs` (источник истины); отдают API и worker, в запросах `max()` | `Jobs` |
| Pool / saturation | `db_client_connections_usage{state="used"/"idle"}`, `db_client_connections_pending_requests`; `messenger_worker_busy` / `messenger_worker_capacity`; `jvm_cpu_recent_utilization_ratio`, `jvm_memory_used_bytes` | соединения, {job}, доля CPU, байты | `pool_name`, `job`, `instance` | agent (Hikari, JVM), `Worker` |
| upload → publish → consume → S3/DB | W3C `traceparent`/`tracestate`: `outbox` (V5) → AMQP headers | — | parent-child (не link) | `Jobs.enqueue`, `Broker.publish`, agent |
| End-to-end time to ready | `messenger_attachment_time_to_ready_seconds_bucket` | с | buckets 0.5, 1, 2, 3, 5, 7.5, 10, 15, 20, 30, 60, 120, 300 | `Jobs.complete` (от `created_at` = COMMIT при 202 до COMMIT ready) |
user_id, chat_id, message_id, attachment_id, request_id, filename и текст в labels метрик не попадают (маршрут — только шаблон). В логах есть технические ID: `request_id` (связь с `X-Request-Id` ответа) и `job_id`/`attachment_id` в тексте событий worker — они нужны для `jobctl` и `job_audit`; данные синтетические.
**Что не экспортируется** и как проверено (`tests/observability.py traces`, блок `leak_check`): тело сообщения, пароль, `Authorization`, session token, байты изображений. SQL — prepared statements + sanitizer агента (значения → `?`), заголовки HTTP агент не пишет, тела запросов и картинки не логируются. Проверка нашла реальную утечку: span Redis содержал `db.statement = "GET session:<token>"` (ключ сессии = сырой токен). Исправлено в `MessengerApplication.sessionKey`: ключ в Redis — `session:<SHA-256 токена>`, сам токен больше не попадает ни в трассы, ни открытым текстом в дамп Redis (разово инвалидирует сессии, выданные до обновления; TTL 1 ч).
**Collector** ([infra/otel/collector.yaml](infra/otel/collector.yaml)): `memory_limiter` первым в каждом pipeline (проверка раз в 1 с, лимит 180 MiB, spike 40 MiB: выше — отказ в приёме, а не рост RAM), `batch` (1024 / 2 с), у каждого exporter `sending_queue` 500 батчей в памяти и `retry_on_failure` ≤ 60 с — дальше данные отбрасываются и считаются в `otelcol_exporter_send_failed_*`/`otelcol_exporter_enqueue_failed_*`; лимит контейнера 256M. Собственные метрики Collector Prometheus опрашивает по :8888. На стороне агента — стандартные буферы SDK (2048 span/записей), при переполнении отбрасываются.
**Dashboard** ([messenger.json](infra/grafana/provisioning/dashboards/messenger.json)), percentile только из histogram buckets всех реплик (`sum by (le)`), не из средних:
| Панель | Запрос (сокращённо) | Единица |
| --- | --- | --- |
| API: запросы/с по маршруту и классу статуса | `sum by (http_route, class) (label_replace(rate(http_server_request_duration_seconds_count{job="messenger-api",http_route!~"/health.*"}[1m]), "class", "${1}xx", "http_response_status_code", "([0-9]).*"))` | req/s |
| API: доля 5xx (без health) | `sum(rate(…{http_response_status_code=~"5.."}[5m])) / sum(rate(…[5m]))` | доля |
| API: p50/p95/p99 | `histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api",http_route!~"/health.*"}[5m])))` | с |
| Worker: задания по исходу | `sum by (outcome) (rate(messenger_jobs_processed_total[5m]))` | {job}/s |
| Worker: длительность попытки p50/p95/p99 | `histogram_quantile(q, sum by (le) (rate(messenger_job_duration_seconds_bucket[5m])))` | с |
| Очередь: глубина и возраст старейшего задания | `max(messenger_queue_depth)`, `max(messenger_queue_oldest_age_seconds)` | {job}, с |
| Worker: занятость | `sum(messenger_worker_busy) / sum(messenger_worker_capacity)` | доля |
| Время до ready p50/p95 | `histogram_quantile(q, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m])))` | с |
| Пул соединений БД | `sum by (job, state) (db_client_connections_usage)`, `sum by (job) (db_client_connections_pending_requests)` | соединения |
| JVM: CPU и память | `avg by (job, host_name) (jvm_cpu_recent_utilization_ratio)`, `sum by (job, host_name) (jvm_memory_used_bytes) / 1048576` | доля, MiB |
| Логи API и worker | Loki `{service_name=~"messenger-api|messenger-worker"}`, trace_id → Tempo | — |
| SLO доступности API: burn rate | `slo:api_errors:ratio_rate{30s,2m30s,1m30s,15m} / 0.01` | × бюджета |
| SLO времени до ready: burn rate | `slo:ttr_slow:ratio_rate… / 0.01` | × бюджета |
### SLI, SLO и alerts
Правила — [infra/prometheus/alerts.yml](infra/prometheus/alerts.yml) (recording rules + alerts, интервал 10 с), runbook — [docs/runbook.md](docs/runbook.md). Доставка наружу не настроена (README: достаточно локального firing/resolved).
- **SLI-1, доступность API** = не-5xx / все ответы API, кроме `/health/*`, по метрике сервера. 4xx — корректный ответ клиенту (неверный пароль, 409), а не отказ сервиса. Числитель и знаменатель — из одного histogram `http_server_request_duration_seconds_count`, по всем репликам.
- **SLO-1: 99 % за 30 дней** (бюджет 1 % = ~7.2 ч полного простоя в месяц). Обоснование: один узел PostgreSQL/Redis/S3/RabbitMQ без резерва, плановые перезапуски и rolling update (lab3) — 99.9 % (43 мин в месяц) этот стенд честно не обеспечит, а 99 % ловит любой заметный пользователю отказ.
- **SLI-2, время до ready** = доля вложений, ставших ready не позже 10 с после durable acceptance (COMMIT при 202). Плохое событие — `> 10 с` (`1 - bucket{le="10"} / count`).
- **SLO-2: 99 % за 30 дней ≤ 10 с.** Обоснование: в норме время до ready — p50 0.67 с, p95 1.03 с, максимум 1.15 с (30 загрузок по одной в секунду, `python3 tests/observability.py ttr`, измерено клиентом от начала запроса до первого опроса со статусом ready, шаг опроса 0.3 с — оценка сверху; [evidence/ttr_baseline.json](evidence/ttr_baseline.json)). Это relay раз в 1 с + обработка 0.2–0.5 с. Порог 10 с ≈ 10× p95 — запас на пачку загрузок и retry с backoff (первые повторы через 0.5–2 с); превью, которое ждут дольше 10 с, пользователь уже замечает. Цель 99 % — по той же причине, что у SLO-1: один worker и один брокер без резерва.
| Alert | Условие | Окна | Порог | for | Severity |
| --- | --- | --- | --- | --- | --- |
| ApiAvailabilityFastBurn | burn rate SLO-1 в обоих окнах | 2m30s и 30s | 14.4 × 1 % | — | page |
| ApiAvailabilitySlowBurn | то же | 15m и 1m30s | 6 × 1 % | — | ticket |
| TimeToReadyFastBurn / SlowBurn | burn rate SLO-2 | те же | 14.4× / 6× | — | page / ticket |
| ApiHighErrorRate (уровень 4, база для сравнения) | доля 5xx | 1m | 5 % | 30s | ticket |
| QueueLagHigh (уровень 4) | `max(messenger_queue_oldest_age_seconds)` | мгновенно | 60 с | 30s | page |
| WorkerAbsent | `absent_over_time(messenger_worker_capacity{job="messenger-worker"}[1m])` | 1m | нет отсчётов | — | page |
Пороги — multiwindow multi-burn-rate из SRE Workbook для окна SLO 30 дней: 14.4× за 1 ч + 5 мин (2 % бюджета за час) и 6× за 6 ч + 30 мин (5 % за 6 ч). Учебный стенд **сжимает время в 24 раза**, чтобы эксперимент шёл минуты: 1 ч → 2m30s, 6 ч → 15m; короткие окна (1/12 длинного: 12.5 с и 75 с) округлены вверх до 30s и 1m30s, чтобы в окне было ≥ 3 отсчёта при экспорте метрик раз в 10 с. Длинное окно не даёт сработать на короткий выброс, короткое — быстро гасит alert после восстановления. OTLP — push, у пропавшего процесса нет staleness-маркеров: поэтому живость worker проверяет `absent_over_time`, а gauge очереди отдают и API-реплики (иначе при остановленном worker последнее значение висело бы 5 мин и QueueLagHigh не сработал бы — это найдено при подготовке инцидента 1).
**Учебный отказ для трека 2.** При `FAULT_INJECTION=1` заголовок `X-Fault-Inject: http-500` даёт ответ 500 в фильтре до обработчика (без побочных эффектов, тело — стандартная ошибка с `request_id`), так нагрузка задаёт точную долю ошибок. В обычном стенде (`FAULT_INJECTION=0`) заголовок игнорируется. Для цепочки с retry — файл `fault-flaky-*`: первая попытка падает временной ошибкой, вторая успешна.
**Что перенесено из lab5 без изменений:** весь API, nginx, идемпотентность, pipeline вложений (outbox, lease, retry/backoff, DLQ, jobctl, варианты), сверка, hooks. **Что изменено:** агент OTel в API и worker, access log `event=http.request`, атрибуты и метрики worker, gauge очереди в `Jobs`, explicit buckets, контекст в outbox (`V5__trace_context.sql`, `Jobs.enqueue` — общий для accept/retry/replay), публикация в контексте причины (`Broker.publish`), ключ сессии Redis = SHA-256 токена, учебные отказы `X-Fault-Inject` и `fault-flaky`, новые сервисы и конфиги в `infra/`; nginx ждёт у реплик `service_started` вместо `service_healthy` и из `scripts/restart.sh` убран `sleep 10` — на этом хосте (55 контейнеров, из них 40 — соседние учебные стенды) полный `down` + `up -d` lab6 с пятью новыми сервисами и агентом OTel занял 23 + 63 с и вместе со `sleep` не укладывался в 90 с hook `tests/resilience.py`; nginx и так перечитывает адреса реплик (`resolve`) и пропускает неготовую (`proxy_next_upstream`).
**Соответствие `.env.example`:** `OTEL_SERVICE_NAME` — messenger-api / messenger-worker (разные), `OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318`, `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf`, `OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab,service.version=6.0.0` — env в `x-otel` compose; дополнительно `OTEL_METRIC_EXPORT_INTERVAL=10000` и захват key-value SLF4J в атрибуты логов. Остальные переменные — как в lab5.
## Доказательства критериев
### Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke при включённой телеметрии | `make test` | `PASS: lab6 public API scenario` (агент OTel в API и worker, Collector и backends работают) | вывод команды |
| Минимум lab5 сохранён | `python3 tests/attachments_negative.py --with-docker`, `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, `python3 tests/pipeline_experiment.py`, `scripts/check-private-bucket.sh` | вложения: `PASS: 12 attachment checks` (первый прогон — один плавающий 502, причина в «Ограничениях»); failover: 2 реплики, 118 записей, 0 ошибок, восстановление записи 1.85 с; persistence: PASS — `docker compose down` + `up -d` всех 13 сервисов с сохранёнными volumes; pipeline lab5: сценарии A/B/C и инварианты PASS за 216.7 с (backoff 781 / 1147 / 3292 / 6579 мс, 27 объектов вариантов = строкам БД, checksums равны); приватный bucket: наружу публикуются только nginx и Grafana | [evidence/lab5_regression.txt](evidence/lab5_regression.txt), [evidence/pipeline_experiment.json](evidence/pipeline_experiment.json) |
| Collector, три хранилища и Grafana в общем стенде; конфиги и provisioning в Git; volumes | `docker compose up -d --build --wait`, `infra/{otel,prometheus,loki,tempo,grafana}` | 13 постоянных сервисов healthy/up; после пересоздания контейнера Prometheus (смена конфига) в TSDB остались 16 минутных точек до рестарта (с 21:27 до 21:42 UTC) — история в volume promdata; трасса и логи из прогона `traces` найдены после остановки/запуска Loki и Tempo в инциденте 3 | вывод команд, [evidence/incidents.json](evidence/incidents.json) |
| API и worker отдают OTLP; в Grafana RPS/errors/duration API, jobs и duration worker | Grafana API → Prometheus | `http_server_request_duration_seconds_count{job="messenger-api"}` по маршрутам, `messenger_jobs_processed_total{outcome}`, `messenger_job_duration_seconds_bucket`, `messenger_attachment_time_to_ready_seconds_bucket`, пул Hikari `db_client_connections_usage{job="messenger-api"/"messenger-worker"}`; datasources `prometheus`, `loki`, `tempo` и dashboard созданы provisioning | вывод команд |
| Структурные логи с trace_id/span_id, без секретов и содержимого | `python3 tests/observability.py traces` | лог запроса: `event=http.request`, `severity_text=INFO`, `trace_id`, `span_id`, `request_id` = заголовку `X-Request-Id`, `http_route=/api/v1/chats/{id}/messages`, статус 201; leak check: текст сообщения в логах/трассах — 0, session token — 0 (до исправления ключа Redis — 2), текст во всех логах Loki — 0 | [evidence/trace_chain.json](evidence/trace_chain.json) |
| Контролируемый запрос → trace и связанный лог | там же: POST сообщения с заданным `traceparent` | trace `8461974b…7750`: SERVER `POST /api/v1/chats/{id}/messages` 13.3 мс → `GET` (Redis, сессия) 0.6 мс, `SELECT messenger` 0.3 мс, `INSERT messenger.idempotency_keys` 0.6 мс, `INSERT messenger.messages` 1.1 мс; в Loki ровно один лог с тем же trace_id и span_id SERVER span | там же |
| Job → worker trace и лог | там же: upload `fault-flaky-trace.png` | trace `0a4cc390…8a77` содержит CONSUMER-span worker обеих попыток; логи worker `job.retry` (WARN, attempt 1) и `job.done` (attempt 2) с тем же trace_id | там же |
| Назначение каждого хранилища объяснено | раздел «Архитектура» | таблица ролей | — |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| W3C context API → broker → worker; producer/consumer spans с parent; цепочка до S3/DB, включая retry | `tests/observability.py traces` | одна трасса: SERVER `POST …/attachments` (API, 57 мс) → PRODUCER `attachments publish` (API relay, parent = upload) → CONSUMER `attachments.process process` attempt 1 (`job.outcome=retry`, ERROR, 116 мс) → PRODUCER `attachments publish` (worker, parent = попытка 1) → CONSUMER attempt 2 (`done`, 164 мс); в той же трассе эффекты worker: `S3.HeadObject/GetObject/CopyObject/PutObject/DeleteObject`, `UPDATE messenger.jobs`, `INSERT messenger.attachment_variants`, `UPDATE messenger.attachments`, `INSERT messenger.outbox` (retry) | [evidence/trace_chain.json](evidence/trace_chain.json) |
| Dashboard: p50/p95/p99, доля ошибок, queue depth/age, DB pool, saturation worker; запросы и единицы; percentile из histogram | provisioning `messenger.json` | 13 панелей, таблица запросов и единиц — в разделе «Архитектура» | [messenger.json](infra/grafana/provisioning/dashboards/messenger.json) |
| Проверяемый SLI/SLO и окно; alert rules на error rate и queue lag | `infra/prometheus/alerts.yml` (`promtool check rules`: 16 rules, SUCCESS) | все группы `health=ok` в `/api/v1/rules`; SLO-1/SLO-2 — раздел «SLI, SLO и alerts» | [alerts.yml](infra/prometheus/alerts.yml) |
| Alerts проверены искусственным отказом: firing → resolved | `tests/observability.py incidents`, `slo` | остановка worker: WorkerAbsent firing +66 с / resolved +23 с после старта, QueueLagHigh +105 с / +34 с, TimeToReady* сработали на разборе backlog и погасли; трек 2: ApiHighErrorRate, ApiAvailabilityFast/SlowBurn firing → resolved на всплеске, деградации и отказе (таблица в «Эксперименты») | [evidence/incidents.json](evidence/incidents.json), [evidence/slo_experiment.json](evidence/slo_experiment.json) |
| Collector: memory limiter/batch, ограниченная буферизация; остановка хранилища не ломает сообщения и не раздувает RAM | `incidents`, сценарий 3 | Loki и Tempo остановлены на 120 с: 1 020 бизнес-запросов без ошибок; RSS Collector 88–99 MiB из 256M; очередь ≤ 33 из 500 батчей; memory_limiter отказов 0; отброшенные данные посчитаны (7 845 span, 264 записи логов, 0 метрик) — см. «Эксперименты» | [evidence/incidents.json](evidence/incidents.json) |
| Разбор двух инцидентов и шаги диагностики | `incidents`, сценарии 1 и 2 + [runbook](docs/runbook.md) | раздел «Эксперименты и отказы» | там же |
### Уровень 5 — трек 2
| Критерий трека | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Обоснованные SLO для API и времени до ready | раздел «SLI, SLO и alerts», `tests/observability.py ttr` | SLO-1 99 % не-5xx, SLO-2 99 % ready ≤ 10 с; норма времени до ready — [evidence/ttr_baseline.json](evidence/ttr_baseline.json) |
| Burn-rate alerts с несколькими окнами | `alerts.yml` | fast (14.4×, 2m30s + 30s) и slow (6×, 15m + 1m30s) для обоих SLO |
| Краткий всплеск и длительная деградация, время обнаружения/восстановления, ложные срабатывания | `python3 tests/observability.py slo` | всплеск 100 % на 20 с (1.85 % бюджета): fast burn — ложное срабатывание (измеренная доля 15.6 % против расчётных 13.3 % у порога 14.4 %), slow burn — нет, наивный порог — ложное; деградация 10 % на 6 мин: slow burn +331 с, fast burn молчит; отказ 100 % на 60 с: fast burn +35.6 с, slow +15.4 с; сброс после восстановления — 32–85 с; 0 пропусков, 0 незапланированных 5xx |
| Runbook, по которому другой студент находит причину | [docs/runbook.md](docs/runbook.md) | шаги метрика → лог → trace → зависимость для каждого alert; применён в инцидентах 1–2 |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: один хост (macOS 14, Apple M3 Pro, OrbStack), все контейнеры с лимитами из compose (API 1 CPU / 512M на реплику, worker 512M, Collector 256M, Prometheus 0.5 CPU / 512M). Нагрузка — `tests/observability.py`: равномерный поток POST сообщений (5 req/s в `incidents`, 10 req/s в `slo`, таймаут клиента 5 с) и в `incidents` ещё загрузка PNG каждые ~2 с. Время в таблицах — секунды от старта прогона (t), сырые данные — JSON в `evidence/`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
### Трек 2: SLO и обнаружение инцидентов
**Гипотеза.** Multiwindow burn-rate (fast 14.4× за 2m30s + 30s, slow 6× за 15m + 1m30s) (1) не поднимает тревогу на короткий всплеск, сжигающий меньше 2 % месячного бюджета; (2) ловит длительную частичную деградацию slow-правилом и полный отказ fast-правилом; (3) гаснет вскоре после восстановления благодаря короткому окну. Простой порог «5xx > 5 % за 1 мин, for 30s» срабатывает на всё подряд, включая всплеск.
**Методика (повторяемая):** `python3 tests/observability.py slo` на стенде с `FAULT_INJECTION=1`. Равномерный поток 10 req/s `POST /api/v1/chats/{id}/messages` (5 потоков, таймаут 5 с); доля запросов с `X-Fault-Inject: http-500` задаёт долю 500 точно (детерминированно: каждый 10-й при 0.1). Фазы: baseline 300 с → всплеск 100 % ошибок → пауза 120 с → деградация 10 % ошибок 360 с → пауза 150 с → отказ 100 % 60 с → пауза 120 с. Скрипт сначала проверяет, что инъекция включена и активных alerts нет, состояние alerts опрашивает каждые 2 с (`/api/v1/alerts` через Grafana), доли ошибок по всем окнам — каждые 10 с; время — от начала фазы. Фазы переключаются с шагом цикла 10 с, поэтому всплеск длился 20 с, а не запланированные 15 (это и вошло в расчёт). «Бюджет, %» — доля месячного бюджета в учебном масштабе: 1 % от 10 req/s × 30 ч (30 дней / 24). Прогон один (≈19 мин); метрики экспортируются раз в 10 с, правила считаются раз в 10 с.
| Фаза | Длительность, с | Доля 500 | ok / 500 / сбоев клиента | Бюджет, % | ApiAvailabilityFastBurn | ApiAvailabilitySlowBurn | ApiHighErrorRate (наивный) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| baseline | 303 | 0 | 3034 / 0 / 1 | 0 | — | — | — |
| всплеск | 20 | 1.0 | 0 / 200 / 0 | 1.85 | firing +33.2 с, горел 18.8 с, resolved +31.9 с после конца — **ложное** | — | firing +52.0 с, resolved +62.4 с — **ложное** |
| пауза | 122 | 0 | 1215 / 0 / 0 | 0 | — | — | — |
| деградация | 363 | 0.10 | 3274 / 360 / 1 | 3.33 | — (верно: burn 10 < 14.4) | **firing +330.9 с**, resolved +48.5 с после конца | firing +71.2 с, resolved +38.4 с |
| пауза | 152 | 0 | 1514 / 0 / 1 | 0 | — | — | — |
| отказ | 60 | 1.0 | 5 / 600 / 0 | 5.56 | **firing +35.6 с**, resolved +35.9 с после конца | firing +15.4 с, resolved +85.0 с | firing +45.8 с, resolved +66.3 с |
| пауза | 121 | 0 | 1215 / 0 / 0 | 0 | — | — | — |
Всего 11 420 запросов: 10 257 успешных, 1 160 внедрённых 500, **0 незапланированных 5xx**, 3 сбоя клиента (таймаут/соединение, не 5xx). Пропущенных инцидентов нет ни у одного правила. Ложные срабатывания (событие, которое по политике SLO не требует реакции, — всплеск на 1.85 % бюджета при пороге page 2 % за час): **fast burn — 1, slow burn — 0, наивный порог — 1**. Сырые данные — [evidence/slo_experiment.json](evidence/slo_experiment.json) (фазы, события alerts, доли ошибок по окнам каждые 10 с).
**Разбор.**
- *Всплеск.* Расчётная доля ошибок в окне 2m30s — 200 / 1500 = 13.3 % (burn 13.3 < 14.4), измеренная (`slo:api_errors:ratio_rate2m30s`) — до 15.6 %: измеренная на 17 % выше расчётной: при экспорте раз в 10 с окно 150 с содержит ~15 отсчётов на ряд, две реплики экспортируют со сдвигом, а `rate()` экстраполирует края окна — погрешность порядка одного-двух отсчётов (7–13 %) на реплику. Запас до порога (8 %) оказался меньше погрешности измерения — fast burn сработал на 18.8 с. Это следствие сжатия окон в 24 раза: в production окно 1 ч при том же интервале экспорта содержит ~360 отсчётов, и один отсчёт — это ~0.3 %. Предлагаемое исправление — `for: 30s` у fast burn: по записанным интервалам оно подавило бы срабатывание на всплеск (горел 18.8 с), а отказ (горел 60.7 с) был бы обнаружен на ~30 с позже (≈ +66 с). Это оценка по записанным данным, повторным прогоном не проверена; правила в репозитории оставлены в проверенном виде. Альтернатива — экспорт метрик раз в 5 с или сжатие в 12 раз (окно 5 мин).
- *Длительная деградация (10 %, burn 10).* Fast burn не сработал (верно). Slow burn сработал через 331 с: к этому моменту окно 15m уже было заполнено трафиком (конец прогона `incidents` и baseline) и содержало 200 ошибок всплеска; модель (200 + 1 ошибка/с · t) / (10 req/s · 900 с) ≥ 6 % даёт t ≥ 340 с — совпадает с измеренным. Без следов всплеска в окне было бы 540 с. Наивный порог сообщил раньше (+71 с), но он же сработал и на всплеск — цена ранности.
- *Отказ (100 %).* Fast burn — +35.6 с: доля в окне 2m30s достигает 14.4 % через 21.6 с отказа, плюс до 10 с экспорта и 10 с вычисления правил. Slow burn — уже +15.4 с: окно 15m ещё держало ошибки деградации (burn 6.4 > 6 на паузе), поэтому хватило короткого окна 1m30s; после свежего инцидента повторная деградация ловится быстрее — это свойство, а не ошибка.
- *Восстановление.* Короткие окна гасят alerts: fast burn — через 32–36 с после конца отказа (окно 30s), slow burn — 49–85 с (окно 1m30s), наивный — 38–66 с. Без короткого окна slow burn продолжал бы гореть: доля в окне 15m после конца деградации оставалась 6.4 % при пороге 6 % (пока ошибки всплеска и деградации не выйдут из окна).
- *SLO-2 (время до ready)* проверено отказом worker (инцидент 1): TimeToReadyFast/SlowBurn сработали через 44 с после запуска worker и погасли через 64 / 125 с. Это событие из прошлого (поздний сигнал) — поэтому рядом QueueLagHigh (+105 с от остановки) и WorkerAbsent (+66 с).
**Вывод.** Гипотеза подтверждена для slow burn (0 ложных, деградация поймана, быстрый сброс) и для обнаружения отказа fast-правилом. Для fast burn на всплеск около порога она не подтвердилась: при сжатых окнах и экспорте раз в 10 с погрешность больше запаса. Ограничения: один прогон без повторов, синтетические ошибки одного маршрута, сжатое время; абсолютные времена обнаружения — учебные.
**Runbook** — [docs/runbook.md](docs/runbook.md): для каждого alert порядок «метрика → лог → trace → зависимость → восстановление → проверка resolved», запросы PromQL/LogQL/TraceQL и признаки, по которым различаются причины (одна реплика или все, один маршрут или все, учебная инъекция; worker мёртв или перегружен; ждём БД или медленный код). По нему разобраны инциденты 1 и 2 ниже.
### Инцидент 1: остановлен worker (153 с)
| t, с | Наблюдение |
| --- | --- |
| 42.4 | `docker compose stop worker` |
| 108.4 | **WorkerAbsent firing** (+66 с: метрик worker нет 1 мин) |
| 147.8 | **QueueLagHigh firing** (+105 с: возраст старейшего задания > 60 с и `for: 30s`) |
| 195 | максимум: в очереди 81 задание, старейшему 169 с |
| 195.4 | `docker compose start worker` |
| 218.8 | WorkerAbsent resolved (+23 с после старта) |
| 228.9 | QueueLagHigh resolved (+34 с) |
| 239.0 | TimeToReadyFastBurn и TimeToReadySlowBurn firing (+44 с): разобранные из backlog вложения стали ready позже 10 с |
| 255.8 | очередь пуста (+60 с) |
| 259.2 / 319.9 | TimeToReadyFastBurn / SlowBurn resolved (короткие окна 30s / 1m30s) |
Пока worker стоял, API принял все 242 загрузки (202, 0 ошибок) и 766 сообщений без ошибок — фоновая обработка отделена от приёма. Разбор только по сохранённым наблюдениям (шаги runbook «QueueLagHigh / WorkerAbsent»): (1) панель очереди — глубина растёт линейно 4 → 81, возраст старейшего задания растёт ~1 с/с, значит задания не забирают; (2) одновременно WorkerAbsent и пустая панель «Worker: занятость» — процесс worker не отдаёт метрики, то есть не жив (не перегружен: при перегрузке занятость = 1 и метрики есть); (3) отсчёты метрик worker прерываются с 21:50:07 до 21:52:56 UTC (170 с, вместе со стартом JVM); в Loki последняя запись `messenger-worker` — `job … done` в 21:50:05, следующие — логи старта Spring в 21:52:51, внутри промежутка записей 0; в Tempo из 50 трасс, пересекающих промежуток, ни один CONSUMER-span не начался внутри него (загрузки этого времени обработаны после старта). Причина — остановленный worker; после запуска backlog разобран за ~60 с. Срабатывание TimeToReady* — следствие уже исправленной причины, а не новый инцидент: SLI времени до ready считается при ready, поэтому видит остановку только задним числом — для этого и нужны QueueLagHigh и WorkerAbsent.
### Инцидент 2: медленная БД (блокировка таблицы messages на 20 с)
`psql: begin; lock table messages in access exclusive mode; select pg_sleep(20); commit;` при t = 255.8. Шесть клиентских запросов упёрлись в таймаут клиента 5 с; сервер завершил их ответом 201 после снятия блокировки, 5xx не было (alerts доступности молчат — это верно: SLO-1 про ошибки). Медленные трассы (Tempo, `minDuration=10s`):
| trace_id | SERVER `POST /api/v1/chats/{id}/messages` | Самый долгий дочерний span | Его длительность |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `1ccc84c5…66fd` | 14.66 с | `INSERT messenger.messages` | 14.64 с |
| `129f48bf…8ba9` | 14.67 с | `INSERT messenger.messages` | 14.65 с |
| `a50f3698…443c` | 19.66 с | `INSERT messenger.messages` | 19.65 с |
Разбор (runbook «Медленная БД»): на панели p99 `POST /api/v1/chats/{id}/messages` за 2 мин = 8.1 с (оценка по histogram: верхний конечный bucket semconv — 10 с, поэтому точные 14.6–19.7 с видны только в trace), доля 5xx не изменилась → проблема в задержке, не в ошибках. В trace ≥ 99.8 % длительности SERVER span занимает один JDBC span `INSERT messenger.messages`, а код обработчика и остальные запросы (`SELECT`, `INSERT idempotency_keys`, Redis) — миллисекунды: ждём БД, а не медленный handler. `db_client_connections_pending_requests` = 0 за всё время — пул не исчерпан, соединение получено, ждёт блокировку внутри PostgreSQL (живое подтверждение — `pg_stat_activity`, `wait_event_type=Lock`). После снятия блокировки p99 вернулся к миллисекундам, 224 следующих запроса — без ошибок.
### Отказ backend телеметрии: Loki и Tempo остановлены на 120 с
| Что измеряли | Результат |
| --- | --- |
| Бизнес-запросы во время и после отказа | 646 и 374 запроса — все успешны, загрузки 202 без ошибок |
| Память Collector (`docker compose stats`, каждые ~11 с) | 88–99 MiB из лимита 256M, без роста по ходу отказа |
| Очередь exporter (`otelcol_exporter_queue_size`) | максимум 33 батча у Loki и 10 у Tempo из 500; после восстановления — 0 |
| Отказы приёма memory_limiter (`otelcol_receiver_refused_*`) | 0 |
| Потери за окно 21:54:30–21:59:30 UTC (`otelcol_exporter_*` из Prometheus) | spans: принято 15 314, доставлено 7 643, отброшено 7 845 — Tempo был недоступен ~3 мин (120 с + собственный старт); логи: принято 1 793, доставлено 1 521, отброшено 264 — Loki поднялся быстрее, очередь дослана; метрики: 0 потерь (Prometheus работал) |
| История до отказа | трасса upload из прогона `traces` (46 span) и её логи worker (2) находятся после рестарта — volumes lokidata/tempodata |
Объяснение: Collector держит батчи в ограниченной очереди в RAM и повторяет их ≤ 60 с; что не доставлено за это окно (или получило неповторяемую ошибку — у остановленного контейнера пропадает DNS-имя), отбрасывается и считается в `otelcol_exporter_send_failed_*`. Память ограничена `memory_limiter` и размером очереди, поэтому отказ backend не роняет ни Collector, ни приложение. Ограничение: очередь не персистентна — рестарт самого Collector во время отказа потерял бы и её (следующий шаг — `file_storage` для sending_queue). Скрипт сначала читал счётчики с суффиксом `_total`, которого у Collector 0.115 нет, и получил нули; верные значения по истории Prometheus записаны в `evidence/incidents.json` (`telemetry_down.loss_counters`), скрипт исправлен.
## Ответы на вопросы защиты
- **Лог, метрика и trace об одном инциденте.** Метрика отвечает «есть ли проблема, где и насколько»: агрегат по всем запросам, дешёвый, на нём alerts (доля 5xx, p99, возраст очереди), но без конкретного запроса. Trace отвечает «где теряется время / на каком шаге ошибка» для одного запроса или задания через процессы (в инциденте 2 почти вся длительность POST — один span `INSERT messenger.messages`, а не код обработчика). Лог отвечает «что именно произошло»: событие с кодом ошибки, `request_id`, `job_id`, attempt; по `trace_id` переходим к trace и обратно.
- **Почему chat_id в labels опасен.** Каждое уникальное сочетание labels — отдельный ряд в памяти head-блока, индексе и чанках TSDB. chat_id не ограничен: рядов становится «чаты × маршруты × статусы × buckets» (у histogram ~15 buckets), например 100 000 чатов × 5 статусов × 15 = 7.5 млн рядов — RAM, диск и время запросов растут вместе с бизнес-данными, а не с нагрузкой. Поэтому в метриках — шаблон маршрута, а конкретные ID — в логах и трассах.
- **Как очередь переносит причинную связь.** Контекст W3C (`traceparent`: trace-id, id родительского span, флаги; `tracestate`) сериализуется в метаданные сообщения (AMQP headers), consumer извлекает его и создаёт свой span дочерним (или со ссылкой-link). Публикация у нас асинхронная (relay в другом потоке/процессе позже), поэтому контекст upload сохраняется в строке `outbox` той же транзакцией, что и job, и relay публикует «от имени» upload; повтор ставится внутри consumer span — следующая попытка становится дочерней к неудачной. Выбран parent-child: у сообщения ровно одна причина; link нужен для fan-in/batch.
- **Почему среднее не заменяет p99 и нельзя усреднять p99 реплик.** Среднее прячет хвост: 99 быстрых и 1 медленный запрос почти не меняют среднее, а пользователь с медленным запросом его видит (и на странице из нескольких вызовов — чаще). Квантиль не аддитивен: если реплика A обслуживает 90 % трафика с p99 = 0.1 с, а B — 10 % с p99 = 5 с, то (0.1 + 5)/2 = 2.55 с не равно p99 общего потока. Правильно — сложить buckets всех реплик (`sum by (le)`) и вычислить `histogram_quantile` один раз; так построены все панели и правила.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Окна burn-rate сжаты в 24 раза ради минутного эксперимента: абсолютные времена обнаружения учебные; в production длинные окна 1 ч / 6 ч и slow burn срабатывает за часы.
- `rate()` по длинному окну, пока история короче окна, считает по имеющимся данным — в начале работы стенда alert чувствительнее; эксперимент начинается с 5 мин нормальной нагрузки, а отклонение учтено в разборе.
- SLI-1 считается на API: отказ всех реплик (502 от nginx) или nginx в него не попадает — нужен счётчик nginx или внешний синтетический probe.
- SLI-2 считается при ready: пока worker полностью стоит, событий нет и TimeToReady* молчат; эту дыру закрывают QueueLagHigh и WorkerAbsent, а TimeToReady* срабатывают уже на разборе backlog.
- Цепочка trace рвётся после истечения lease (sweep в таймере без span) и после `jobctl replay/reprocess/redispatch` (CLI без агента): там новая трасса, связь — по `job_id` в логах и `job_audit`.
- Каждый тик relay (`Jobs.relay`, раз в 1 с в трёх процессах) — отдельная короткая трасса: шум в Tempo; следующий шаг — tail sampling или фильтр в Collector.
- CPU/RAM — метрики JVM от агента; метрик контейнеров (cAdvisor) нет, память Collector в эксперименте снята `docker compose stats`.
- Alertmanager и доставка уведомлений не развёрнуты (по README не требуется).
- Телеметрия за время отказа backend дольше окна retry (60 с) теряется безвозвратно; потери видны в счётчиках Collector.
- Наследство lab3–lab5 в nginx: `proxy_next_upstream … http_503` вместе с `max_fails=3 fail_timeout=10s` засчитывает ответ 503 приложения (например, S3 недоступен) как отказ реплики. После серии таких ответов обе реплики на ≤ 10 с считаются мёртвыми (`no live upstreams` → 502). Поэтому первый прогон `attachments_negative.py` на этом стенде упал: шаг «остановить реплику» шёл сразу за шагом «S3 down», и одно скачивание получило 502. Повторный прогон — 12/12 PASS. Исправление на будущее — не засчитывать `http_503` в `max_fails` (отдельный upstream без `http_503` для GET), в этой работе не менялось.
+476
View File
@@ -0,0 +1,476 @@
# Compose-стенд lab6: nginx → 2 API-реплики → PostgreSQL + Redis + SeaweedFS (S3); RabbitMQ → worker;
# телеметрия: API/worker (OTel Java agent) → OTLP → otel-collector → Prometheus / Loki / Tempo → Grafana.
# Перед первым запуском: python3 scripts/init_secrets.py — секреты появятся в secrets/ (вне Git).
# Общие переменные; FAULT_INJECTION=1 включают только эксперименты (tests/pipeline_experiment.py).
x-env: &env
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/messenger
SPRING_DATASOURCE_USERNAME: messenger
SPRING_DATA_REDIS_HOST: redis
SESSION_TTL_SECONDS: 3600
S3_ENDPOINT: http://s3:8333
S3_REGION: us-east-1
S3_BUCKET: messenger-attachments
JOB_MAX_ATTEMPTS: 5
PIPELINE_VERSION: 1
FAULT_INJECTION: ${FAULT_INJECTION:-0}
# Телеметрия API и worker: OTel Java agent, экспорт OTLP/HTTP в Collector раз в 10 с (метрики).
x-otel: &otel
JAVA_TOOL_OPTIONS: -javaagent:/app/opentelemetry-javaagent.jar
OTEL_SERVICE_NAME: messenger-api
OTEL_EXPORTER_OTLP_ENDPOINT: http://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL: http/protobuf
OTEL_RESOURCE_ATTRIBUTES: deployment.environment.name=lab,service.version=6.0.0
OTEL_METRIC_EXPORT_INTERVAL: 10000
# key-value из SLF4J (event=…) становятся атрибутами записи лога.
OTEL_INSTRUMENTATION_LOGBACK_APPENDER_EXPERIMENTAL_CAPTURE_KEY_VALUE_PAIR_ATTRIBUTES: "true"
# Общая часть API-реплик, worker, migration и инструментов: один образ, разные режимы запуска.
x-api: &api
build: .
image: messenger-api:lab6
environment:
<<: [*env, *otel]
# Секреты читаются Spring как свойства: имя файла в /run/secrets = имя свойства (configtree).
secrets:
- source: db_password
target: spring.datasource.password
- source: redis_password
target: spring.data.redis.password
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
- source: broker_api_url
target: broker.url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
s3-init:
condition: service_completed_successfully
migration:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/ready"]
interval: 5s
timeout: 3s
retries: 3
# Запас на одновременный старт нескольких JVM при лимите 1 CPU; healthy наступает с первой успешной проверки.
start_period: 90s
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
reservations:
cpus: '0.5'
memory: 256M
services:
# Nginx балансирует запросы между API-репликами; единственный опубликованный порт стенда.
nginx:
image: nginx:1.28.0-alpine
ports:
- "8080:8080"
volumes:
- ./infra/nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
# service_started, а не healthy: адреса реплик nginx перечитывает сам (resolve), неготовую реплику
# пропускает (proxy_next_upstream), а `up -d` не ждёт прогрева двух JVM с агентом OTel — перезапуск
# стенда укладывается в 90 с hook из tests/resilience.py.
depends_on:
api-1:
condition: service_started
api-2:
condition: service_started
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 128M
# Две взаимозаменяемые API-реплики без локального состояния.
api-1: *api
api-2: *api
# Worker: отдельный процесс (режим worker) с собственными ключами S3 и пользователем брокера.
worker:
<<: *api
command: ["worker"]
environment:
<<: [*env, *otel]
OTEL_SERVICE_NAME: messenger-worker
WORKER_CONCURRENCY: 2
JOB_TIMEOUT_SECONDS: 60
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:-15}
STAGING_RETENTION_SECONDS: 86400
# Куча до 65% лимита: декодирование одного изображения ограничено ~48 MiB растра.
JAVA_TOOL_OPTIONS: -javaagent:/app/opentelemetry-javaagent.jar -XX:MaxRAMPercentage=65
secrets:
- source: db_password
target: spring.datasource.password
- source: s3_worker_access_key
target: s3.access-key
- source: s3_worker_secret_key
target: s3.secret-key
- source: broker_worker_url
target: broker.url
depends_on:
postgres:
condition: service_healthy
rabbitmq:
condition: service_healthy
s3-init:
condition: service_completed_successfully
migration:
condition: service_completed_successfully
# Живой = подключён к брокеру (файл обновляется каждые 2 с).
healthcheck:
test: ["CMD-SHELL", "test -n \"$$(find /tmp/worker-alive -newermt '-15 seconds' 2>/dev/null)\""]
interval: 5s
timeout: 3s
retries: 3
start_period: 90s
# Операторские команды заданий: docker compose run --rm jobctl status | replay | reprocess | redispatch.
jobctl:
<<: *api
environment: *env
entrypoint: ["java", "-Dfile.encoding=UTF-8", "-jar", "/app/messenger.jar", "jobctl"]
command: []
profiles: ["tools"]
secrets:
- source: db_password
target: spring.datasource.password
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
# Однократные миграции Flyway до запуска реплик; нужен только пароль БД.
migration:
<<: *api
environment: *env
command: ["migrate"]
secrets:
- source: db_password
target: spring.datasource.password
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
# Сверка БД и S3 по требованию: docker compose run --rm reconciler [--apply] [--grace-seconds=N].
reconciler:
<<: *api
environment: *env
# Режим в entrypoint: аргументы docker compose run дописываются к нему.
entrypoint: ["java", "-Dfile.encoding=UTF-8", "-jar", "/app/messenger.jar", "reconcile"]
command: []
profiles: ["tools"]
secrets:
- source: db_password
target: spring.datasource.password
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
depends_on:
postgres:
condition: service_healthy
s3:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
# RabbitMQ: durable quorum-очередь attachments.process + DLQ. Пользователи, права и топология —
# из definitions-файла (secrets/), management UI не включён, порт наружу не публикуется.
rabbitmq:
image: rabbitmq:4.0.5-alpine
# Имя узла rabbit@rabbitmq задаёт каталог данных в volume: без фиксированного hostname
# пересозданный контейнер не увидел бы прежние очереди и сообщения.
hostname: rabbitmq
volumes:
- rabbitmqdata:/var/lib/rabbitmq
- ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/conf.d/90-lab.conf:ro
secrets:
- source: rabbitmq_definitions
target: rabbitmq_definitions.json
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "check_port_connectivity"]
interval: 10s
timeout: 10s
retries: 12
start_period: 20s
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
# Collector: приём OTLP, memory_limiter/batch, ограниченные очереди экспорта (infra/otel/collector.yaml).
otel-collector:
image: otel/opentelemetry-collector-contrib:0.115.1
command: ["--config=/etc/otelcol/config.yaml"]
volumes:
- ./infra/otel/collector.yaml:/etc/otelcol/config.yaml:ro
depends_on:
prometheus:
condition: service_healthy
loki:
condition: service_healthy
tempo:
condition: service_started
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
# Метрики (TSDB в volume, 7 дней), приём OTLP от Collector.
prometheus:
image: prom/prometheus:v3.0.1
command: ["--config.file=/etc/prometheus/prometheus.yml", "--storage.tsdb.path=/prometheus", "--storage.tsdb.retention.time=7d", "--web.enable-otlp-receiver"]
volumes:
- ./infra/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
- ./infra/prometheus/alerts.yml:/etc/prometheus/alerts.yml:ro
- promdata:/prometheus
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:9090/-/ready"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
# Логи (structured metadata с trace_id/span_id), файловое хранилище в volume.
loki:
image: grafana/loki:3.3.2
command: ["-config.file=/etc/loki/loki.yaml"]
volumes:
- ./infra/loki/loki.yaml:/etc/loki/loki.yaml:ro
- lokidata:/loki
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost:3100/ready"]
interval: 5s
timeout: 3s
retries: 30
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
# Трассы (локальные блоки в volume, 7 дней).
tempo:
image: grafana/tempo:2.6.1
command: ["-config.file=/etc/tempo/tempo.yaml"]
volumes:
- ./infra/tempo/tempo.yaml:/etc/tempo/tempo.yaml:ro
- tempodata:/var/tempo
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
# Grafana: только интерфейс и запросы; datasources и dashboard — provisioning из Git.
grafana:
image: grafana/grafana:11.4.0
ports:
- "3000:3000"
environment:
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password
GF_USERS_ALLOW_SIGN_UP: "false"
GF_AUTH_ANONYMOUS_ENABLED: "false"
secrets:
- grafana_admin_password
volumes:
- ./infra/grafana/provisioning:/etc/grafana/provisioning:ro
- grafanadata:/var/lib/grafana
depends_on:
- prometheus
- loki
- tempo
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
# PostgreSQL — источник истины: пользователи, чаты, сообщения, метаданные вложений.
postgres:
image: postgres:16.4
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: '2.0'
memory: 1G
# Redis хранит Bearer-сессии; пароль и AOF заданы в redis.conf из secrets/.
redis:
image: redis:7.4.1
command: ["redis-server", "/run/secrets/redis.conf"]
secrets:
- source: redis_conf
target: redis.conf
- redis_password
volumes:
- redisdata:/data
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
# SeaweedFS: master/volume/filer слушают только 127.0.0.1 внутри контейнера (их HTTP-админки
# без авторизации), в сеть стенда открыт только S3 :8333. Наружу порты не публикуются.
s3:
image: chrislusf/seaweedfs:3.99
command:
- server
- -dir=/data
- -ip=127.0.0.1
- -ip.bind=127.0.0.1
- -s3
- -s3.ip.bind=0.0.0.0
- -s3.port=8333
- -s3.config=/run/secrets/s3_config.json
- -master.volumeSizeLimitMB=1024
- -volume.max=0
# Мягкий предел кучи Go ниже лимита контейнера: без него при 10+ параллельных загрузках
# SeaweedFS упирался в 512M (tests/upload_memory.py, REPORT.md).
environment:
GOMEMLIMIT: 320MiB
secrets:
- source: s3_config
target: s3_config.json
volumes:
- s3data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8333/healthz"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
# Однократный идемпотентный bootstrap приватного bucket (admin-ключи есть только здесь и в s3).
s3-init:
image: curlimages/curl:8.11.1
entrypoint: ["/bin/sh", "/init/s3-init.sh"]
environment:
S3_ENDPOINT: http://s3:8333
S3_REGION: us-east-1
S3_BUCKET: messenger-attachments
volumes:
- ./infra/s3/s3-init.sh:/init/s3-init.sh:ro
secrets:
- s3_admin_access_key
- s3_admin_secret_key
depends_on:
s3:
condition: service_healthy
restart: "no"
# Клиент S3 мимо API для проверок и внедрения сбоев: scripts/check-private-bucket.sh,
# tests/reconcile_experiment.py. Только ключи API; скрипт читается из stdin.
s3-probe:
image: curlimages/curl:8.11.1
profiles: ["tools"]
entrypoint: ["/bin/sh", "-eu", "-s"]
secrets:
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
restart: "no"
volumes:
promdata:
lokidata:
tempodata:
grafanadata:
rabbitmqdata:
pgdata:
redisdata:
s3data:
# Файлы создаёт scripts/init_secrets.py; в Git их нет.
secrets:
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
redis_conf:
file: ./secrets/redis.conf
s3_config:
file: ./secrets/s3_config.json
s3_api_access_key:
file: ./secrets/s3_api_access_key
s3_api_secret_key:
file: ./secrets/s3_api_secret_key
s3_admin_access_key:
file: ./secrets/s3_admin_access_key
s3_admin_secret_key:
file: ./secrets/s3_admin_secret_key
s3_worker_access_key:
file: ./secrets/s3_worker_access_key
s3_worker_secret_key:
file: ./secrets/s3_worker_secret_key
broker_api_url:
file: ./secrets/broker_api_url
broker_worker_url:
file: ./secrets/broker_worker_url
rabbitmq_definitions:
file: ./secrets/rabbitmq_definitions.json
grafana_admin_password:
file: ./secrets/grafana_admin_password
+77
View File
@@ -0,0 +1,77 @@
# Runbook: alerts и инциденты lab6
Правила — `infra/prometheus/alerts.yml`, состояние — Grafana → Alerting (источник Prometheus) или
`docker compose exec -T prometheus wget -qO- http://localhost:9090/api/v1/alerts`. Dashboard —
Grafana → «Messenger — API, worker, очередь» (provisioning, uid `messenger-lab6`).
Порядок всегда один: **метрика** (что и насколько сломано) → **лог** (какая операция, request_id/job_id) →
**trace** (в каком span теряется время или возникает ошибка) → проверка зависимости → восстановление → проверка resolved.
## ApiAvailabilityFastBurn / ApiAvailabilitySlowBurn / ApiHighErrorRate
Смысл: доля 5xx среди бизнес-запросов (без `/health/*`) выше нормы. Fast burn (14.4×, окна 2m30s + 30s) — острый
отказ, нужен немедленный ответ; slow burn (6×, 15m + 1m30s) — длительная частичная деградация; ApiHighErrorRate —
простой порог 5 % за 1 мин, реагирует и на короткие всплески (см. REPORT.md, трек 2).
1. Панель «API: запросы/с по маршруту и классу статуса»: какие маршруты дают 5xx, все или один.
```promql
sum by (http_route, http_response_status_code) (rate(http_server_request_duration_seconds_count{job="messenger-api", http_response_status_code=~"5.."}[5m]))
sum by (instance) (rate(http_server_request_duration_seconds_count{job="messenger-api", http_response_status_code=~"5.."}[5m]))
```
Одна реплика (`instance`) → проблема процесса/контейнера; все реплики и один маршрут → зависимость этого маршрута.
2. Логи ошибок (панель логов или Explore → Loki):
```logql
{service_name="messenger-api"} | event="http.request" | http_response_status_code=~"5.."
{service_name="messenger-api"} | detected_level="error"
```
В записи есть `request_id` (тот же, что в заголовке `X-Request-Id` и в теле ошибки) и `trace_id` → ссылка в Tempo.
3. Trace (Explore → Tempo, TraceQL): `{ resource.service.name = "messenger-api" && status = error }`. Смотрим, какой
дочерний span красный: JDBC (PostgreSQL), `GET`/`SET` Redis, `S3.PutObject`/`GetObject` (SeaweedFS), `attachments publish`
(RabbitMQ).
4. Проверить зависимость: `docker compose ps`; для БД — `db_client_connections_pending_requests` на панели «Пул соединений БД»,
для брокера — `docker compose exec rabbitmq rabbitmq-diagnostics -q check_port_connectivity`.
5. Особый случай учебного стенда: `http_route` пустой/`unmatched`, нет дочерних span, тело `injected fault` — это
инъекция `X-Fault-Inject: http-500` (работает только при `FAULT_INJECTION=1`), а не дефект кода.
6. Восстановление: поднять зависимость (`docker compose start <service>`), убедиться, что доля 5xx на панели падает; fast burn
гаснет через ~30–60 с, slow burn — через ~1–2 мин (короткое окно), ApiHighErrorRate — через ~1 мин.
## QueueLagHigh / WorkerAbsent / TimeToReady*
Смысл: QueueLagHigh — старейшее queued-задание ждёт > 60 с (gauge из таблицы `jobs`, отдают API и worker);
WorkerAbsent — метрик worker нет 1 мин; TimeToReadyFast/SlowBurn — вложения становятся ready дольше 10 с
(считается при ready, поэтому при полностью остановленном worker молчит и срабатывает уже на разборе backlog).
1. Панель «Очередь: глубина и возраст самого старого задания»: возраст растёт линейно, глубина растёт → задания не забирают.
2. WorkerAbsent тоже firing → процесс worker не жив: `docker compose ps worker`, `docker compose logs --tail=50 worker`
(OOM, ошибка старта, healthcheck). Не firing → worker жив, но не успевает или не получает сообщения:
- «Worker: занятость (busy / capacity)» около 1 → насыщение; «Worker: длительность попытки p95» выросла → медленная обработка
(S3, размер картинок, CPU-лимит контейнера);
- занятость около 0 при растущей очереди → сообщения не доходят: `docker compose exec rabbitmq rabbitmqctl list_queues name messages consumers`,
в логах API `outbox relay paused` (брокер недоступен, outbox копится в БД);
- `{service_name="messenger-worker"} | event=~"job.retry|job.failed"` — задания падают и уходят в backoff.
3. По одному заданию: в логе worker `job <job_id> attempt N …` → trace_id → trace от `POST /api/v1/chats/{id}/attachments`
через `attachments publish` до `attachments.process process` и S3/JDBC; повторные попытки — дочерние span той же трассы.
Статус задания: `docker compose --profile tools run --rm jobctl status`.
4. Восстановление: `docker compose start worker` (или устранить причину из п. 2). Проверка: глубина → 0, QueueLagHigh и
WorkerAbsent resolved; TimeToReady* может кратко сработать на разборе backlog и погаснуть по короткому окну.
## Медленная БД (p99 растёт, 5xx нет)
Признак: на «API: длительность p50/p95/p99» p99 вырос, доля 5xx нет; `db_client_connections_pending_requests` > 0 или
`usage{state="used"}` у предела пула.
1. Tempo: `{ resource.service.name = "messenger-api" && duration > 2s }`. Если почти вся длительность SERVER span — это
один JDBC span (`INSERT messenger.messages` и т. п.) — ждём БД; если JDBC span короткие, а SERVER длинный — медленный
код обработчика/внешний вызов.
2. В БД: `docker compose exec -T postgres psql -U messenger -d messenger -c "select pid, wait_event_type, wait_event, now()-xact_start as xact, left(query,60) from pg_stat_activity where datname='messenger' and state<>'idle'"` —
блокировка (`Lock`), долгая транзакция; `select pg_terminate_backend(<pid>)` для зависшей сессии.
3. Проверка: p99 возвращается к норме, pending = 0.
## Недоступен backend телеметрии (Loki/Tempo/Prometheus)
Признак: в Grafana ошибки источника, пустые панели логов/трасс; API отвечает нормально.
1. `docker compose ps loki tempo prometheus`; метрики Collector (если жив Prometheus):
`otelcol_exporter_queue_size`, `otelcol_exporter_send_failed_spans_total`, `otelcol_exporter_send_failed_log_records_total`,
`otelcol_exporter_enqueue_failed_*`.
2. Collector держит очередь ≤ 500 батчей на exporter и повторяет ≤ 60 с, `memory_limiter` (180 MiB) ограничивает память:
данные дольше этого окна теряются и учитываются в `send_failed`/`enqueue_failed`; бизнес-запросы от этого не зависят.
3. Восстановление: `docker compose start loki tempo`; новые логи/трассы появляются через ~10–20 с; пропуск в истории не
восстанавливается.
+398
View File
@@ -0,0 +1,398 @@
{
"worker_stop": {
"stopped_at": 42.4,
"started_at": 195.4,
"backlog_drained_at": 255.8,
"queue": [
{
"t": 54.3,
"depth": 4.0,
"oldest_age_s": 6.3752
},
{
"t": 64.4,
"depth": 8.0,
"oldest_age_s": 16.3758
},
{
"t": 74.4,
"depth": 13.0,
"oldest_age_s": 26.3814
},
{
"t": 85.0,
"depth": 17.0,
"oldest_age_s": 36.376
},
{
"t": 95.0,
"depth": 22.0,
"oldest_age_s": 46.3741
},
{
"t": 105.0,
"depth": 27.0,
"oldest_age_s": 56.3743
},
{
"t": 115.0,
"depth": 32.0,
"oldest_age_s": 66.3743
},
{
"t": 125.1,
"depth": 36.0,
"oldest_age_s": 76.3787
},
{
"t": 135.2,
"depth": 41.0,
"oldest_age_s": 86.376
},
{
"t": 145.2,
"depth": 46.0,
"oldest_age_s": 96.3853
},
{
"t": 155.2,
"depth": 51.0,
"oldest_age_s": 106.3763
},
{
"t": 165.3,
"depth": 56.0,
"oldest_age_s": 116.3741
},
{
"t": 175.3,
"depth": 61.0,
"oldest_age_s": 126.3746
},
{
"t": 185.4,
"depth": 66.0,
"oldest_age_s": 136.3763
},
{
"t": 195.4,
"depth": 70.0,
"oldest_age_s": 146.377
},
{
"t": 205.5,
"depth": 75.0,
"oldest_age_s": 156.3825
},
{
"t": 210.6,
"depth": 75.0,
"oldest_age_s": 156.3825
},
{
"t": 215.6,
"depth": 80.0,
"oldest_age_s": 166.3826
},
{
"t": 220.6,
"depth": 81.0,
"oldest_age_s": 169.4459
},
{
"t": 225.6,
"depth": 23.0,
"oldest_age_s": 46.3507
},
{
"t": 230.7,
"depth": 23.0,
"oldest_age_s": 46.3507
},
{
"t": 235.7,
"depth": 1.0,
"oldest_age_s": 0.4415
},
{
"t": 240.7,
"depth": 1.0,
"oldest_age_s": 0.4415
},
{
"t": 245.7,
"depth": 1.0,
"oldest_age_s": 0.0882
},
{
"t": 250.8,
"depth": 1.0,
"oldest_age_s": 0.0882
},
{
"t": 255.8,
"depth": 0.0,
"oldest_age_s": 0.0
}
]
},
"db_lock": {
"locked_at": 255.8,
"lock_s": 20,
"slow_traces": [
{
"trace_id": "1ccc84c51eb31bcc7041a55932f066fd",
"root": "POST /api/v1/chats/{id}/messages",
"server_s": 14.66,
"slowest_db_span": "INSERT messenger.messages",
"db_s": 14.64
},
{
"trace_id": "129f48bf429d60bc08ff140618078ba9",
"root": "POST /api/v1/chats/{id}/messages",
"server_s": 14.67,
"slowest_db_span": "INSERT messenger.messages",
"db_s": 14.65
},
{
"trace_id": "a50f369854f74ae199c0500f10a2443c",
"root": "POST /api/v1/chats/{id}/messages",
"server_s": 19.66,
"slowest_db_span": "INSERT messenger.messages",
"db_s": 19.65
}
],
"p99_messages_s_2m": 8.125,
"max_pending_connections_2m": 0.0,
"requests": {
"db_locked": {
"ok": 2,
"failed": 6
},
"db_recovered": {
"ok": 224
}
}
},
"telemetry_down": {
"down_s": 120,
"collector": [
{
"t": 315.7,
"collector_mem": "88.48MiB / 256MiB",
"queue_batches": 0.0,
"refused_spans": null
},
{
"t": 326.9,
"collector_mem": "88.5MiB / 256MiB",
"queue_batches": 0.0,
"refused_spans": null
},
{
"t": 338.6,
"collector_mem": "88.55MiB / 256MiB",
"queue_batches": 2.0,
"refused_spans": null
},
{
"t": 350.7,
"collector_mem": "99.13MiB / 256MiB",
"queue_batches": 9.0,
"refused_spans": null
},
{
"t": 361.9,
"collector_mem": "99.14MiB / 256MiB",
"queue_batches": 13.0,
"refused_spans": null
},
{
"t": 373.4,
"collector_mem": "98.91MiB / 256MiB",
"queue_batches": 16.0,
"refused_spans": null
},
{
"t": 384.6,
"collector_mem": "99.36MiB / 256MiB",
"queue_batches": 16.0,
"refused_spans": null
},
{
"t": 396.5,
"collector_mem": "88.94MiB / 256MiB",
"queue_batches": 20.0,
"refused_spans": null
},
{
"t": 407.7,
"collector_mem": "88.92MiB / 256MiB",
"queue_batches": 25.0,
"refused_spans": null
},
{
"t": 419.4,
"collector_mem": "89.33MiB / 256MiB",
"queue_batches": 32.0,
"refused_spans": null
},
{
"t": 430.7,
"collector_mem": "89.37MiB / 256MiB",
"queue_batches": 32.0,
"refused_spans": null
}
],
"lost_before": {
"spans": 0,
"log_records": 0
},
"lost_after": {
"spans": 0,
"log_records": 0
},
"requests": {
"telemetry_down": {
"ok": 646
},
"telemetry_recovered": {
"ok": 374
}
},
"loss_counters": {
"window_utc": [
"21:54:30",
"21:59:30"
],
"increase": {
"otelcol_exporter_sent_spans": 7643.0,
"otelcol_exporter_send_failed_spans": 7845.0,
"otelcol_exporter_sent_log_records": 1521.0,
"otelcol_exporter_send_failed_log_records": 264.0,
"otelcol_exporter_sent_metric_points": 5729.0,
"otelcol_exporter_send_failed_metric_points": 0.0,
"otelcol_receiver_refused_spans": 0.0,
"otelcol_receiver_refused_log_records": 0.0,
"otelcol_receiver_accepted_spans": 15314.0,
"otelcol_receiver_accepted_log_records": 1793.0
},
"max_queue_batches": {
"otlphttp/loki": 33,
"otlp/tempo": 10,
"otlphttp/prometheus": 0
},
"note": "lost_before/lost_after were queried with *_total names that Collector 0.115 does not export (no suffix), hence 0; corrected values from Prometheus history are here"
}
},
"alerts": {
"QueueLagHigh": [
[
147.8,
228.9
]
],
"TimeToReadyFastBurn": [
[
239.0,
259.2
]
],
"TimeToReadySlowBurn": [
[
239.0,
319.9
]
],
"WorkerAbsent": [
[
108.4,
218.8
]
]
},
"uploads": {
"accepted": 242,
"failed": 0
},
"requests": {
"warmup": {
"ok": 200
},
"worker_stopped": {
"ok": 766
},
"worker_recovering": {
"ok": 302
},
"db_locked": {
"ok": 2,
"failed": 6
},
"db_recovered": {
"ok": 224
},
"telemetry_down": {
"ok": 646
},
"telemetry_recovered": {
"ok": 374
}
},
"events": [
{
"t": 108.4,
"alert": "WorkerAbsent",
"from": "inactive",
"to": "firing"
},
{
"t": 119.4,
"alert": "QueueLagHigh",
"from": "inactive",
"to": "pending"
},
{
"t": 147.8,
"alert": "QueueLagHigh",
"from": "pending",
"to": "firing"
},
{
"t": 218.8,
"alert": "WorkerAbsent",
"from": "firing",
"to": "inactive"
},
{
"t": 228.9,
"alert": "QueueLagHigh",
"from": "firing",
"to": "inactive"
},
{
"t": 239.0,
"alert": "TimeToReadySlowBurn",
"from": "inactive",
"to": "firing"
},
{
"t": 239.0,
"alert": "TimeToReadyFastBurn",
"from": "inactive",
"to": "firing"
},
{
"t": 259.2,
"alert": "TimeToReadyFastBurn",
"from": "firing",
"to": "inactive"
},
{
"t": 319.9,
"alert": "TimeToReadySlowBurn",
"from": "firing",
"to": "inactive"
}
]
}
+29
View File
@@ -0,0 +1,29 @@
== negative
PASS variants: original/thumbnail/crop/optimized 200 with own types, garbage 400
PASS S3 down: attachments 503, messages/ready OK, no rows left; recovered after start
PASS upload replica b805dae52d5c stopped: other replica serves identical bytes
PASS: 12 attachment checks
exit
-- nginx errors:
nginx-1 | 192.168.229.1 - - [30/Oct/2026:22:27:15 +0000] "GET /api/v1/attachments/2b92fc3f-8a83-44d1-b591-48e82ddfb3cd/content HTTP/1.1" 502 157 "-" "Python-urllib/3.15" "-"
nginx-1 | 192.168.229.1 - - [30/Oct/2026:22:27:16 +0000] "GET /api/v1/attachments/2b92fc3f-8a83-44d1-b591-48e82ddfb3cd/content HTTP/1.1" 502 157 "-" "Python-urllib/3.15" "-"
nginx-1 | 2026/10/30 22:27:16 [error] 27#27: *184 no live upstreams while connecting to upstream, client: 192.168.229.1, server: localhost, request: "GET /api/v1/attachments/2b92fc3f-8a83-44d1-b591-48e82ddfb3cd/content HTTP/1.1", upstream: "http://api_backend
nginx-1 | 2026/10/30 22:27:17 [warn] 27#27: *187 a client request body is buffered to a temporary file /var/cache/nginx/client_temp/0000000028, client: 192.168.229.1, server: localhost, request: "POST /api/v1/chats/1e8097c5-0a45-4712-8757-00fcbbf68c74/attachm
nginx-1 | 2026/10/30 22:27:20 [error] 27#27: *192 upstream timed out (110: Operation timed out) while connecting to upstream, client: 192.168.229.1, server: localhost, request: "GET /api/v1/attachments/312a7fb3-1c5a-4ef9-807f-9dd8a7a4d327/content HTTP/1.1", u
nginx-1 | 2026/10/30 22:27:21 [error] 27#27: *195 upstream timed out (110: Operation timed out) while connecting to upstream, client: 192.168.229.1, server: localhost, request: "GET /api/v1/attachments/312a7fb3-1c5a-4ef9-807f-9dd8a7a4d327/content HTTP/1.1", u
== failover
{"observed_instances_before": 2, "successful_writes": 118, "failed_attempts": 0, "first_recovery_seconds": 1.847}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
== persistence
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
took 82s
== pipeline
PASS A: worker down -> 202/409/message 201 -> API+broker restart keeps job -> worker -> ready
PASS B: crash windows recovered, duplicates dropped, backoff [781, 1147, 3292, 6579] ms -> retry_exhausted -> replay -> ready, invalid_image not retried
PASS C: v2 committed first, late v1 committed as superseded, pointer stays 2, duplicates dropped
PASS invariants: 9 attachments final, 27 variant objects = DB rows, checksums equal, every done job committed once, dropped {'duplicate_done': 4, 'duplicate_in_progress': 6, 'stale_attempt': 1}
exit
== smoke
PASS: lab6 public API scenario; infrastructure and grading evidence remain separate.
api-1 Up 55 seconds (healthy);api-2 Up 55 seconds (healthy);grafana Up 5 minutes;loki Up 5 minutes (healthy);nginx Up 5 minutes;otel-collector Up 5 minutes;postgres Up 5 minutes (healthy);prometheus Up 5 minutes (healthy);rabbitmq Up 4 minutes (healthy);redis Up 5 minutes (healthy);s3 Up 5 minutes (healthy);tempo Up 5 minutes;worker Up 55 seconds (healthy);
+403
View File
@@ -0,0 +1,403 @@
{
"experiment": "lab5 pipeline: grade 3/4 scenarios and track 2 idempotency",
"lease_seconds": 6,
"scenarios": {
"A_worker_down_restart": {
"attachment_id": "37a07cde-cb88-4957-a8ce-bcea293ae9b2",
"job_id": "4e122ef2-b0ac-48de-917c-af4b3a28f3ab",
"message_id": "2a8b0831-cfa7-4d30-b865-4665aa4d7db3",
"queue_before_restart": {
"attachments.process": 1,
"attachments.dlq": 0
},
"queue_after_restart": {
"attachments.process": 1,
"attachments.dlq": 0
},
"content_while_queued": 409,
"seconds": 51.8,
"result": "PASS"
},
"B_faults": {
"fired_points": [
"crash-after-claim",
"crash-after-commit",
"crash-after-publish",
"crash-after-s3",
"crash-before-publish"
],
"audit": {
"crash-before-publish": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
]
],
"crash-after-publish": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
],
[
1,
"duplicate_done",
""
]
],
"crash-after-claim": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"lease_expired",
"next_attempt=2 delay_ms=0 error=lease expired"
],
[
2,
"claimed",
""
],
[
2,
"done",
"current"
]
],
"crash-after-s3": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"lease_expired",
"next_attempt=2 delay_ms=0 error=lease expired"
],
[
2,
"claimed",
""
],
[
2,
"duplicate_in_progress",
""
],
[
2,
"lease_expired",
"next_attempt=3 delay_ms=0 error=lease expired"
],
[
3,
"claimed",
""
],
[
3,
"done",
"current"
]
],
"crash-after-commit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
],
[
1,
"duplicate_done",
""
]
]
},
"transient": {
"job_id": "3dc87e66-b861-4cab-915b-55de7bc47eb4",
"backoff_delays_ms": [
781,
1147,
3292,
6579
],
"audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"retry_scheduled",
"next_attempt=2 delay_ms=781 error=java.io.IOException: injected transient fault"
],
[
1,
"stale_attempt",
""
],
[
2,
"claimed",
""
],
[
2,
"retry_scheduled",
"next_attempt=3 delay_ms=1147 error=java.io.IOException: injected transient fault"
],
[
3,
"claimed",
""
],
[
3,
"retry_scheduled",
"next_attempt=4 delay_ms=3292 error=java.io.IOException: injected transient fault"
],
[
4,
"claimed",
""
],
[
4,
"retry_scheduled",
"next_attempt=5 delay_ms=6579 error=java.io.IOException: injected transient fault"
],
[
5,
"claimed",
""
],
[
5,
"failed",
"retry_exhausted"
],
[
6,
"replayed",
"operator"
],
[
6,
"claimed",
""
],
[
6,
"done",
"current"
]
],
"replay": {
"3dc87e66-b861-4cab-915b-55de7bc47eb4": "queued as attempt 6",
"d43dec57-ac25-4db7-b151-90bd90c22e03": "skipped: job is done"
},
"replay_again": {
"3dc87e66-b861-4cab-915b-55de7bc47eb4": "skipped: job is done"
}
},
"invalid_image": {
"job_id": "3a58faf4-4e63-43f1-9bd7-f4c003954ba3",
"audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"failed",
"invalid_image"
]
]
},
"seconds": 74.2,
"result": "PASS"
},
"C_stale_version": {
"attachment_id": "c2191b04-2593-43c2-bf73-0c17d83677a5",
"v1_job": "8160092d-cf5c-45b4-9f2b-cda2342f88d9",
"v2_job": "d59b03be-12ea-4049-b9e3-dc206c0468e0",
"reprocess": {
"jobs_created": 1
},
"v1_audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"done",
"superseded"
],
[
1,
"duplicate_done",
""
],
[
1,
"duplicate_done",
""
]
],
"v2_audit": [
[
1,
"claimed",
""
],
[
1,
"done",
"current"
]
],
"pointer": 2,
"seconds": 46.0,
"result": "PASS"
}
},
"invariants": {
"I1_no_lost_accepted_work": {
"caa80c9b-40c3-4e75-ae16-3da8483608d5": "failed",
"0e715743-76d1-4e60-8dee-28657b6c19ac": "ready",
"c2191b04-2593-43c2-bf73-0c17d83677a5": "ready",
"37a07cde-cb88-4957-a8ce-bcea293ae9b2": "ready",
"93bd6905-8ece-4da6-898f-621b2f169bbb": "ready",
"7afa8d8b-3247-459b-a836-5abe12c18147": "ready",
"c1b37b43-00c4-4c19-9d5d-1de1bde7bce1": "ready",
"30418140-0300-4f0c-bcea-919188af4ee5": "ready",
"40d6632d-8c50-4bbb-80b8-6deefaab7e50": "ready"
},
"I2_variants_per_effect_key": {
"c2191b04-2593-43c2-bf73-0c17d83677a5/v1": 3,
"0e715743-76d1-4e60-8dee-28657b6c19ac/v1": 3,
"40d6632d-8c50-4bbb-80b8-6deefaab7e50/v1": 3,
"37a07cde-cb88-4957-a8ce-bcea293ae9b2/v1": 3,
"c2191b04-2593-43c2-bf73-0c17d83677a5/v2": 3,
"30418140-0300-4f0c-bcea-919188af4ee5/v1": 3,
"c1b37b43-00c4-4c19-9d5d-1de1bde7bce1/v1": 3,
"93bd6905-8ece-4da6-898f-621b2f169bbb/v1": 3,
"7afa8d8b-3247-459b-a836-5abe12c18147/v1": 3
},
"I2_s3_variant_objects": 27,
"I3_checksums_equal": 27,
"I4_commits_per_job": [
0,
1,
1,
1,
1,
1,
1,
1,
1,
1
],
"I5_staging": {
"staging_left_for_run": [
"caa80c9b-40c3-4e75-ae16-3da8483608d5"
]
},
"duplicates_dropped": {
"duplicate_done": 4,
"duplicate_in_progress": 6,
"stale_attempt": 1
},
"result": "PASS"
},
"seconds_total": 216.7
}
File diff suppressed because it is too large Load Diff
+143
View File
@@ -0,0 +1,143 @@
{
"controlled_request": {
"trace_id": "8461974b8914ca8c5a34e08e3e4b7750",
"request_id": "94712dff-a1c8-4f1c-adb1-ca79a23f1787",
"spans": [
{
"service": "messenger-api",
"kind": "SERVER",
"name": "POST /api/v1/chats/{id}/messages",
"ms": 13.3,
"status": "UNSET"
},
{
"service": "messenger-api",
"kind": "CLIENT",
"name": "GET",
"ms": 0.6,
"status": "UNSET"
},
{
"service": "messenger-api",
"kind": "CLIENT",
"name": "SELECT messenger",
"ms": 0.3,
"status": "UNSET"
},
{
"service": "messenger-api",
"kind": "CLIENT",
"name": "INSERT messenger.idempotency_keys",
"ms": 0.6,
"status": "UNSET"
},
{
"service": "messenger-api",
"kind": "CLIENT",
"name": "INSERT messenger.messages",
"ms": 1.1,
"status": "UNSET"
}
],
"logs": [
{
"ts": "1793396891770396773",
"line": "POST /api/v1/chats/{id}/messages -> 201 in 12 ms",
"event": "http.request",
"severity_text": "INFO",
"trace_id": "8461974b8914ca8c5a34e08e3e4b7750",
"span_id": "7d5500ec633602f8",
"request_id": "94712dff-a1c8-4f1c-adb1-ca79a23f1787",
"http_route": "/api/v1/chats/{id}/messages",
"http_response_status_code": "201"
}
]
},
"upload_with_retry": {
"trace_id": "0a4cc3901adee435a0471add15968a77",
"attachment_status": "ready",
"chain": [
{
"service": "messenger-api",
"kind": "SERVER",
"name": "POST /api/v1/chats/{id}/attachments",
"parent": null,
"ms": 57.2,
"status": "UNSET"
},
{
"service": "messenger-api",
"kind": "PRODUCER",
"name": "attachments publish",
"parent": "POST /api/v1/chats/{id}/attachments",
"ms": 1.9,
"status": "UNSET"
},
{
"service": "messenger-worker",
"kind": "CONSUMER",
"name": "attachments.process process",
"parent": "attachments publish",
"ms": 116.2,
"status": "STATUS_CODE_ERROR",
"job.attempt": "1",
"job.outcome": "retry"
},
{
"service": "messenger-worker",
"kind": "PRODUCER",
"name": "attachments publish",
"parent": "attachments.process process",
"ms": 8.1,
"status": "UNSET"
},
{
"service": "messenger-worker",
"kind": "CONSUMER",
"name": "attachments.process process",
"parent": "attachments publish",
"ms": 163.6,
"status": "UNSET",
"job.attempt": "2",
"job.outcome": "done"
}
],
"worker_effect_spans": [
"INSERT messenger.attachment_variants",
"INSERT messenger.job_audit",
"INSERT messenger.outbox",
"S3.CopyObject",
"S3.DeleteObject",
"S3.GetObject",
"S3.HeadObject",
"S3.PutObject",
"UPDATE messenger.attachments",
"UPDATE messenger.jobs"
],
"logs": [
{
"event": "http.request",
"severity_text": "INFO",
"line": "POST /api/v1/chats/{id}/attachments -> 202 in 54 ms",
"span_id": "e0f77957eeff84f5"
},
{
"event": "job.done",
"severity_text": "INFO",
"line": "job 70d78d27-d995-4c90-a747-330481717138 attempt 2 done: attachment 4ecc20d9-4f98-4a39-82c1-4d3a2710e381 v1",
"span_id": "3c3f5c2b536d5828"
},
{
"event": "job.retry",
"severity_text": "WARN",
"line": "job 70d78d27-d995-4c90-a747-330481717138 attempt 1 failed: java.io.IOException: injected transient fault, attempt 1 only",
"span_id": "1e612c3539aa180c"
}
]
},
"leak_check": {
"message_text_in_logs_or_traces": 0,
"session_token_in_logs_or_traces": 0,
"message_text_in_loki_all_logs": 0
}
}
+39
View File
@@ -0,0 +1,39 @@
{
"uploads": 30,
"p50_s": 0.67,
"p95_s": 1.03,
"max_s": 1.15,
"over_10s": 0,
"all_s": [
0.64,
0.65,
0.65,
0.65,
0.65,
0.65,
0.65,
0.65,
0.65,
0.66,
0.66,
0.66,
0.67,
0.67,
0.67,
0.67,
0.67,
0.68,
0.68,
0.68,
0.69,
0.69,
0.69,
0.74,
0.87,
0.88,
0.96,
0.98,
1.03,
1.15
]
}
@@ -0,0 +1,8 @@
apiVersion: 1
providers:
- name: messenger
folder: Messenger
type: file
disableDeletion: true
options:
path: /etc/grafana/provisioning/dashboards
@@ -0,0 +1,583 @@
{
"uid": "messenger-lab6",
"title": "Messenger — API, worker, очередь",
"schemaVersion": 39,
"version": 2,
"editable": true,
"time": {
"from": "now-30m",
"to": "now"
},
"refresh": "10s",
"tags": [
"messenger",
"lab6"
],
"panels": [
{
"id": 1,
"type": "timeseries",
"title": "API: запросы/с по маршруту и классу статуса",
"description": "http.server.request.duration (count), все реплики; health исключён",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 0,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "reqps"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "sum by (http_route, class) (label_replace(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_route!~\"/health.*\"}[1m]), \"class\", \"${1}xx\", \"http_response_status_code\", \"([0-9]).*\"))",
"legendFormat": "{{http_route}} {{class}}",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 2,
"type": "timeseries",
"title": "API: доля 5xx (без health)",
"description": "numerator: ответы 5xx; denominator: все бизнес-запросы, кроме /health/*",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 0,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "percentunit"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_route!~\"/health.*\",http_response_status_code=~\"5..\"}[5m])) / sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_route!~\"/health.*\"}[5m]))",
"legendFormat": "5xx / все",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 3,
"type": "timeseries",
"title": "API: длительность p50/p95/p99 (из histogram, все реплики)",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 8,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "s"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "histogram_quantile(0.5, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\",http_route!~\"/health.*\"}[5m])))",
"legendFormat": "p50",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\",http_route!~\"/health.*\"}[5m])))",
"legendFormat": "p95",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "C",
"expr": "histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\",http_route!~\"/health.*\"}[5m])))",
"legendFormat": "p99",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 4,
"type": "timeseries",
"title": "Worker: задания по исходу",
"description": "messenger.jobs.processed: done / retry / failed / duplicate / fenced",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 8,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "ops"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "sum by (outcome) (rate(messenger_jobs_processed_total{job=\"messenger-worker\"}[5m]))",
"legendFormat": "{{outcome}}",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 5,
"type": "timeseries",
"title": "Worker: длительность попытки p50/p95/p99",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 16,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "s"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "histogram_quantile(0.5, sum by (le) (rate(messenger_job_duration_seconds_bucket{job=\"messenger-worker\"}[5m])))",
"legendFormat": "p50",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_job_duration_seconds_bucket{job=\"messenger-worker\"}[5m])))",
"legendFormat": "p95",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "C",
"expr": "histogram_quantile(0.99, sum by (le) (rate(messenger_job_duration_seconds_bucket{job=\"messenger-worker\"}[5m])))",
"legendFormat": "p99",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 6,
"type": "timeseries",
"title": "Очередь: глубина и возраст самого старого задания",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 16,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "max(messenger_queue_depth)",
"legendFormat": "queued, шт",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "max(messenger_queue_oldest_age_seconds)",
"legendFormat": "oldest age, с",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 7,
"type": "timeseries",
"title": "Worker: занятость (busy / capacity)",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 24,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "percentunit"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "sum(messenger_worker_busy{job=\"messenger-worker\"}) / sum(messenger_worker_capacity{job=\"messenger-worker\"})",
"legendFormat": "busy / capacity",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 8,
"type": "timeseries",
"title": "Время до ready p50/p95 (от 202 до ready)",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 24,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "s"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "histogram_quantile(0.5, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{job=\"messenger-worker\"}[5m])))",
"legendFormat": "p50",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{job=\"messenger-worker\"}[5m])))",
"legendFormat": "p95",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 9,
"type": "timeseries",
"title": "Пул соединений БД (Hikari)",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 32,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "sum by (job, state) (db_client_connections_usage)",
"legendFormat": "{{job}} {{state}}",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "sum by (job) (db_client_connections_pending_requests)",
"legendFormat": "{{job}} waiting",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 10,
"type": "timeseries",
"title": "JVM: CPU и память",
"description": "",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 32,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"targets": [
{
"refId": "A",
"expr": "avg by (job, host_name) (jvm_cpu_recent_utilization_ratio)",
"legendFormat": "CPU {{job}} {{host_name}}",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "sum by (job, host_name) (jvm_memory_used_bytes) / 1048576",
"legendFormat": "heap+non-heap MiB {{job}} {{host_name}}",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 11,
"type": "logs",
"title": "Логи API и worker (Loki, со ссылкой на trace)",
"datasource": {
"type": "loki",
"uid": "loki"
},
"gridPos": {
"x": 0,
"y": 40,
"w": 24,
"h": 10
},
"options": {
"showTime": true,
"wrapLogMessage": true
},
"targets": [
{
"refId": "A",
"expr": "{service_name=~\"messenger-api|messenger-worker\"}",
"datasource": {
"type": "loki",
"uid": "loki"
}
}
]
},
{
"id": 12,
"type": "timeseries",
"title": "SLO доступности API: burn rate (page ≥ 14.4 за 2m30s+30s, ticket ≥ 6 за 15m+1m30s)",
"description": "burn = доля 5xx (без /health) / бюджет 1 %; окна — SRE Workbook, сжатые в 24 раза (см. infra/prometheus/alerts.yml)",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 0,
"y": 50,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "x",
"min": 0
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "slo:api_errors:ratio_rate30s / 0.01",
"legendFormat": "burn 30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "slo:api_errors:ratio_rate2m30s / 0.01",
"legendFormat": "burn 2m30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "C",
"expr": "slo:api_errors:ratio_rate1m30s / 0.01",
"legendFormat": "burn 1m30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "D",
"expr": "slo:api_errors:ratio_rate15m / 0.01",
"legendFormat": "burn 15m",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
},
{
"id": 13,
"type": "timeseries",
"title": "SLO времени до ready ≤ 10 с: burn rate (те же пороги)",
"description": "burn = доля вложений с временем до ready > 10 с / бюджет 1 %; события появляются только при ready",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"x": 12,
"y": 50,
"w": 12,
"h": 8
},
"fieldConfig": {
"defaults": {
"unit": "x",
"min": 0
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "slo:ttr_slow:ratio_rate30s / 0.01",
"legendFormat": "burn 30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "B",
"expr": "slo:ttr_slow:ratio_rate2m30s / 0.01",
"legendFormat": "burn 2m30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "C",
"expr": "slo:ttr_slow:ratio_rate1m30s / 0.01",
"legendFormat": "burn 1m30s",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
},
{
"refId": "D",
"expr": "slo:ttr_slow:ratio_rate15m / 0.01",
"legendFormat": "burn 15m",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
}
}
]
}
]
}
@@ -0,0 +1,33 @@
# Grafana ничего не хранит сама: три источника, связанные между собой по trace_id.
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: http://prometheus:9090
isDefault: true
- name: Loki
uid: loki
type: loki
access: proxy
url: http://loki:3100
jsonData:
# trace_id из structured metadata записи лога → переход в трассу Tempo.
derivedFields:
- name: trace_id
matcherType: label
matcherRegex: trace_id
datasourceUid: tempo
url: '$${__value.raw}'
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: http://tempo:3200
jsonData:
tracesToLogsV2:
datasourceUid: loki
filterByTraceID: true
spanStartTimeShift: -5m
spanEndTimeShift: 5m
+31
View File
@@ -0,0 +1,31 @@
# Loki — логи: однопроцессный режим, файловое хранилище в volume, нативный приём OTLP (/otlp).
auth_enabled: false
server:
http_listen_port: 3100
common:
path_prefix: /loki
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
replication_factor: 1
ring:
kvstore:
store: inmemory
schema_config:
configs:
- from: 2024-01-01
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
# trace_id/span_id и атрибуты записи OTLP хранятся как structured metadata, а не как labels.
allow_structured_metadata: true
retention_period: 168h
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
+70
View File
@@ -0,0 +1,70 @@
# Встроенный DNS Docker: адреса реплик перечитываются каждые 5 секунд. Поэтому nginx
# стартует, даже если одна реплика остановлена, и находит пересозданный контейнер с новым IP.
resolver 127.0.0.11 valid=5s ipv6=off;
upstream api_backend {
# zone нужна для resolve: адреса реплик хранятся в общей памяти воркеров nginx.
zone api_backend 64k;
# Балансировка между API-репликами round-robin.
# max_fails и fail_timeout обеспечивают пассивную проверку здоровья.
server api-1:8080 resolve max_fails=3 fail_timeout=10s;
server api-2:8080 resolve max_fails=3 fail_timeout=10s;
# Переиспользование соединений с репликами.
keepalive 32;
}
server {
listen 8080;
server_name localhost;
# Таймауты для предотвращения зависаний.
# proxy_connect_timeout 1s — быстрое обнаружение отказа backend.
proxy_connect_timeout 1s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
# Передача заголовков клиента в backend (наследуется всеми location ниже).
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# Поддержка keepalive соединений с backend.
proxy_http_version 1.1;
proxy_set_header Connection "";
# Повтор на другой реплике: не более 2 попыток и 10 секунд.
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 10s;
# Вложения до 10 MiB проверяет API (JSON 413 с X-Request-Id). Запас до 11m, чтобы ответ
# 413 на 10 MiB + 1 байт давало приложение; всё больше nginx отсекает сам, не читая тело.
# Тело буферизуется в nginx: медленный клиент не держит поток API.
client_max_body_size 11m;
client_body_timeout 15s;
error_page 413 = @payload_too_large;
# Основной location для API и health.
location / {
proxy_pass http://api_backend;
# Уже отправленный POST (users, chats, auth/sessions) не повторяем:
# прозрачный повтор может создать второй объект (contracts/README.md).
proxy_next_upstream error timeout http_503;
}
# Отправку сообщения повторять безопасно: дубль отсекает Idempotency-Key.
# Загрузку вложения (POST .../attachments) nginx не повторяет: контракт запрещает прозрачный retry.
location ~ ^/api/v1/chats/[^/]+/messages$ {
proxy_pass http://api_backend;
proxy_next_upstream error timeout http_503 non_idempotent;
}
# Ответ nginx на слишком большое тело — в формате ошибки контракта, а не HTML.
location @payload_too_large {
default_type application/json;
add_header X-Request-Id $request_id always;
return 413 '{"error":{"code":"payload_too_large","message":"payload too large","request_id":"$request_id"}}';
}
}
+63
View File
@@ -0,0 +1,63 @@
# OTel Collector: принимает OTLP от API и worker, ограничивает память, батчит и раскладывает сигналы
# по хранилищам. Сам ничего долго не хранит: очереди экспорта ограничены, повторы — не дольше 60 с.
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
processors:
# Первым в цепочке: при превышении лимита Collector отказывает приёмом (SDK повторит/отбросит), а не растёт в RAM.
memory_limiter:
check_interval: 1s
limit_mib: 180
spike_limit_mib: 40
batch:
send_batch_size: 1024
timeout: 2s
exporters:
otlphttp/prometheus:
endpoint: http://prometheus:9090/api/v1/otlp
sending_queue: { queue_size: 500 }
retry_on_failure: { max_elapsed_time: 60s }
otlphttp/loki:
endpoint: http://loki:3100/otlp
sending_queue: { queue_size: 500 }
retry_on_failure: { max_elapsed_time: 60s }
otlp/tempo:
endpoint: tempo:4317
tls: { insecure: true }
sending_queue: { queue_size: 500 }
retry_on_failure: { max_elapsed_time: 60s }
extensions:
health_check:
endpoint: 0.0.0.0:13133
service:
extensions: [health_check]
# Собственные метрики Collector (принято/отброшено/ошибки экспорта) — их собирает Prometheus.
telemetry:
metrics:
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
pipelines:
traces:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlp/tempo]
metrics:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlphttp/prometheus]
logs:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlphttp/loki]
+107
View File
@@ -0,0 +1,107 @@
# Правила Prometheus: SLO burn-rate (трек 2) и базовые alerts уровня 4. Состояние видно в Prometheus
# /api/v1/alerts и в Grafana → Alerting (data source-managed). Доставка наружу не настроена (не требуется).
#
# SLO-1 «доступность API»: 99 % бизнес-запросов (все маршруты, кроме /health/*) без 5xx; 4xx — ответ
# клиенту, а не отказ сервиса. Бюджет ошибок b = 1 %.
# SLO-2 «время до ready»: 99 % вложений становятся ready не позже 10 с после durable acceptance (202).
# Бюджет b = 1 %. Плохое событие — время до ready > 10 с (bucket le="10").
#
# Пороги — multiwindow multi-burn-rate из SRE Workbook (окно SLO 30 дней): 14.4× за 1 ч + 5 мин (page) и
# 6× за 6 ч + 30 мин. Учебный стенд сжимает время в 24 раза, чтобы эксперимент занимал минуты:
# 1 ч → 2m30s, 6 ч → 15m; короткие окна (1/12 длинного) 12.5 с → 30s и 75 с → 1m30s — не меньше трёх
# отсчётов при экспорте метрик раз в 10 с. Короткое окно гасит alert вскоре после восстановления.
groups:
- name: slo-api-availability
interval: 10s
rules:
- record: slo:api_errors:ratio_rate30s
expr: |
sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*", http_response_status_code=~"5.."}[30s]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*"}[30s]))
- record: slo:api_errors:ratio_rate1m
expr: |
sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*", http_response_status_code=~"5.."}[1m]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*"}[1m]))
- record: slo:api_errors:ratio_rate1m30s
expr: |
sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*", http_response_status_code=~"5.."}[1m30s]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*"}[1m30s]))
- record: slo:api_errors:ratio_rate2m30s
expr: |
sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*", http_response_status_code=~"5.."}[2m30s]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*"}[2m30s]))
- record: slo:api_errors:ratio_rate15m
expr: |
sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*", http_response_status_code=~"5.."}[15m]))
/ sum(rate(http_server_request_duration_seconds_count{job="messenger-api", http_route!~"/health.*"}[15m]))
- alert: ApiAvailabilityFastBurn
expr: slo:api_errors:ratio_rate2m30s > (14.4 * 0.01) and slo:api_errors:ratio_rate30s > (14.4 * 0.01)
labels: { severity: page, slo: api-availability }
annotations:
summary: "API сжигает бюджет ошибок в 14.4× быстрее допустимого"
description: "Доля 5xx за 2m30s и 30s выше 14.4 %. При таком темпе месячный бюджет кончится за ~2 дня (в учебном масштабе — за 2 ч)."
runbook: docs/runbook.md#apiavailabilityfastburn--apiavailabilityslowburn--apihigherrorrate
- alert: ApiAvailabilitySlowBurn
expr: slo:api_errors:ratio_rate15m > (6 * 0.01) and slo:api_errors:ratio_rate1m30s > (6 * 0.01)
labels: { severity: ticket, slo: api-availability }
annotations:
summary: "API длительно сжигает бюджет ошибок (6×)"
description: "Доля 5xx за 15m и 1m30s выше 6 %."
runbook: docs/runbook.md#apiavailabilityfastburn--apiavailabilityslowburn--apihigherrorrate
# Наивное правило уровня 4 «высокий error rate» — одно окно и порог; в треке 2 служит базой
# для сравнения ложных срабатываний с burn-rate.
- alert: ApiHighErrorRate
expr: slo:api_errors:ratio_rate1m > 0.05
for: 30s
labels: { severity: ticket }
annotations:
summary: "Доля 5xx API за 1 мин выше 5 %"
description: "Числитель — 5xx, знаменатель — все запросы кроме /health/*."
runbook: docs/runbook.md#apiavailabilityfastburn--apiavailabilityslowburn--apihigherrorrate
- name: slo-time-to-ready
interval: 10s
rules:
- record: slo:ttr_slow:ratio_rate30s
expr: 1 - sum(rate(messenger_attachment_time_to_ready_seconds_bucket{le="10"}[30s])) / sum(rate(messenger_attachment_time_to_ready_seconds_count[30s]))
- record: slo:ttr_slow:ratio_rate1m30s
expr: 1 - sum(rate(messenger_attachment_time_to_ready_seconds_bucket{le="10"}[1m30s])) / sum(rate(messenger_attachment_time_to_ready_seconds_count[1m30s]))
- record: slo:ttr_slow:ratio_rate2m30s
expr: 1 - sum(rate(messenger_attachment_time_to_ready_seconds_bucket{le="10"}[2m30s])) / sum(rate(messenger_attachment_time_to_ready_seconds_count[2m30s]))
- record: slo:ttr_slow:ratio_rate15m
expr: 1 - sum(rate(messenger_attachment_time_to_ready_seconds_bucket{le="10"}[15m])) / sum(rate(messenger_attachment_time_to_ready_seconds_count[15m]))
# Событие появляется только при ready: пока worker стоит, этих alerts нет — остановку ловит QueueLagHigh.
- alert: TimeToReadyFastBurn
expr: slo:ttr_slow:ratio_rate2m30s > (14.4 * 0.01) and slo:ttr_slow:ratio_rate30s > (14.4 * 0.01)
labels: { severity: page, slo: time-to-ready }
annotations:
summary: "Вложения становятся ready дольше 10 с: бюджет горит в 14.4×"
runbook: docs/runbook.md#queuelaghigh--workerabsent--timetoready
- alert: TimeToReadySlowBurn
expr: slo:ttr_slow:ratio_rate15m > (6 * 0.01) and slo:ttr_slow:ratio_rate1m30s > (6 * 0.01)
labels: { severity: ticket, slo: time-to-ready }
annotations:
summary: "Вложения длительно становятся ready дольше 10 с (6×)"
runbook: docs/runbook.md#queuelaghigh--workerabsent--timetoready
- name: pipeline
interval: 10s
rules:
# Возраст старейшего queued-задания (источник — таблица jobs; gauge отдают API и worker, берём max).
- alert: QueueLagHigh
expr: max(messenger_queue_oldest_age_seconds) > 60
for: 30s
labels: { severity: page }
annotations:
summary: "Старейшее задание ждёт дольше 60 с"
description: "Очередь не разбирается: worker остановлен, перегружен или не получает сообщения."
runbook: docs/runbook.md#queuelaghigh--workerabsent--timetoready
# OTLP — push, у пропавшего процесса нет staleness-маркеров: отсутствие отсчётов за 1 мин = worker не жив.
- alert: WorkerAbsent
expr: absent_over_time(messenger_worker_capacity{job="messenger-worker"}[1m])
labels: { severity: page }
annotations:
summary: "Нет метрик worker больше минуты"
runbook: docs/runbook.md#queuelaghigh--workerabsent--timetoready
+22
View File
@@ -0,0 +1,22 @@
# Prometheus — метрики: принимает OTLP от Collector (--web.enable-otlp-receiver) и сам опрашивает Collector.
global:
scrape_interval: 15s
evaluation_interval: 10s
# SLO burn-rate и alerts уровня 4.
rule_files:
- /etc/prometheus/alerts.yml
# Атрибуты ресурса, которые нужны как labels (реплика и окружение); остальное — в target_info.
otlp:
promote_resource_attributes: [service.instance.id, host.name, deployment.environment.name]
# OTLP приходит батчами с задержкой: допускаем отсчёты не по порядку в пределах 30 минут.
storage:
tsdb:
out_of_order_time_window: 30m
scrape_configs:
- job_name: otel-collector
static_configs:
- targets: ['otel-collector:8888']
+5
View File
@@ -0,0 +1,5 @@
# Пользователи, права, exchange и очереди импортируются при каждом старте (идемпотентно, по хешу файла).
load_definitions = /run/secrets/rabbitmq_definitions.json
# Пороги flow control ниже лимита контейнера 512M: при нехватке памяти/диска брокер тормозит издателей, а не падает.
vm_memory_high_watermark.absolute = 256MiB
disk_free_limit.absolute = 200MB
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
# Идемпотентный bootstrap S3: bucket создаётся один раз, повторный запуск ничего не меняет.
# Работает с admin-ключами; API их не получает. Ключи передаются curl через stdin, не в argv.
set -eu
url="$S3_ENDPOINT/$S3_BUCKET"
s3() {
printf 'user = "%s:%s"\n' "$(cat /run/secrets/s3_admin_access_key)" "$(cat /run/secrets/s3_admin_secret_key)" |
curl -K - -s -o /dev/null -w '%{http_code}' --aws-sigv4 "aws:amz:$S3_REGION:s3" "$@"
}
code=$(s3 -I "$url")
case "$code" in
200) echo "bucket $S3_BUCKET already exists" ;;
404)
code=$(s3 -X PUT "$url")
# 409: bucket успели создать параллельно — это тоже успех.
[ "$code" = 200 ] || [ "$code" = 409 ] || { echo "create bucket failed: HTTP $code" >&2; exit 1; }
echo "bucket $S3_BUCKET created" ;;
*) echo "head bucket failed: HTTP $code" >&2; exit 1 ;;
esac
# Bucket приватный: анонимный листинг и чтение должны получать 403.
anon=$(curl -s -o /dev/null -w '%{http_code}' "$url?list-type=2")
[ "$anon" = 403 ] || { echo "bucket is not private: anonymous list -> HTTP $anon" >&2; exit 1; }
echo "anonymous list -> 403, bucket is private"
+19
View File
@@ -0,0 +1,19 @@
# Tempo — трассы: приём OTLP gRPC от Collector, локальное хранилище блоков в volume, хранение 7 дней.
server:
http_listen_port: 3200
distributor:
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
storage:
trace:
backend: local
local:
path: /var/tempo/traces
wal:
path: /var/tempo/wal
compactor:
compaction:
block_retention: 168h
+40
View File
@@ -0,0 +1,40 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.5</version>
<relativePath/>
</parent>
<groupId>ru.mtusi</groupId>
<artifactId>messenger</artifactId>
<version>1.0.0</version>
<properties><java.version>21</java.version></properties>
<dependencyManagement>
<dependencies>
<!-- AWS SDK v2 для S3-совместимого SeaweedFS. -->
<dependency><groupId>software.amazon.awssdk</groupId><artifactId>bom</artifactId><version>2.29.52</version><type>pom</type><scope>import</scope></dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>
<dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-crypto</artifactId></dependency>
<dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><scope>runtime</scope></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
<dependency><groupId>org.flywaydb</groupId><artifactId>flyway-core</artifactId></dependency>
<dependency><groupId>org.flywaydb</groupId><artifactId>flyway-database-postgresql</artifactId></dependency>
<dependency>
<groupId>software.amazon.awssdk</groupId><artifactId>s3</artifactId>
<exclusions><exclusion><groupId>software.amazon.awssdk</groupId><artifactId>netty-nio-client</artifactId></exclusion></exclusions>
</dependency>
<!-- RabbitMQ: publisher confirms и ручной ack без обёрток Spring AMQP; версия из BOM Spring Boot. -->
<dependency><groupId>com.rabbitmq</groupId><artifactId>amqp-client</artifactId></dependency>
<!-- OpenTelemetry API для своих метрик заданий; реализацию даёт Java agent (без него — no-op). Версия из BOM Spring Boot. -->
<dependency><groupId>io.opentelemetry</groupId><artifactId>opentelemetry-api</artifactId></dependency>
<!-- Синхронный HTTP-клиент с пулом соединений и настраиваемыми таймаутами. -->
<dependency><groupId>software.amazon.awssdk</groupId><artifactId>apache-client</artifactId></dependency>
</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>
+41
View File
@@ -0,0 +1,41 @@
#!/bin/sh
# Проверка приватности S3 мимо API (уровень 4). Запросы идут из отдельного контейнера s3-probe
# в сети стенда — ближе всего к атакующему внутри; с хоста S3 вообще недоступен.
# Нужен хотя бы один загруженный файл (например, после make test). Секреты не печатаются.
set -eu
cd "$(dirname "$0")/.."
key=$(docker compose exec -T postgres psql -U messenger -d messenger -At -c "select object_key from attachments where state='ready' limit 1")
[ -n "$key" ] || { echo "no attachments yet: run make test first" >&2; exit 2; }
docker compose run --rm -T -e KEY="$key" s3-probe <<'EOF'
url="http://s3:8333/messenger-attachments"
fail=0
expect() { # expect <описание> <ожидаемый код> <фактический код>
if [ "$2" = "$3" ]; then echo "PASS $1 -> $3"; else echo "FAIL $1 -> $3 (expected $2)"; fail=1; fi
}
signed() { # подписанный запрос ключами API; ключи идут в curl через stdin, не в argv
printf 'user = "%s:%s"\n' "$(cat /run/secrets/s3.access-key)" "$(cat /run/secrets/s3.secret-key)" |
curl -K - -s -o /tmp/body -w '%{http_code}' -m 5 --aws-sigv4 aws:amz:us-east-1:s3 "$@"
}
anon() { curl -s -o /dev/null -w '%{http_code}' -m 5 "$@"; }
expect "anonymous GET object" 403 "$(anon "$url/$KEY")"
expect "anonymous HEAD object" 403 "$(anon -I "$url/$KEY")"
expect "anonymous LIST bucket" 403 "$(anon "$url?list-type=2")"
expect "anonymous PUT object" 403 "$(anon -X PUT --data-binary x "$url/originals/anon-probe")"
# Контроль: подпись верна и ключ API читает свой bucket — значит, 403 ниже вызваны именно правами.
expect "API key GET object (control)" 200 "$(signed "$url/$KEY")"
expect "API key create other bucket" 403 "$(signed -X PUT http://s3:8333/probe-other-bucket)"
grep -q AccessDenied /tmp/body && echo "PASS ...denied by policy (AccessDenied), not by signature" || { echo "FAIL unexpected error body"; fail=1; }
expect "API key delete own bucket" 403 "$(signed -X DELETE "$url")"
# HTTP-админки SeaweedFS (master UI, filer UI, volume) слушают только 127.0.0.1 внутри контейнера s3.
for port in 9333 8888 8080; do expect "admin port s3:$port reachable" 000 "$(anon "http://s3:$port/")"; done
exit $fail
EOF
# С хоста опубликованы только nginx (API) и Grafana (UI наблюдаемости, вход по паролю).
if docker compose ps --format '{{.Service}} {{.Ports}}' | grep -vE '^(nginx|grafana) ' | grep -q -- '->'; then
echo "FAIL services other than nginx/grafana publish host ports"; exit 1
fi
echo "PASS only nginx and grafana publish host ports"
+86
View File
@@ -0,0 +1,86 @@
#!/usr/bin/env python3
"""Создаёт синтетические секреты локального стенда в secrets/ (вне Git); значения не печатает.
Повторный запуск не меняет существующие файлы: пароль PostgreSQL задаётся при первой
инициализации volume, и его смена сломала бы уже созданный стенд.
"""
import base64
import hashlib
import json
import os
import secrets
import string
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
DIR = ROOT / 'secrets'
BUCKET = os.environ.get('S3_BUCKET', 'messenger-attachments')
def value(name, generate):
path = DIR / name
if not path.exists():
path.write_text(generate(), encoding='utf-8')
# 644: файлы монтируются в контейнеры, где сервисы работают не от root; каталог закрыт 700.
os.chmod(path, 0o644)
return path.read_text(encoding='utf-8')
def token():
return secrets.token_urlsafe(30)
def access_key():
return ''.join(secrets.choice(string.ascii_uppercase + string.digits) for _ in range(20))
DIR.mkdir(exist_ok=True)
os.chmod(DIR, 0o700)
value('db_password', token)
redis_password = value('redis_password', token)
value('redis.conf', lambda: 'requirepass %s\nappendonly yes\ndir /data\n' % redis_password)
api_key, api_secret = value('s3_api_access_key', access_key), value('s3_api_secret_key', token)
admin_key, admin_secret = value('s3_admin_access_key', access_key), value('s3_admin_secret_key', token)
worker_key, worker_secret = value('s3_worker_access_key', access_key), value('s3_worker_secret_key', token)
# admin нужен только s3-init для создания bucket; API получает права лишь на свой bucket.
value('s3_config.json', lambda: json.dumps({'identities': [
{'name': 'admin', 'credentials': [{'accessKey': admin_key, 'secretKey': admin_secret}],
'actions': ['Admin', 'Read', 'Write', 'List']},
{'name': 'api', 'credentials': [{'accessKey': api_key, 'secretKey': api_secret}],
'actions': ['Read:' + BUCKET, 'Write:' + BUCKET, 'List:' + BUCKET]},
{'name': 'worker', 'credentials': [{'accessKey': worker_key, 'secretKey': worker_secret}],
'actions': ['Read:' + BUCKET, 'Write:' + BUCKET, 'List:' + BUCKET]},
]}, indent=2))
def rabbit_hash(password):
# Формат rabbit_password_hashing_sha256: base64(salt4 + sha256(salt4 + password)).
salt = os.urandom(4)
return base64.b64encode(salt + hashlib.sha256(salt + password.encode()).digest()).decode()
# RabbitMQ: пользователь api только публикует в exchange attachments, worker ещё и читает очередь.
# configure-прав нет ни у кого: топологию создаёт definitions-файл при старте брокера.
api_pw, worker_pw = value('broker_api_password', token), value('broker_worker_password', token)
value('broker_api_url', lambda: 'amqp://api:%s@rabbitmq:5672/%%2F' % api_pw)
value('broker_worker_url', lambda: 'amqp://worker:%s@rabbitmq:5672/%%2F' % worker_pw)
user = lambda name, pw: {'name': name, 'password_hash': rabbit_hash(pw), 'hashing_algorithm': 'rabbit_password_hashing_sha256', 'tags': []}
exchange = lambda name, kind: {'name': name, 'vhost': '/', 'type': kind, 'durable': True, 'auto_delete': False, 'internal': False, 'arguments': {}}
queue = lambda name, args: {'name': name, 'vhost': '/', 'durable': True, 'auto_delete': False, 'arguments': args}
binding = lambda source, queue, key: {'source': source, 'vhost': '/', 'destination': queue, 'destination_type': 'queue', 'routing_key': key, 'arguments': {}}
value('rabbitmq_definitions.json', lambda: json.dumps({
'users': [user('api', api_pw), user('worker', worker_pw)],
'vhosts': [{'name': '/'}],
'permissions': [
{'user': 'api', 'vhost': '/', 'configure': '^$', 'write': '^attachments$', 'read': '^$'},
{'user': 'worker', 'vhost': '/', 'configure': '^$', 'write': '^attachments$', 'read': '^attachments\\.process$'},
],
'exchanges': [exchange('attachments', 'direct'), exchange('attachments.dlx', 'fanout')],
# Quorum-очередь: реплицируемый журнал на диске, сообщения переживают рестарт брокера с volume.
'queues': [queue('attachments.process', {'x-queue-type': 'quorum', 'x-dead-letter-exchange': 'attachments.dlx', 'x-delivery-limit': 50}),
queue('attachments.dlq', {'x-queue-type': 'quorum'})],
'bindings': [binding('attachments', 'attachments.process', 'process'), binding('attachments.dlx', 'attachments.dlq', '')],
}, indent=2))
# Пароль администратора Grafana (UI наблюдаемости).
value('grafana_admin_password', token)
print('secrets ready in %s (values are not printed)' % DIR)
+47
View File
@@ -0,0 +1,47 @@
#!/bin/bash
# Поочерёдная остановка каждой API-реплики под нагрузкой (уровень «4»).
# RPS, ошибки и p50/p95/p99 даёт tests/load.py (POST сообщений через nginx),
# время восстановления — от запуска реплики до её возвращения в балансировку nginx.
# Время переключения LB на живую реплику измеряет make test-failover (first_recovery_seconds).
set -euo pipefail
cd "$(dirname "$0")/.."
BASE_URL="${BASE_URL:-http://localhost:8080}"
DURATION="${DURATION:-40}"
OUTPUT_DIR="${OUTPUT_DIR:-evidence/failover}"
mkdir -p "$OUTPUT_DIR"
# healthy ещё не значит «в балансировке»: nginx держит упавшую реплику выключенной fail_timeout=10s.
in_rotation() {
local id; id=$(docker compose ps -q "$1" | cut -c1-12)
for _ in $(seq 60); do
curl -s -D - -o /dev/null "$BASE_URL/health/live" | grep -qi "x-instance-id: $id" && return 0
sleep 0.5
done
echo "$1 не вернулась в балансировку за 30 s" >&2; return 1
}
for svc in api-1 api-2; do
result="$OUTPUT_DIR/${svc}_$(date +%Y%m%d_%H%M%S).json"
echo "=== Остановка $svc под нагрузкой (${DURATION}s, 4 потока POST сообщений) ==="
python3 tests/load.py --base-url "$BASE_URL" --duration "$DURATION" --concurrency 4 --output "$result" >/dev/null &
load_pid=$!
sleep 5
docker compose stop "$svc"
echo "$svc остановлена, запросы обслуживает другая реплика"
sleep 10
start=$SECONDS
docker compose up -d --no-deps --wait "$svc"
in_rotation "$svc"
echo "Время восстановления $svc (запуск → снова в балансировке): $((SECONDS - start)) s"
wait "$load_pid" || echo "load.py завершился с ошибкой"
cat "$result"
echo
done
echo "Результаты в: $OUTPUT_DIR"
+19
View File
@@ -0,0 +1,19 @@
#!/bin/bash
# Скрипт перезапуска всего стенда с сохранением volumes.
set -e
echo "Останавливаем все контейнеры стенда..."
docker compose down
echo "Запускаем стенд заново..."
docker compose up -d
# Готовность (/health/ready) ждёт сам tests/resilience.py — лишний sleep только съедал бюджет 90 с.
echo "Проверяем статус контейнеров..."
docker compose ps
echo "Проверяем health check..."
curl -f http://localhost:8080/health/ready || echo "API ещё не готов"
echo "Стенд успешно перезапущен"
+49
View File
@@ -0,0 +1,49 @@
#!/bin/bash
# Rolling update под нагрузкой: реплики пересобираются и заменяются по одной,
# пока tests/load.py пишет сообщения через nginx.
set -euo pipefail
cd "$(dirname "$0")/.."
BASE_URL="${BASE_URL:-http://localhost:8080}"
DURATION="${DURATION:-60}"
OUTPUT_DIR="${OUTPUT_DIR:-evidence/rolling}"
mkdir -p "$OUTPUT_DIR"
result="$OUTPUT_DIR/rolling_$(date +%Y%m%d_%H%M%S).json"
# healthy ещё не значит «в балансировке»: nginx держит упавшую реплику выключенной fail_timeout=10s.
# Ждём ответ с X-Instance-Id новой реплики, иначе следующая замена оставит nginx без живых backend.
in_rotation() {
local id; id=$(docker compose ps -q "$1" | cut -c1-12)
for _ in $(seq 60); do
curl -s -D - -o /dev/null "$BASE_URL/health/live" | grep -qi "x-instance-id: $id" && return 0
sleep 0.5
done
echo "$1 не вернулась в балансировку за 30 s" >&2; return 1
}
echo "=== Rolling update под нагрузкой (${DURATION}s, 4 потока POST сообщений) ==="
docker compose ps
python3 tests/load.py --base-url "$BASE_URL" --duration "$DURATION" --concurrency 4 --output "$result" >/dev/null &
load_pid=$!
sleep 5
for svc in api-1 api-2; do
# Сборка до остановки: пока собирается образ, реплика продолжает работать.
echo "Собираем образ $svc..."
docker compose build -q "$svc"
# --force-recreate заменяет контейнер, даже если образ не изменился.
echo "Заменяем $svc и ждём healthy..."
start=$SECONDS
docker compose up -d --no-deps --force-recreate --wait "$svc"
in_rotation "$svc"
echo "$svc заменена и снова в балансировке за $((SECONDS - start)) s"
done
echo "Ожидание завершения нагрузки..."
wait "$load_pid" || echo "load.py завершился с ошибкой"
docker compose ps
echo "=== Нагрузка во время rolling update ==="
cat "$result"
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
# Останавливает ровно ту API-реплику, чей X-Instance-Id передан тестом в TARGET_INSTANCE_ID,
# и оставляет её остановленной. X-Instance-Id = hostname = первые 12 символов ID контейнера.
# Восстановление после теста: docker compose start api-1 api-2
set -eu
: "${TARGET_INSTANCE_ID:?тест передаёт X-Instance-Id обслужившей реплики}"
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]* | "") echo "unexpected instance id" >&2; exit 2 ;;
esac
cid=$(docker compose ps -q api-1 api-2 | grep "^$TARGET_INSTANCE_ID" || true)
[ "$(printf "%s\n" "$cid" | grep -c .)" -eq 1 ] || { echo "no single running api container for $TARGET_INSTANCE_ID" >&2; exit 1; }
docker stop "$cid" >/dev/null
echo "stopped $(docker inspect -f "{{.Name}}" "$cid") ($TARGET_INSTANCE_ID)"
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
# Останавливает worker (graceful: текущие попытки дорабатываются ≤ 25 с); очередь и задания остаются.
# Запуск обратно: docker compose start worker
set -eu
cd "$(dirname "$0")/.."
docker compose stop worker
@@ -0,0 +1,217 @@
package ru.mtusi.messenger;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HexFormat;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
import ru.mtusi.messenger.MessengerApplication.ApiException;
// Вложения: метаданные в PostgreSQL, байты в приватном S3. Доступ только через API участникам чата.
// Приём (lab5): оригинал → staging в S3, затем вложение + job + outbox одной транзакцией → 202 queued;
// варианты создаёт worker асинхронно.
@RestController
class Attachments {
static final long MAX_BYTES = 10L * 1024 * 1024;
static final Set<String> VARIANTS = Set.of("thumbnail", "crop", "optimized");
static final Logger log = LoggerFactory.getLogger(Attachments.class);
record Attachment(UUID id, UUID chat_id, UUID owner_id, String filename, String content_type, long size_bytes, String sha256,
String status, List<Variant> variants, String error_code, Instant created_at, Instant updated_at) {}
record Variant(String name, String content_type, long size_bytes, int width, int height, String sha256) {}
final MessengerApplication.Api api;
final JdbcTemplate db;
final Storage storage;
final Jobs jobs;
// Не больше N загрузок на реплику одновременно: диск под временные файлы и CPU проверки ограничены.
final Semaphore uploads = new Semaphore(Integer.parseInt(System.getenv().getOrDefault("MAX_CONCURRENT_UPLOADS", "8")));
Attachments(MessengerApplication.Api api, JdbcTemplate db, Storage storage, Jobs jobs) {
this.api = api;
this.db = db;
this.storage = storage;
this.jobs = jobs;
}
@PostMapping("/api/v1/chats/{id}/attachments")
ResponseEntity<Attachment> upload(@PathVariable UUID id, @RequestParam(required = false) String filename, HttpServletRequest r)
throws IOException, InterruptedException {
// Порядок как у остальных endpoint: сессия → доступ к чату → входные данные.
UUID user = api.auth(r);
if (!api.member(id, user)) throw api.notFound();
if (!validFilename(filename)) api.bad();
String declared = declaredType(r.getContentType());
if (declared == null) throw unsupported();
// Заявленный размер проверяем до чтения тела.
if (r.getContentLengthLong() > MAX_BYTES) throw tooLarge();
if (!uploads.tryAcquire(10, TimeUnit.SECONDS)) throw unavailable("too many concurrent uploads, retry later");
Path tmp = Files.createTempFile("upload-", ".bin");
try {
// 1. Тело — во временный файл с жёстким лимитом, SHA-256 считается по ходу. Файл живёт
// только до конца запроса: это буфер проверки, а не хранилище оригинала.
MessageDigest sha = sha256();
long size = 0;
try (InputStream in = r.getInputStream(); OutputStream out = Files.newOutputStream(tmp)) {
byte[] buf = new byte[65536];
while (true) {
int n;
try { n = in.read(buf); } catch (IOException e) { throw new ApiException(HttpStatus.BAD_REQUEST, "invalid_request", "upload interrupted"); }
if (n < 0) break;
size += n;
if (size > MAX_BYTES) throw tooLarge();
sha.update(buf, 0, n);
out.write(buf, 0, n);
}
}
if (size == 0) api.bad();
// 2. Формат по содержимому, лимит пикселей по заголовку — до распаковки.
ImageCheck.Info image;
try { image = ImageCheck.inspect(tmp); } catch (ImageCheck.Invalid e) { throw e.tooLarge ? tooLarge() : unsupported(); }
if (!image.contentType().equals(declared)) throw unsupported();
// 3. Полный проверенный оригинал — в устойчивый staging (приватный S3-префикс), до записи в БД.
UUID attachmentId = UUID.randomUUID();
String staging = Storage.STAGING + attachmentId;
String hash = HexFormat.of().formatHex(sha.digest());
try {
storage.put(staging, tmp, declared);
} catch (SdkException e) {
log.warn("S3 staging put failed for attachment {}: {}", attachmentId, e.toString());
throw unavailable("object storage is unavailable");
}
// 4. Метаданные, задание и outbox — одна транзакция; 202 только после её COMMIT.
// Не записалось — убираем staging (иначе его удалит очистка staging по retention).
Instant created = now();
try {
jobs.accept(attachmentId, id, user, filename, declared, size, hash, image.width(), image.height(), created);
} catch (RuntimeException e) {
try { storage.delete(staging); } catch (SdkException ignored) {}
throw e;
}
return ResponseEntity.status(202).body(new Attachment(attachmentId, id, user, filename, declared, size, hash, "queued", List.of(), null, created, created));
} finally {
Files.deleteIfExists(tmp);
uploads.release();
}
}
@GetMapping("/api/v1/attachments/{id}")
Attachment metadata(@PathVariable UUID id, HttpServletRequest r) {
return visible(id, api.auth(r)).attachment();
}
// Байты отдаются потоком из S3 через авторизованный API, без redirect на bucket.
@GetMapping("/api/v1/attachments/{id}/content")
void content(@PathVariable UUID id, @RequestParam(required = false) String variant, HttpServletRequest r, HttpServletResponse s) throws IOException {
Visible v = visible(id, api.auth(r));
String name = variant == null ? "original" : variant;
if (!name.equals("original") && !VARIANTS.contains(name)) api.bad();
// queued/processing/failed — 409: оригинал ещё не опубликован, варианты не готовы.
if (!v.attachment().status().equals("ready")) throw new ApiException(HttpStatus.CONFLICT, "conflict", "attachment is not ready");
Attachment a = v.attachment();
String key = v.key(), type = a.content_type();
long size = a.size_bytes();
if (!name.equals("original")) {
Object[] x = db.query("select object_key,content_type,size_bytes from attachment_variants where attachment_id=? and pipeline_version=? and name=?",
rs -> rs.next() ? new Object[]{rs.getString(1), rs.getString(2), rs.getLong(3)} : null, id, v.version(), name);
if (x == null) throw api.notFound();
key = (String) x[0];
type = (String) x[1];
size = (long) x[2];
}
ResponseInputStream<GetObjectResponse> in;
try {
in = storage.get(key);
} catch (NoSuchKeyException e) {
// Метаданные есть, объекта нет: рассинхронизация, её покажет и исправит сверка.
log.error("object {} is missing for ready attachment {}", key, id);
throw new ApiException(HttpStatus.INTERNAL_SERVER_ERROR, "internal_error", "internal server error");
} catch (SdkException e) {
throw unavailable("object storage is unavailable");
}
try (in) {
s.setContentType(type);
s.setContentLengthLong(size);
s.setHeader("Cache-Control", "private, no-store");
s.setHeader("X-Content-Type-Options", "nosniff");
in.transferTo(s.getOutputStream());
}
}
record Visible(Attachment attachment, String key, Integer version) {}
// Вложения чатов, где пользователь участник; uploading/lost и чужие — 404 без раскрытия существования.
// Варианты — только текущей (последней зафиксированной) версии pipeline.
Visible visible(UUID id, UUID user) {
Visible v = db.query("select id,chat_id,owner_id,filename,content_type,size_bytes,sha256,created_at,updated_at,object_key,state,error_code,pipeline_version from attachments a"
+ " where id=? and state in ('queued','processing','ready','failed') and exists(select 1 from chat_members m where m.chat_id=a.chat_id and m.user_id=?)", rs -> {
if (!rs.next()) return null;
String state = rs.getString(11);
Integer version = rs.getObject(13, Integer.class);
List<Variant> variants = state.equals("ready") && version != null ? db.query("select name,content_type,size_bytes,width,height,sha256 from attachment_variants"
+ " where attachment_id=? and pipeline_version=? order by array_position(array['thumbnail','crop','optimized']::text[],name::text)",
(x, n) -> new Variant(x.getString(1), x.getString(2), x.getLong(3), x.getInt(4), x.getInt(5), x.getString(6)), id, version) : List.of();
return new Visible(new Attachment(rs.getObject(1, UUID.class), rs.getObject(2, UUID.class), rs.getObject(3, UUID.class), rs.getString(4), rs.getString(5),
rs.getLong(6), rs.getString(7), state, variants, state.equals("failed") ? rs.getString(12) : null, rs.getTimestamp(8).toInstant(), rs.getTimestamp(9).toInstant()),
rs.getString(10), version);
}, id, user);
if (v == null) throw api.notFound();
return v;
}
// filename только для отображения: 1–255 code points, без путей, NUL и управляющих символов.
static boolean validFilename(String name) {
if (name == null || name.isBlank() || name.equals(".") || name.equals("..")) return false;
if (name.codePointCount(0, name.length()) > 255) return false;
return name.codePoints().noneMatch(c -> c == '/' || c == '\\' || Character.getType(c) == Character.CONTROL
|| c == 0x2028 || c == 0x2029 || Character.getType(c) == Character.SURROGATE);
}
static String declaredType(String header) {
try {
MediaType t = MediaType.parseMediaType(header);
String base = t.getType() + "/" + t.getSubtype();
return base.equals("image/png") || base.equals("image/jpeg") ? base : null;
} catch (RuntimeException e) {
return null;
}
}
static Instant now() { return Instant.now().truncatedTo(ChronoUnit.MICROS); }
static MessageDigest sha256() {
try { return MessageDigest.getInstance("SHA-256"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
}
static ApiException tooLarge() { return new ApiException(HttpStatus.PAYLOAD_TOO_LARGE, "payload_too_large", "attachment exceeds 10 MiB or 40 megapixels"); }
static ApiException unsupported() { return new ApiException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "unsupported_media_type", "only valid PNG or JPEG content is accepted"); }
static ApiException unavailable(String message) { return new ApiException(HttpStatus.SERVICE_UNAVAILABLE, "unavailable", message); }
}
@@ -0,0 +1,72 @@
package ru.mtusi.messenger;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.Scope;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
// RabbitMQ: exchange attachments → quorum-очередь attachments.process (DLX → attachments.dlq).
// Топологию и пользователей создаёт definitions-файл брокера; клиент ничего не объявляет.
@Component
class Broker {
static final String EXCHANGE = "attachments", ROUTING_KEY = "process", QUEUE = "attachments.process";
final ConnectionFactory factory = new ConnectionFactory();
Connection connection;
Channel channel;
volatile boolean returned;
Broker(@Value("${broker.url:amqp://localhost}") String url) throws Exception {
factory.setUri(url.trim());
// Переподключение делаем сами (следующий тик relay/supervisor), без скрытых повторов публикаций.
factory.setAutomaticRecoveryEnabled(false);
factory.setConnectionTimeout(3000);
factory.setRequestedHeartbeat(10);
}
Connection connect(String name, ExecutorService executor) throws Exception {
return factory.newConnection(executor, name);
}
// trace — контекст причины попытки (Jobs.context): в нём агент OTel создаёт span publish и пишет traceparent в headers.
record Message(String id, byte[] body, Context trace) {}
// Пачка с publisher confirms: возврат без исключения = брокер сохранил все сообщения в очереди.
synchronized void publish(List<Message> messages) throws Exception {
try {
if (channel == null || !channel.isOpen()) {
connection = factory.newConnection("publisher");
channel = connection.createChannel();
channel.confirmSelect();
// mandatory: сообщение без маршрута брокер подтвердил бы, но не сохранил — считаем ошибкой.
channel.addReturnListener(r -> returned = true);
}
returned = false;
for (Message m : messages) {
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().contentType("application/json").deliveryMode(2)
.messageId(m.id()).type(Jobs.TYPE).timestamp(new Date()).build();
try (Scope ignored = m.trace().makeCurrent()) {
channel.basicPublish(EXCHANGE, ROUTING_KEY, true, props, m.body());
}
}
channel.waitForConfirmsOrDie(5000);
if (returned) throw new IOException("message was not routed to a queue");
} catch (Exception e) {
close();
throw e;
}
}
synchronized void close() {
if (connection != null) connection.abort(1000);
connection = null;
channel = null;
}
}
@@ -0,0 +1,207 @@
package ru.mtusi.messenger;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.zip.CRC32;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;
// Потоковая проверка PNG/JPEG по содержимому без декодирования в пиксели: память — буферы по 64 KiB,
// а не ширина × высота. Размеры читаются из заголовка, лимит пикселей применяется до распаковки.
final class ImageCheck {
static final long MAX_PIXELS = 40_000_000L;
static final byte[] PNG_SIGNATURE = {(byte) 0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'};
record Info(String contentType, int width, int height) {}
// tooLarge: валидный формат, но больше 40 Мпикс (413); иначе файл повреждён или чужого формата (415).
static final class Invalid extends Exception {
final boolean tooLarge;
Invalid(String message, boolean tooLarge) { super(message); this.tooLarge = tooLarge; }
}
private ImageCheck() {}
static Info inspect(Path file) throws IOException, Invalid {
try (InputStream in = new BufferedInputStream(Files.newInputStream(file), 65536)) {
in.mark(8);
byte[] head = in.readNBytes(8);
in.reset();
if (Arrays.equals(head, PNG_SIGNATURE)) return png(new DataInputStream(in));
if (head.length >= 3 && (head[0] & 0xff) == 0xff && (head[1] & 0xff) == 0xd8 && (head[2] & 0xff) == 0xff) return jpeg(in);
throw bad("not a PNG or JPEG");
}
}
static Invalid bad(String message) { return new Invalid(message, false); }
static void checkPixels(long width, long height) throws Invalid {
if (width <= 0 || height <= 0) throw bad("zero image dimension");
if (width * height > MAX_PIXELS) throw new Invalid("image exceeds 40 megapixels", true);
}
// PNG: CRC каждого chunk, IHDR первым, IEND последним, а IDAT распаковывается в никуда со счётчиком байтов.
// Ровно ожидаемое число байтов после inflate ловит и обрыв, и мусор, и «бомбу» с честным заголовком.
static Info png(DataInputStream in) throws IOException, Invalid {
in.readFully(new byte[8]);
CRC32 crc = new CRC32();
Inflater inflater = new Inflater();
byte[] buf = new byte[65536], out = new byte[65536];
int width = 0, height = 0;
long expected = -1, produced = 0;
boolean first = true, inIdat = false, idatDone = false;
try {
while (true) {
int length = in.readInt();
if (length < 0) throw bad("invalid PNG chunk length");
byte[] type = new byte[4];
in.readFully(type);
String name = new String(type, StandardCharsets.ISO_8859_1);
crc.reset();
crc.update(type);
if (first != name.equals("IHDR")) throw bad("IHDR must be the first chunk");
boolean idat = name.equals("IDAT");
if (idat && (idatDone || expected < 0)) throw bad("IDAT chunks must be consecutive after IHDR");
if (inIdat && !idat) idatDone = true;
inIdat = idat;
if (first) {
if (length != 13) throw bad("invalid IHDR");
byte[] h = new byte[13];
in.readFully(h);
crc.update(h);
width = int32(h, 0);
height = int32(h, 4);
checkPixels(width, height);
expected = rawSize(width, height, h[8] & 0xff, h[9] & 0xff, h[12] & 0xff);
if (h[10] != 0 || h[11] != 0) throw bad("unsupported PNG compression/filter");
} else {
for (long left = length; left > 0; ) {
int n = in.read(buf, 0, (int) Math.min(buf.length, left));
if (n < 0) throw new EOFException();
crc.update(buf, 0, n);
left -= n;
if (!idat || inflater.finished()) continue;
inflater.setInput(buf, 0, n);
while (!inflater.finished() && !inflater.needsInput()) {
int k = inflater.inflate(out);
produced += k;
if (produced > expected) throw bad("PNG pixel data is larger than IHDR declares");
if (k == 0 && inflater.needsDictionary()) throw bad("invalid PNG zlib stream");
if (k == 0) break;
}
}
}
if (in.readInt() != (int) crc.getValue()) throw bad("PNG chunk CRC mismatch");
first = false;
if (name.equals("IEND")) {
if (!inflater.finished() || produced != expected) throw bad("PNG pixel data is truncated");
if (in.read() != -1) throw bad("data after PNG IEND");
return new Info("image/png", width, height);
}
}
} catch (EOFException e) {
throw bad("truncated PNG");
} catch (DataFormatException e) {
throw bad("invalid PNG zlib stream");
} finally {
inflater.end();
}
}
// Размер распакованных строк PNG (с байтом фильтра); для Adam7 — сумма по семи проходам.
static long rawSize(long width, long height, int depth, int colorType, int interlace) throws Invalid {
int channels = switch (colorType) {
case 0 -> depth == 1 || depth == 2 || depth == 4 || depth == 8 || depth == 16 ? 1 : 0;
case 3 -> depth == 1 || depth == 2 || depth == 4 || depth == 8 ? 1 : 0;
case 2 -> depth == 8 || depth == 16 ? 3 : 0;
case 4 -> depth == 8 || depth == 16 ? 2 : 0;
case 6 -> depth == 8 || depth == 16 ? 4 : 0;
default -> 0;
};
if (channels == 0) throw bad("invalid PNG color type/bit depth");
long bits = (long) channels * depth;
if (interlace == 0) return height * (1 + (width * bits + 7) / 8);
if (interlace != 1) throw bad("invalid PNG interlace method");
int[][] passes = {{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}};
long total = 0;
for (int[] p : passes) {
long w = width > p[0] ? (width - p[0] + p[2] - 1) / p[2] : 0;
long h = height > p[1] ? (height - p[1] + p[3] - 1) / p[3] : 0;
if (w > 0 && h > 0) total += h * (1 + (w * bits + 7) / 8);
}
return total;
}
// JPEG: SOI, корректные длины сегментов, SOF до первого SOS, энтропийные данные до EOI.
// Байты после EOI допускаются: их дописывают многие камеры и телефоны.
static Info jpeg(InputStream in) throws IOException, Invalid {
in.skipNBytes(2);
int width = 0, height = 0, marker = -1;
boolean scan = false;
try {
while (true) {
if (marker < 0) {
if (in.read() != 0xff) throw bad("invalid JPEG marker");
do marker = read(in); while (marker == 0xff);
}
int m = marker;
marker = -1;
if (m == 0xd9) {
if (width == 0 || !scan) throw bad("JPEG has no frame or scan");
return new Info("image/jpeg", width, height);
}
if (m == 0x01 || (m >= 0xd0 && m <= 0xd7)) continue;
if (m == 0xd8 || m == 0x00) throw bad("unexpected JPEG marker");
int length = (read(in) << 8) | read(in);
if (length < 2) throw bad("invalid JPEG segment length");
boolean sof = m >= 0xc0 && m <= 0xcf && m != 0xc4 && m != 0xc8 && m != 0xcc;
if (sof) {
if (length < 8 || width != 0) throw bad("invalid JPEG frame header");
in.skipNBytes(1);
height = (read(in) << 8) | read(in);
width = (read(in) << 8) | read(in);
checkPixels(width, height);
in.skipNBytes(length - 7);
} else if (m == 0xda) {
if (width == 0) throw bad("JPEG scan before frame header");
in.skipNBytes(length - 2);
marker = entropy(in);
scan = true;
} else {
in.skipNBytes(length - 2);
}
}
} catch (EOFException e) {
throw bad("truncated JPEG");
}
}
// Пропускает сжатые данные скана; FF00 — экранированный байт, FFD0..FFD7 — restart-маркеры.
static int entropy(InputStream in) throws IOException {
boolean ff = false;
while (true) {
int c = read(in);
if (!ff) { ff = c == 0xff; continue; }
if (c == 0xff) continue;
if (c == 0x00 || (c >= 0xd0 && c <= 0xd7)) { ff = false; continue; }
return c;
}
}
static int read(InputStream in) throws IOException {
int c = in.read();
if (c < 0) throw new EOFException();
return c;
}
static int int32(byte[] b, int at) {
return ((b[at] & 0xff) << 24) | ((b[at + 1] & 0xff) << 16) | ((b[at + 2] & 0xff) << 8) | (b[at + 3] & 0xff);
}
}
@@ -0,0 +1,215 @@
package ru.mtusi.messenger;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
// Варианты изображения: thumbnail (JPEG, вписан в 256×256), crop (JPEG 128×128 из центрального квадрата),
// optimized (WebP, вписан в 1280×1280). EXIF orientation применяется, alpha компонуется на белый,
// метаданные исходника не переносятся. Версия pipeline задаёт параметры кодирования.
final class ImagePipeline {
record Params(float jpegQuality, int webpQuality) {}
static final Map<Integer, Params> VERSIONS = Map.of(1, new Params(0.85f, 80), 2, new Params(0.92f, 90));
// Декодирование с прореживанием до ≤ 12 Мпикс: растр одной задачи ≤ ~48 MiB при любом исходнике ≤ 40 Мпикс.
static final long DECODE_PIXELS = 12_000_000L, MAX_PIXELS = 40_000_000L;
record Output(String name, String contentType, String file, int width, int height, Path path) {}
static final class Invalid extends Exception {
Invalid(String message) { super(message); }
}
static List<Output> render(Path source, String contentType, int version, Path dir, Jobs.Claim c) throws IOException, Invalid {
Params p = VERSIONS.get(version);
if (p == null) throw new Jobs.Permanent("unsupported_pipeline", "unknown pipeline_version " + version);
int orientation = contentType.equals("image/jpeg") ? orientation(source) : 1;
ImageReader reader = ImageIO.getImageReadersByMIMEType(contentType).next();
BufferedImage img;
int w, h;
try (ImageInputStream in = ImageIO.createImageInputStream(source.toFile())) {
reader.setInput(in, true, true);
w = reader.getWidth(0);
h = reader.getHeight(0);
// Повторная проверка лимита пикселей по заголовку до декодирования.
if ((long) w * h > MAX_PIXELS) throw new Invalid("too many pixels");
int s = 1;
while ((long) ((w + s - 1) / s) * ((h + s - 1) / s) > DECODE_PIXELS) s++;
ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(s, s, 0, 0);
c.reader = reader;
img = reader.read(0, param);
} catch (IOException | RuntimeException e) {
c.check();
throw new Invalid(e.toString());
} finally {
c.reader = null;
reader.dispose();
}
// abort() по таймауту или потере аренды прерывает read: частичный растр не используем.
c.check();
int dw = img.getWidth(), dh = img.getHeight();
boolean swap = orientation >= 5;
int ow = swap ? h : w, oh = swap ? w : h;
List<Output> out = new ArrayList<>();
int[] t = fit(ow, oh, 256);
out.add(jpeg("thumbnail", orient(scale(img, 0, 0, dw, dh, swap ? t[1] : t[0], swap ? t[0] : t[1]), orientation), p.jpegQuality(), dir));
c.check();
int side = Math.min(dw, dh);
out.add(jpeg("crop", orient(scale(img, (dw - side) / 2, (dh - side) / 2, side, side, 128, 128), orientation), p.jpegQuality(), dir));
c.check();
int[] o = fit(ow, oh, 1280);
out.add(webp(orient(scale(img, 0, 0, dw, dh, swap ? o[1] : o[0], swap ? o[0] : o[1]), orientation), p.webpQuality(), dir, c));
return out;
}
// Вписать в box×box с сохранением пропорций, без увеличения; округление вниз, минимум 1 px.
static int[] fit(int w, int h, int box) {
if (w <= box && h <= box) return new int[]{w, h};
return w >= h ? new int[]{box, (int) Math.max(1, (long) h * box / w)} : new int[]{(int) Math.max(1, (long) w * box / h), box};
}
// Область исходника → tw×th на белом фоне; сильное уменьшение — последовательными halving-шагами.
static BufferedImage scale(BufferedImage src, int sx, int sy, int sw, int sh, int tw, int th) {
BufferedImage cur = src;
while (sw / 2 >= tw && sh / 2 >= th) {
BufferedImage next = canvas(sw / 2, sh / 2);
draw(next, cur, sx, sy, sw, sh, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
cur = next;
sx = 0;
sy = 0;
sw = next.getWidth();
sh = next.getHeight();
}
BufferedImage out = canvas(tw, th);
draw(out, cur, sx, sy, sw, sh, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
return out;
}
static BufferedImage canvas(int w, int h) {
BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g = img.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(0, 0, w, h);
g.dispose();
return img;
}
static void draw(BufferedImage dst, BufferedImage src, int sx, int sy, int sw, int sh, Object interpolation) {
Graphics2D g = dst.createGraphics();
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolation);
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g.drawImage(src, 0, 0, dst.getWidth(), dst.getHeight(), sx, sy, sx + sw, sy + sh, null);
g.dispose();
}
// EXIF Orientation 1–8 → поворот/отражение готового (маленького) растра.
static BufferedImage orient(BufferedImage s, int o) {
if (o <= 1 || o > 8) return s;
int w = s.getWidth(), h = s.getHeight();
BufferedImage d = new BufferedImage(o >= 5 ? h : w, o >= 5 ? w : h, BufferedImage.TYPE_INT_RGB);
for (int y = 0; y < h; y++)
for (int x = 0; x < w; x++) {
int dx, dy;
switch (o) {
case 2 -> { dx = w - 1 - x; dy = y; }
case 3 -> { dx = w - 1 - x; dy = h - 1 - y; }
case 4 -> { dx = x; dy = h - 1 - y; }
case 5 -> { dx = y; dy = x; }
case 6 -> { dx = h - 1 - y; dy = x; }
case 7 -> { dx = h - 1 - y; dy = w - 1 - x; }
default -> { dx = y; dy = w - 1 - x; }
}
d.setRGB(dx, dy, s.getRGB(x, y));
}
return d;
}
// Тег 0x0112 из APP1 Exif; любая нестандартная структура — ориентация по умолчанию.
static int orientation(Path file) {
try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(file)))) {
if (in.readUnsignedShort() != 0xFFD8) return 1;
while (true) {
int marker = in.readUnsignedShort();
if ((marker & 0xFF00) != 0xFF00 || marker == 0xFFDA || marker == 0xFFD9) return 1;
int len = in.readUnsignedShort();
if (len < 2) return 1;
byte[] seg = new byte[len - 2];
in.readFully(seg);
if (marker == 0xFFE1 && seg.length > 14 && new String(seg, 0, 6, StandardCharsets.ISO_8859_1).equals("Exif\0\0")) {
ByteBuffer b = ByteBuffer.wrap(seg).order(seg[6] == 'I' ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
int ifd = 6 + b.getInt(10), n = b.getShort(ifd) & 0xFFFF;
for (int i = 0; i < n; i++) {
int e = ifd + 2 + i * 12;
if ((b.getShort(e) & 0xFFFF) == 0x0112) {
int v = b.getShort(e + 8) & 0xFFFF;
return v >= 1 && v <= 8 ? v : 1;
}
}
return 1;
}
}
} catch (IOException | RuntimeException e) {
return 1;
}
}
static Output jpeg(String name, BufferedImage img, float quality, Path dir) throws IOException {
Path file = dir.resolve(name + ".jpg");
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
ImageWriteParam param = writer.getDefaultWriteParam();
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(quality);
try (ImageOutputStream out = ImageIO.createImageOutputStream(file.toFile())) {
writer.setOutput(out);
writer.write(null, new IIOImage(img, null, null), param);
} finally {
writer.dispose();
}
return new Output(name, "image/jpeg", name + ".jpg", img.getWidth(), img.getHeight(), file);
}
// cwebp (libwebp): -q качество, -metadata none — без EXIF/XMP/ICC. Отдельный процесс с таймаутом.
static Output webp(BufferedImage img, int quality, Path dir, Jobs.Claim c) throws IOException {
Path png = dir.resolve("optimized.png"), file = dir.resolve("optimized.webp");
ImageIO.write(img, "png", png.toFile());
Process proc = new ProcessBuilder("cwebp", "-quiet", "-q", String.valueOf(quality), "-metadata", "none", png.toString(), "-o", file.toString())
.redirectErrorStream(true).redirectOutput(ProcessBuilder.Redirect.DISCARD).start();
c.process = proc;
try {
if (!proc.waitFor(30, TimeUnit.SECONDS)) {
proc.destroyForcibly();
throw new IOException("cwebp timeout");
}
} catch (InterruptedException e) {
proc.destroyForcibly();
Thread.currentThread().interrupt();
throw new IOException("interrupted");
} finally {
c.process = null;
}
c.check();
if (proc.exitValue() != 0) throw new IOException("cwebp exit code " + proc.exitValue());
return new Output("optimized", "image/webp", "optimized.webp", img.getWidth(), img.getHeight(), file);
}
}
+498
View File
@@ -0,0 +1,498 @@
package ru.mtusi.messenger;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleHistogram;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.TextMapGetter;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import javax.imageio.ImageReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
// Задания обработки вложений. Источник истины — таблица jobs в PostgreSQL; сообщение брокера —
// только сигнал «попытка attempt задания job_id готова к запуску» (contracts/jobs.schema.json).
//
// - вложение, job и запись outbox пишутся одной транзакцией с приёмом файла, публикует relay;
// - attempt — fencing token: захват, продление аренды и фиксация результата сверяют его в БД;
// - эффект идемпотентен по (attachment_id, pipeline_version, variant): детерминированные ключи S3 и PK.
@Component
class Jobs {
static final String TYPE = "attachment.process.v1";
static final int MAX_ATTEMPTS = env("JOB_MAX_ATTEMPTS", 5);
static final int TIMEOUT_SECONDS = env("JOB_TIMEOUT_SECONDS", 60);
static final int LEASE_SECONDS = env("JOB_LEASE_SECONDS", 15);
static final int PIPELINE_VERSION = env("PIPELINE_VERSION", 1);
static final long BACKOFF_BASE_MS = env("JOB_BACKOFF_BASE_MS", 1000), BACKOFF_MAX_MS = env("JOB_BACKOFF_MAX_MS", 30000);
static final long STAGING_RETENTION_SECONDS = env("STAGING_RETENTION_SECONDS", 86400);
// Внедрение сбоев только при FAULT_INJECTION=1; точку выбирает префикс имени файла fault-<point>.
static final boolean FAULTS = "1".equals(System.getenv("FAULT_INJECTION"));
static final String ACTOR = System.getenv().getOrDefault("HOSTNAME", "local");
static final ObjectMapper JSON = new ObjectMapper();
static final Logger log = LoggerFactory.getLogger(Jobs.class);
// От устойчивого приёма (COMMIT при 202) до публикации ready.
// Границы покрывают норму (1–3 с), порог SLO 10 с и долгий backlog после остановки worker.
static final DoubleHistogram TIME_TO_READY = GlobalOpenTelemetry.getMeter("ru.mtusi.messenger.worker").histogramBuilder("messenger.attachment.time_to_ready")
.setUnit("s").setDescription("От durable acceptance до публикации ready")
.setExplicitBucketBoundariesAdvice(java.util.List.of(0.5, 1.0, 2.0, 3.0, 5.0, 7.5, 10.0, 15.0, 20.0, 30.0, 60.0, 120.0, 300.0)).build();
final JdbcTemplate db;
final TransactionTemplate tx, separate;
final Broker broker;
final boolean relayEnabled;
long relayPausedUntil, lastWarning;
Jobs(JdbcTemplate db, PlatformTransactionManager tm, Broker broker, @Value("${outbox.enabled:true}") boolean relayEnabled) {
this.db = db;
this.broker = broker;
this.relayEnabled = relayEnabled;
tx = new TransactionTemplate(tm);
separate = new TransactionTemplate(tm);
separate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
// Очередь из БД (источник истины, а не счётчик брокера). Отдают все процессы с агентом — API и worker,
// поэтому возраст задач виден и при остановленном worker; в запросах берём max().
var meter = GlobalOpenTelemetry.getMeter("ru.mtusi.messenger.worker");
var queue = io.opentelemetry.api.common.Attributes.of(io.opentelemetry.api.common.AttributeKey.stringKey("queue"), Broker.QUEUE);
meter.gaugeBuilder("messenger.queue.depth").ofLongs().setUnit("{job}").setDescription("Задания в состоянии queued")
.buildWithCallback(m -> m.record((long) queued()[0], queue));
meter.gaugeBuilder("messenger.queue.oldest_age").setUnit("s").setDescription("Возраст самого старого queued-задания")
.buildWithCallback(m -> m.record(queued()[1], queue));
}
static int env(String name, int fallback) {
return Integer.parseInt(System.getenv().getOrDefault(name, String.valueOf(fallback)));
}
@JsonInclude(JsonInclude.Include.NON_NULL)
record Msg(Integer schema_version, UUID job_id, String type, UUID attachment_id, Integer pipeline_version, Integer attempt,
String created_at, String traceparent, String tracestate) {}
record Variant(String name, String contentType, long size, int width, int height, String sha256, String key) {}
record Source(String contentType, long size, String sha256, String key) {}
// Приём: метаданные, задание и outbox — одна транзакция. После COMMIT работа не теряется
// ни при падении API, ни при недоступном брокере: relay опубликует позже.
void accept(UUID id, UUID chat, UUID owner, String filename, String type, long size, String sha256, int width, int height, Instant at) {
Timestamp ts = Timestamp.from(at);
tx.executeWithoutResult(s -> {
db.update("insert into attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,width,height,state,object_key,created_at,updated_at)"
+ " values(?,?,?,?,?,?,?,?,?,'queued',?,?,?)", id, chat, owner, filename, type, size, sha256, width, height, Storage.ORIGINALS + id, ts, ts);
UUID job = UUID.randomUUID();
db.update("insert into jobs(job_id,attachment_id,pipeline_version,state,attempt,attempts_limit,created_at,updated_at) values(?,?,?,'queued',1,?,?,?)",
job, id, PIPELINE_VERSION, MAX_ATTEMPTS, ts, ts);
enqueue(job, 1, 0);
audit(job, 1, "accepted", null);
});
}
// Outbox relay работает в API-репликах и в worker; FOR UPDATE SKIP LOCKED делит записи между ними.
// Падение после publish до DELETE даёт повторную публикацию — её гасит идемпотентный consumer.
// ponytail: опрос раз в секунду (+≤1 с к времени до ready); LISTEN/NOTIFY — если задержка станет важна.
@Scheduled(fixedDelayString = "${outbox.poll:PT1S}")
void relay() {
if (!relayEnabled || System.currentTimeMillis() < relayPausedUntil) return;
try {
while (Boolean.TRUE.equals(tx.execute(s -> relayBatch()))) {
// полная пачка: сразу следующая
}
} catch (RuntimeException e) {
relayPausedUntil = System.currentTimeMillis() + 2000;
if (System.currentTimeMillis() - lastWarning > 30000) {
lastWarning = System.currentTimeMillis();
log.warn("outbox relay paused: {}", e.toString());
}
}
}
record Pending(long id, UUID job, int attempt, UUID attachment, int version, Instant created, String filename, String traceparent, String tracestate) {}
boolean relayBatch() {
List<Pending> rows = db.query("select o.id,o.job_id,o.attempt,j.attachment_id,j.pipeline_version,j.created_at,a.filename,o.traceparent,o.tracestate from outbox o"
+ " join jobs j on j.job_id=o.job_id join attachments a on a.id=j.attachment_id where o.available_at<=now() order by o.id limit 100 for update of o skip locked",
(rs, n) -> new Pending(rs.getLong(1), rs.getObject(2, UUID.class), rs.getInt(3), rs.getObject(4, UUID.class), rs.getInt(5), rs.getTimestamp(6).toInstant(), rs.getString(7),
rs.getString(8), rs.getString(9)));
if (rows.isEmpty()) return false;
List<Broker.Message> messages = new ArrayList<>();
for (Pending r : rows) {
crash("crash-before-publish", r.attachment(), r.filename());
messages.add(new Broker.Message(r.job() + "/" + r.attempt(), message(r), context(r.traceparent(), r.tracestate())));
}
try {
broker.publish(messages);
} catch (Exception e) {
throw new IllegalStateException("publish failed: " + e, e);
}
for (Pending r : rows) crash("crash-after-publish", r.attachment(), r.filename());
db.update("delete from outbox where id=any(?)", (Object) rows.stream().map(Pending::id).toArray(Long[]::new));
return rows.size() == 100;
}
static byte[] message(Pending r) {
try {
return JSON.writeValueAsBytes(new Msg(1, r.job(), TYPE, r.attachment(), r.version(), r.attempt(), r.created().toString(), r.traceparent(), r.tracestate()));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
// Запись outbox с W3C trace context текущего span: upload (HTTP server span API) или неудачная попытка
// (consumer span worker). Нет активного span (lease sweep, jobctl без агента) — NULL, публикация начнёт новый trace.
void enqueue(UUID job, int attempt, double delaySeconds) {
Map<String, String> t = new HashMap<>();
W3CTraceContextPropagator.getInstance().inject(Context.current(), t, Map::put);
String state = t.get("tracestate");
db.update("insert into outbox(job_id,attempt,available_at,traceparent,tracestate) values(?,?,now()+make_interval(secs=>?),?,?)",
job, attempt, delaySeconds, t.get("traceparent"), state != null && state.length() <= 512 ? state : null);
}
static final TextMapGetter<Map<String, String>> CARRIER = new TextMapGetter<>() {
@Override
public Iterable<String> keys(Map<String, String> carrier) {
return carrier.keySet();
}
@Override
public String get(Map<String, String> carrier, String key) {
return carrier == null ? null : carrier.get(key);
}
};
// Контекст публикации из outbox: span publish агента станет дочерним к причине попытки (без неё — корнем
// нового trace, а не тиком relay), агент же переносит его в headers AMQP до consumer span worker.
static Context context(String traceparent, String tracestate) {
Map<String, String> t = new HashMap<>();
if (traceparent != null) t.put("traceparent", traceparent);
if (tracestate != null) t.put("tracestate", tracestate);
return W3CTraceContextPropagator.getInstance().extract(Context.root(), t, CARRIER);
}
// Строгая проверка по jobs.schema.json; лишние поля — ошибка разбора (сообщение уйдёт в DLQ).
static Msg parse(byte[] body) throws IOException {
Msg m = JSON.readValue(body, Msg.class);
if (!Integer.valueOf(1).equals(m.schema_version()) || !TYPE.equals(m.type()) || m.job_id() == null || m.attachment_id() == null
|| m.pipeline_version() == null || m.pipeline_version() < 1 || m.attempt() == null || m.attempt() < 1 || m.created_at() == null)
throw new IOException("message does not match jobs.schema.json");
Instant.parse(m.created_at());
return m;
}
// Захват попытки: только queued с тем же attempt. Иначе дубль или устаревшее сообщение — no-op и ack.
Claim claim(Msg m) {
return tx.execute(s -> {
List<Claim> claimed = db.query("update jobs j set state='processing',lease_owner=?,lease_until=now()+make_interval(secs=>?),started_at=now(),updated_at=now()"
+ " from attachments a where j.job_id=? and j.state='queued' and j.attempt=? and j.attachment_id=? and j.pipeline_version=? and a.id=j.attachment_id"
+ " returning a.filename", (rs, n) -> new Claim(m.job_id(), m.attachment_id(), m.attempt(), m.pipeline_version(), rs.getString(1)),
ACTOR, LEASE_SECONDS, m.job_id(), m.attempt(), m.attachment_id(), m.pipeline_version());
if (claimed.isEmpty()) {
// Причина — в audit: по нему эксперимент считает погашенные дубли.
String why = db.query("select state,attempt from jobs where job_id=?", rs -> !rs.next() ? "unknown_job"
: rs.getString(1).equals("done") ? "duplicate_done" : rs.getInt(2) > m.attempt() ? "stale_attempt"
: rs.getString(1).equals("processing") ? "duplicate_in_progress" : rs.getString(1).equals("failed") ? "dropped_failed" : "mismatch", m.job_id());
if (!why.equals("unknown_job")) audit(m.job_id(), m.attempt(), why, null);
log.info("job {} attempt {}: {}, ack without processing", m.job_id(), m.attempt(), why);
return null;
}
// ready-вложение (новая версия pipeline) остаётся ready: старый результат отдаётся до новой фиксации.
db.update("update attachments set state='processing',updated_at=now() where id=? and state='queued'", m.attachment_id());
audit(m.job_id(), m.attempt(), "claimed", null);
return claimed.get(0);
});
}
// [число queued-заданий, возраст самого старого в секундах] — для метрик очереди.
double[] queued() {
return db.queryForObject("select count(*),coalesce(extract(epoch from now()-min(updated_at)),0) from jobs where state='queued'",
(rs, n) -> new double[]{rs.getLong(1), rs.getDouble(2)});
}
Source source(UUID attachment) {
return db.queryForObject("select content_type,size_bytes,sha256,object_key from attachments where id=?",
(rs, n) -> new Source(rs.getString(1), rs.getLong(2), rs.getString(3), rs.getString(4)), attachment);
}
// Heartbeat: продлевает аренду, но не дальше JOB_TIMEOUT_SECONDS от начала попытки.
boolean extend(Claim c) {
return db.update("update jobs set lease_until=now()+make_interval(secs=>?) where job_id=? and state='processing' and attempt=? and started_at>now()-make_interval(secs=>?)",
LEASE_SECONDS, c.job, c.attempt, TIMEOUT_SECONDS) == 1;
}
// Фиксация результата: варианты, указатель версии и done — атомарно и только владельцем попытки.
boolean complete(Claim c, List<Variant> variants) {
return Boolean.TRUE.equals(tx.execute(s -> {
if (lock(c) == null) return false;
for (Variant v : variants)
db.update("insert into attachment_variants(attachment_id,pipeline_version,name,content_type,size_bytes,width,height,sha256,object_key,job_id)"
+ " values(?,?,?,?,?,?,?,?,?,?) on conflict do nothing", c.attachment, c.version, v.name(), v.contentType(), v.size(), v.width(), v.height(), v.sha256(), v.key(), c.job);
// Указатель текущей версии только растёт: старая job после новой не перезапишет результат.
boolean current = db.update("update attachments set state='ready',error_code=null,pipeline_version=?,updated_at=now() where id=? and state<>'lost'"
+ " and coalesce(pipeline_version,0)<=?", c.version, c.attachment, c.version) == 1;
db.update("update jobs set state='done',lease_owner=null,lease_until=null,error_code=null,updated_at=now() where job_id=?", c.job);
audit(c.job, c.attempt, "done", current ? "current" : "superseded");
if (current && c.version == 1)
TIME_TO_READY.record(db.queryForObject("select extract(epoch from now()-created_at) from attachments where id=?", Double.class, c.attachment));
return true;
}));
}
// Временная ошибка: следующая попытка через backoff с jitter, после исчерпания — failed/retry_exhausted.
void retry(Claim c, Exception error) {
tx.executeWithoutResult(s -> {
Integer limit = lock(c);
if (limit == null) return;
if (c.attempt >= limit) {
failLocked(c.job, c.attempt, c.attachment, "retry_exhausted", error.toString());
return;
}
long cap = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS << Math.min(20, c.attempt - 1));
long delay = cap / 2 + ThreadLocalRandom.current().nextLong(cap / 2 + 1);
requeueLocked(c.job, c.attempt, c.attachment, delay, "retry_scheduled", error.toString());
});
}
void fail(Claim c, String code, String error) {
tx.executeWithoutResult(s -> {
if (lock(c) != null) failLocked(c.job, c.attempt, c.attachment, code, error);
});
}
// Fencing: попытка ещё владеет заданием; строка заблокирована до конца транзакции. null — не владеет.
Integer lock(Claim c) {
Integer limit = db.query("select attempts_limit from jobs where job_id=? and state='processing' and attempt=? for update",
rs -> rs.next() ? rs.getInt(1) : null, c.job, c.attempt);
if (limit == null) log.warn("job {} attempt {} no longer owns the lease, result discarded", c.job, c.attempt);
return limit;
}
void requeueLocked(UUID job, int attempt, UUID attachment, long delayMs, String event, String error) {
db.update("update jobs set state='queued',attempt=attempt+1,lease_owner=null,lease_until=null,next_attempt_at=now()+make_interval(secs=>?),last_error=?,updated_at=now() where job_id=?",
delayMs / 1000.0, truncate(error), job);
db.update("update attachments set state='queued',updated_at=now() where id=? and state='processing'", attachment);
enqueue(job, attempt + 1, delayMs / 1000.0);
audit(job, attempt, event, "next_attempt=" + (attempt + 1) + " delay_ms=" + delayMs + " error=" + truncate(error));
}
void failLocked(UUID job, int attempt, UUID attachment, String code, String error) {
db.update("update jobs set state='failed',error_code=?,last_error=?,lease_owner=null,lease_until=null,updated_at=now() where job_id=?", code, truncate(error), job);
// failed только у вложения без готовой версии: ready (другая версия pipeline) не откатывается.
db.update("update attachments set state='failed',error_code=?,updated_at=now() where id=? and state in ('queued','processing') and pipeline_version is null", code, attachment);
audit(job, attempt, "failed", code);
}
// Истёкшая аренда: worker умер или завис (heartbeat не продлевал) — следующая попытка, без второго эффекта.
void sweep() {
tx.executeWithoutResult(s -> {
List<Object[]> expired = db.query("select job_id,attempt,attempts_limit,attachment_id from jobs where state='processing' and lease_until<now()"
+ " order by lease_until limit 100 for update skip locked", (rs, n) -> new Object[]{rs.getObject(1, UUID.class), rs.getInt(2), rs.getInt(3), rs.getObject(4, UUID.class)});
for (Object[] j : expired) {
UUID job = (UUID) j[0], attachment = (UUID) j[3];
int attempt = (int) j[1];
if (attempt >= (int) j[2]) failLocked(job, attempt, attachment, "retry_exhausted", "lease expired");
else requeueLocked(job, attempt, attachment, 0, "lease_expired", "lease expired");
}
});
}
// Staging удаляется после безопасной фиксации (ready); непривязанные и failed — после retention.
int sweepStaging(Storage storage) {
int deleted = 0;
Instant cutoff = Instant.now().minusSeconds(STAGING_RETENTION_SECONDS);
for (ListObjectsV2Response page : storage.list(Storage.STAGING)) {
Map<UUID, S3Object> objects = new HashMap<>();
for (S3Object o : page.contents()) {
try { objects.put(UUID.fromString(o.key().substring(Storage.STAGING.length())), o); } catch (IllegalArgumentException ignored) {}
}
if (objects.isEmpty()) continue;
Map<UUID, Object[]> rows = new HashMap<>();
db.query("select id,state,updated_at from attachments where id=any(?)", rs -> {
rows.put(rs.getObject(1, UUID.class), new Object[]{rs.getString(2), rs.getTimestamp(3).toInstant()});
}, (Object) objects.keySet().toArray(new UUID[0]));
for (Map.Entry<UUID, S3Object> e : objects.entrySet()) {
Object[] r = rows.get(e.getKey());
boolean delete = r == null ? e.getValue().lastModified().isBefore(cutoff)
: r[0].equals("ready") || (r[0].equals("failed") && ((Instant) r[1]).isBefore(cutoff));
if (delete) {
storage.delete(e.getValue().key());
deleted++;
}
}
}
if (deleted > 0) log.info("staging sweep deleted {} objects", deleted);
return deleted;
}
// Операторские команды: docker compose run --rm jobctl <command>.
int cli(String[] args) throws IOException {
String command = args.length > 0 ? args[0] : "";
Object result;
switch (command) {
case "status" -> {
Map<String, Object> r = new LinkedHashMap<>();
r.put("jobs", db.queryForList("select pipeline_version,state,count(*) from jobs group by 1,2 order by 1,2"));
r.put("attachments", db.queryForList("select state,count(*) from attachments group by 1 order by 1"));
r.put("outbox_pending", db.queryForObject("select count(*) from outbox", Long.class));
r.put("failed", db.queryForList("select job_id::text,attachment_id::text,pipeline_version,attempt,error_code,updated_at::text from jobs where state='failed' order by updated_at desc limit 50"));
result = r;
}
case "replay" -> {
List<UUID> ids = args.length > 1 && args[1].equals("--all-failed")
? db.queryForList("select job_id from jobs where state='failed'", UUID.class) : ids(args, 1);
Map<String, String> r = new LinkedHashMap<>();
for (UUID id : ids) r.put(id.toString(), replay(id));
result = r;
}
case "reprocess" -> {
if (args.length < 3 || !args[1].startsWith("--pipeline-version=")) return usage();
int version = Integer.parseInt(args[1].substring(19));
boolean all = args[2].equals("--all");
result = Map.of("jobs_created", reprocess(version, all ? List.of() : ids(args, 2), all));
}
case "redispatch" -> {
long older = args.length > 1 && args[1].startsWith("--older-than=") ? Long.parseLong(args[1].substring(13)) : 300;
result = Map.of("republished", redispatch(older));
}
default -> { return usage(); }
}
System.out.println(JSON.copy().enable(SerializationFeature.INDENT_OUTPUT).writeValueAsString(result));
return 0;
}
static int usage() {
System.err.println("usage: jobctl status | replay <job_id>...|--all-failed | reprocess --pipeline-version=N <attachment_id>...|--all | redispatch [--older-than=SECONDS]");
return 2;
}
static List<UUID> ids(String[] args, int from) {
List<UUID> ids = new ArrayList<>();
for (int i = from; i < args.length; i++) ids.add(UUID.fromString(args[i]));
return ids;
}
// Явный replay только failed: done-задание не исполняется повторно, прежний эффект защищён PK и fencing.
String replay(UUID job) {
return tx.execute(s -> {
Object[] j = db.query("select state,attempt,attachment_id from jobs where job_id=? for update",
rs -> rs.next() ? new Object[]{rs.getString(1), rs.getInt(2), rs.getObject(3, UUID.class)} : null, job);
if (j == null) return "unknown job";
if (!j[0].equals("failed")) return "skipped: job is " + j[0];
int attempt = (int) j[1] + 1;
db.update("update jobs set state='queued',attempt=?,attempts_limit=?,error_code=null,next_attempt_at=now(),updated_at=now() where job_id=?",
attempt, attempt + MAX_ATTEMPTS - 1, job);
db.update("update attachments set state='queued',error_code=null,updated_at=now() where id=? and state='failed'", j[2]);
enqueue(job, attempt, 0);
audit(job, attempt, "replayed", "operator");
return "queued as attempt " + attempt;
});
}
// Новая версия pipeline — новая логическая работа (новый job_id); на одну версию не больше одной job.
int reprocess(int version, List<UUID> ids, boolean all) {
return db.update("with j as (insert into jobs(job_id,attachment_id,pipeline_version,state,attempt,attempts_limit,created_at,updated_at)"
+ " select gen_random_uuid(),id,?,'queued',1,?,now(),now() from attachments where state in ('queued','processing','ready') and (? or id=any(?))"
+ " on conflict (attachment_id,pipeline_version) do nothing returning job_id) insert into outbox(job_id,attempt) select job_id,1 from j",
version, MAX_ATTEMPTS, all, ids.toArray(new UUID[0]));
}
// Ручное восстановление queued-заданий, чьё сообщение потеряно (например, ушло в DLQ по delivery-limit).
int redispatch(long olderThanSeconds) {
return db.update("with r as (update jobs j set next_attempt_at=now(),updated_at=now() where state='queued' and next_attempt_at<now()-make_interval(secs=>?)"
+ " and not exists(select 1 from outbox o where o.job_id=j.job_id) returning job_id,attempt) insert into outbox(job_id,attempt) select job_id,attempt from r", olderThanSeconds);
}
void audit(UUID job, int attempt, String event, String detail) {
db.update("insert into job_audit(job_id,attempt,event,actor,detail) values(?,?,?,?,?)", job, attempt, event, ACTOR, detail);
}
static String truncate(String s) {
return s == null || s.length() <= 500 ? s : s.substring(0, 500);
}
// Аварийная остановка процесса в заданной точке, один раз на вложение (отметка коммитится до halt).
void crash(String point, UUID attachment, String filename) {
if (!FAULTS || filename == null || !filename.startsWith("fault-" + point)) return;
Integer fired = separate.execute(s -> db.update("insert into fault_marks(point,attachment_id) values(?,?) on conflict do nothing", point, attachment));
if (fired == null || fired == 0) return;
log.warn("FAULT INJECTION {}: halting process (attachment {})", point, attachment);
// Пауза, чтобы уже отправляемый HTTP-ответ этого процесса дошёл: падение — именно в фоновой точке.
try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
Runtime.getRuntime().halt(137);
}
// Захваченная попытка в worker: флаги для heartbeat/таймаута и ссылки, которые прерывает abort().
static final class Claim {
final UUID job, attachment;
final int attempt, version;
final String filename;
final long started = System.nanoTime();
volatile boolean fenced;
volatile ImageReader reader;
volatile Process process;
Claim(UUID job, UUID attachment, int attempt, int version, String filename) {
this.job = job;
this.attachment = attachment;
this.attempt = attempt;
this.version = version;
this.filename = filename;
}
long elapsedSeconds() {
return (System.nanoTime() - started) / 1_000_000_000L;
}
long elapsedNanos() {
return System.nanoTime() - started;
}
// Перед каждым побочным эффектом: аренда потеряна — стоп без записи; превышен таймаут — временная ошибка.
void check() {
if (fenced) throw new Fenced();
if (elapsedSeconds() >= TIMEOUT_SECONDS) throw new TimedOut();
}
void abort() {
ImageReader r = reader;
if (r != null) r.abort();
Process p = process;
if (p != null) p.destroyForcibly();
}
}
static final class Fenced extends RuntimeException {
Fenced() { super("lease lost"); }
}
static final class TimedOut extends RuntimeException {
TimedOut() { super("job timeout exceeded"); }
}
static final class Permanent extends RuntimeException {
final String code;
Permanent(String code, String message) {
super(message);
this.code = code;
}
}
}
@@ -0,0 +1,499 @@
package ru.mtusi.messenger;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.*;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import com.fasterxml.jackson.databind.JsonNode;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.MapperFeature;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.time.*;
import java.util.*;
import java.util.Base64;
// Главная аннотация Spring Boot: включает запуск приложения и автоматическую настройку.
// @EnableScheduling запускает периодическую сверку БД и S3 (Reconciler) в API-репликах.
@SpringBootApplication
@EnableScheduling
public class MessengerApplication {
// Идентификатор экземпляра API = hostname контейнера (первые 12 символов ID контейнера в Docker).
// По нему scripts/stop-one.sh находит и останавливает нужную реплику.
private static final String INSTANCE_ID = System.getenv().getOrDefault("HOSTNAME", UUID.randomUUID().toString());
// Один образ — пять режимов: api (HTTP-сервер, по умолчанию), migrate (Flyway и выход),
// worker (обработка заданий из брокера), reconcile (сверка БД и S3) и jobctl (операторские команды заданий).
public static void main(String[] args) throws IOException {
String mode = args.length > 0 ? args[0] : "api";
if (mode.equals("api")) {
SpringApplication.run(MessengerApplication.class, args);
return;
}
if (mode.equals("migrate")) {
// Только Flyway, без контекста Spring: контейнеру migration не нужны ни Redis, ни S3, ни их секреты.
String password = java.nio.file.Files.readString(java.nio.file.Path.of("/run/secrets/spring.datasource.password")).trim();
org.flywaydb.core.Flyway.configure().dataSource(System.getenv("SPRING_DATASOURCE_URL"), System.getenv("SPRING_DATASOURCE_USERNAME"), password).load().migrate();
return;
}
if (mode.equals("worker")) {
// Без HTTP: процесс живёт за счёт потоков consumer/планировщика; SIGTERM — graceful stop.
new SpringApplicationBuilder(MessengerApplication.class).web(WebApplicationType.NONE)
.properties("reconcile.enabled=false", "worker.enabled=true").run();
return;
}
if (!mode.equals("reconcile") && !mode.equals("jobctl")) {
System.err.println("usage: [api | migrate | worker | reconcile [--apply] [--grace-seconds=N] [--verify-checksums] | jobctl <command>]");
System.exit(2);
}
ConfigurableApplicationContext ctx = new SpringApplicationBuilder(MessengerApplication.class)
.web(WebApplicationType.NONE)
.properties("reconcile.enabled=false", "outbox.enabled=false", "spring.main.banner-mode=off", "logging.level.root=WARN")
.run();
int code;
try {
String[] rest = Arrays.copyOfRange(args, 1, args.length);
code = mode.equals("jobctl") ? ctx.getBean(Jobs.class).cli(rest) : ctx.getBean(Reconciler.class).cli(rest);
} catch (Exception e) {
LoggerFactory.getLogger(MessengerApplication.class).error(mode + " failed", e);
code = 1;
}
int exit = code;
System.exit(SpringApplication.exit(ctx, () -> exit));
}
// @Bean регистрирует возвращаемый объект в контейнере Spring.
// BCrypt хранит пароль в виде хеша, поэтому исходный пароль не попадает в базу.
@Bean
BCryptPasswordEncoder passwordEncoder() {
// Возвращаем BCrypt-кодировщик, который Spring передаст контроллеру.
return new BCryptPasswordEncoder();
}
// Отключаем автоматическое превращение чисел в строки при чтении JSON.
@Bean
Jackson2ObjectMapperBuilderCustomizer strictJson() {
return builder -> builder.featuresToDisable(MapperFeature.ALLOW_COERCION_OF_SCALARS);
}
// @Bean регистрирует фильтр в контейнере Spring.
// Фильтр добавляет общий идентификатор каждому HTTP-ответу.
@Bean OncePerRequestFilter requestId() {
return new OncePerRequestFilter() {
// Метод фильтра вызывается для каждого HTTP-запроса.
protected void doFilterInternal(HttpServletRequest r, HttpServletResponse s, FilterChain c)
throws ServletException, IOException {
// Создаём уникальный идентификатор текущего запроса.
String id=UUID.randomUUID().toString();
// Добавляем идентификатор в HTTP-ответ.
s.setHeader("X-Request-Id", id);
// Добавляем стабильный идентификатор экземпляра API.
s.setHeader("X-Instance-Id", INSTANCE_ID);
// Сохраняем тот же идентификатор для обработчика ошибок.
r.setAttribute("requestId", id);
long started = System.nanoTime();
try {
// Учебный отказ для эксперимента SLO (только FAULT_INJECTION=1): заголовок X-Fault-Inject: http-500
// даёт 500 до обработчика, без побочных эффектов, так нагрузка задаёт точную долю ошибок.
if (Jobs.FAULTS && "http-500".equals(r.getHeader("X-Fault-Inject"))) {
s.setStatus(500);
s.setContentType("application/json");
s.getWriter().write("{\"error\":{\"code\":\"internal_error\",\"message\":\"injected fault\",\"request_id\":\"" + id + "\"}}");
return;
}
// Передаём запрос дальше по цепочке Spring.
c.doFilter(r, s);
} finally {
// Структурный лог запроса внутри server span: агент OTel добавит trace_id/span_id.
// Только шаблон маршрута, без raw URL, тела и заголовков; health-пробы не логируем.
if (!r.getRequestURI().startsWith("/health")) {
Object route = r.getAttribute(org.springframework.web.servlet.HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
long ms = (System.nanoTime() - started) / 1_000_000;
LoggerFactory.getLogger("http").atInfo().addKeyValue("event", "http.request")
.addKeyValue("http.request.method", r.getMethod())
.addKeyValue("http.route", route == null ? "unmatched" : route.toString())
.addKeyValue("http.response.status_code", s.getStatus())
.addKeyValue("request_id", id)
.log("{} {} -> {} in {} ms", r.getMethod(), route, s.getStatus(), ms);
}
}
}
};
}
// Эти record-классы описывают JSON-модели ответов и запросов.
// Публичная модель пользователя без пароля.
record User(UUID id, String username, String display_name, Instant created_at) {}
// Модель чата со списком участников.
record Chat(UUID id, String title, List<UUID> member_ids, Instant created_at) {}
// Модель сообщения с автором, временем создания и вложениями (в порядке из запроса).
record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at, List<UUID> attachment_ids) {}
// Универсальная модель страницы списка.
record Page<T>(List<T> items, String next_cursor) {}
// Ответ успешного входа с Bearer-токеном.
record Session(String token, String token_type, Instant expires_at, User user) {}
// Тело запроса регистрации.
record UserIn(JsonNode username, JsonNode display_name, JsonNode password) {}
// Тело запроса создания чата.
record ChatIn(JsonNode title, List<UUID> member_ids) {}
// Тело запроса отправки сообщения; attachment_ids необязателен (по умолчанию []).
record MessageIn(JsonNode text, JsonNode attachment_ids) {}
// Поля внутренней ошибки API.
record Error(String code, String message, String request_id) {}
// Обёртка, требуемая форматом JSON ошибки.
record ErrorBody(Error error) {}
// Исключение хранит HTTP-статус и безопасный код ошибки.
static class ApiException extends RuntimeException {
// HTTP-статус, который будет отправлен клиенту.
final HttpStatus status;
// Короткий код ошибки для программы-клиента.
final String code;
ApiException(HttpStatus s, String c, String m) {
// Сохраняем текст сообщения в стандартном RuntimeException.
super(m);
status=s;
code=c;
}
}
// @RestController объединяет @Controller и @ResponseBody.
// Методы этого класса принимают HTTP-запросы и возвращают JSON.
@RestController
static class Api {
// JdbcTemplate работает с PostgreSQL, RedisTemplate — с Redis-сессиями.
// JdbcTemplate отправляет SQL-запросы в PostgreSQL.
final JdbcTemplate db;
// StringRedisTemplate работает со строковыми ключами Redis.
final StringRedisTemplate redis;
// BCryptPasswordEncoder проверяет и хеширует пароли.
final BCryptPasswordEncoder encoder;
// Генератор создаёт 32 случайных байта для каждой сессии.
final SecureRandom random = new SecureRandom();
// TTL можно уменьшить через переменную окружения для проверки expiry.
final long ttl = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
Api(JdbcTemplate d, StringRedisTemplate r, BCryptPasswordEncoder e) {
// Сохраняем зависимости, созданные Spring Boot.
db=d;
redis=r;
encoder=e;
}
// Метод проверяет доступность PostgreSQL тестовым запросом.
void dbOk() {
try {
// Простой запрос проверяет соединение с PostgreSQL.
db.queryForObject("select 1", Integer.class);
} catch (Exception e) {
// Внутреннюю ошибку базы не показываем клиенту.
throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","database is unavailable");
}
}
// Метод проверяет Bearer-токен и возвращает UUID пользователя.
UUID auth(HttpServletRequest req) {
// Читаем заголовок авторизации из HTTP-запроса.
String h=req.getHeader("Authorization");
// Защищённые методы принимают только Bearer-схему.
if (h==null || !h.startsWith("Bearer ")) throw unauth();
// В Redis хранится связь хеша токена с UUID пользователя.
try { String v=redis.opsForValue().get(sessionKey(h.substring(7))); if(v==null) throw unauth(); return UUID.fromString(v); }
catch (ApiException e) { throw e; } catch (Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
}
ApiException unauth() { return new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","valid Bearer session required"); }
// Загружаем пользователя по UUID из PostgreSQL.
// Метод ищет пользователя в PostgreSQL по его UUID.
User user(UUID id) {
return db.query("select id,username,display_name,created_at from users where id=?", rs -> rs.next()
? new User(rs.getObject(1,UUID.class),rs.getString(2),rs.getString(3),rs.getTimestamp(4).toInstant()) : null, id);
}
// Метод проверяет, состоит ли пользователь в выбранном чате.
boolean member(UUID chat, UUID user) {
// Пользователь должен состоять в чате, иначе ресурс для него скрыт.
return Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from chat_members where chat_id=? and user_id=?)",Boolean.class,chat,user));
}
// Загружает один чат и его участников напрямую по идентификатору.
Chat chatById(UUID id) {
return db.query("select id,title,created_at from chats where id=?",rs -> rs.next()
? new Chat(rs.getObject(1,UUID.class),rs.getString(2),
db.query("select user_id from chat_members where chat_id=?",(z,k)->z.getObject(1,UUID.class),id),
rs.getTimestamp(3).toInstant()) : null,id);
}
// Считает символы как Unicode code points, а не как UTF-16 char.
int codePointLength(String value) {
return value.codePointCount(0,value.length());
}
// Возвращает значение только если JSON-поле действительно является строкой.
String string(JsonNode value) { return value!=null && value.isTextual()?value.textValue():null; }
// PostgreSQL не хранит нулевой байт, поэтому заменяем его безопасным символом.
String databaseText(String value) { return value==null?null:value.replace('\0','\uFFFD'); }
// Проверяет обязательную непустую строку и её максимальную длину.
boolean text(String value, int max) { return value!=null && !value.isBlank() && codePointLength(value)<=max; }
// Ключ сессии в Redis — SHA-256 токена: агент OTel пишет команду Redis (GET session:<ключ>) в span,
// поэтому сырой токен не должен быть частью ключа (и не лежит открыто в дампе Redis).
String sessionKey(String token) {
try { return "session:"+HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(token.getBytes(StandardCharsets.UTF_8))); }
catch (Exception e) { throw new IllegalStateException("session hashing is unavailable",e); }
}
// Предварительный SHA-256 сохраняет весь пароль перед ограниченным BCrypt.
String passwordValue(String value) {
try { return Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8))); }
catch (Exception e) { throw new IllegalStateException("password hashing is unavailable",e); }
}
// Готовность проверяет не только Java-процесс, но и его зависимости.
// @GetMapping связывает GET-запрос с Java-методом.
@GetMapping({"/health/live","/health/ready"})
// Для ready дополнительно проверяем PostgreSQL и Redis.
// Метод возвращает JSON со статусом приложения.
Map<String,String> health(HttpServletRequest r) { if (r.getRequestURI().endsWith("ready")) { dbOk(); try { redis.hasKey("health"); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); } } return Map.of("status","ok"); }
// @PostMapping связывает POST-запрос с методом регистрации.
@PostMapping("/api/v1/users")
// @RequestBody преобразует JSON-тело запроса в объект UserIn.
ResponseEntity<User> register(@RequestBody UserIn in) {
String username=in==null?null:string(in.username());
String displayName=in==null?null:string(in.display_name());
String password=in==null?null:string(in.password());
// До запроса в базу проверяем формат обязательных полей.
if(username==null || !username.matches("[a-z0-9_]{3,32}") || !text(displayName,100) || password==null || password.isBlank() || codePointLength(password)<12 || codePointLength(password)>128) bad();
displayName=databaseText(displayName);
// Создаём UUID пользователя и фиксируем время регистрации.
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Значения передаются параметрами, а не склеиваются со строкой SQL.
try { db.update("insert into users values(?,?,?,?,?)",id,username,displayName,encoder.encode(passwordValue(password)),java.sql.Timestamp.from(now)); }
// Уникальное ограничение username превращаем в понятный ответ 409.
catch(DuplicateKeyException e) { throw new ApiException(HttpStatus.CONFLICT,"conflict","username is already used"); }
// Возвращаем созданного пользователя без пароля.
return ResponseEntity.status(201).body(new User(id,username,displayName,now));
}
// POST-метод входа проверяет Basic-логин и создаёт Bearer-сессию.
@PostMapping("/api/v1/auth/sessions")
// HttpServletRequest позволяет прочитать заголовок Authorization.
ResponseEntity<Session> login(HttpServletRequest req) {
// Читаем Basic-заголовок, который используется только при входе.
String h=req.getHeader("Authorization");
if(h==null || !h.startsWith("Basic ")) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","Basic authentication required"); }
// Basic используется только для входа, после него клиент получает Bearer-токен.
String[] p; try { p=new String(Base64.getDecoder().decode(h.substring(6)),StandardCharsets.UTF_8).split(":",2); } catch(Exception e) { p=new String[0]; }
// Получаем BCrypt-хеш пользователя из PostgreSQL.
String hash=p.length==2 ? db.query("select password_hash from users where username=?",rs -> rs.next()?rs.getString(1):null,p[0]) : null;
// Сравниваем введённый пароль с сохранённым хешем.
if(p.length!=2 || hash==null || codePointLength(p[1])<12 || codePointLength(p[1])>128 || !encoder.matches(passwordValue(p[1]),hash)) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","invalid credentials"); }
// После успешной проверки загружаем полную модель пользователя.
User u=user(db.queryForObject("select id from users where username=?",UUID.class,p[0]));
// Генерируем непрозрачный случайный токен сессии.
byte[] secret=new byte[32]; random.nextBytes(secret);
String token=Base64.getUrlEncoder().withoutPadding().encodeToString(secret);
// Вычисляем момент, когда сессия перестанет действовать.
Instant exp=Instant.now().plusSeconds(ttl);
// Сессия автоматически удалится из Redis после окончания TTL.
try { redis.opsForValue().set(sessionKey(token),u.id().toString(),Duration.ofSeconds(ttl)); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
return ResponseEntity.status(201).body(new Session(token,"Bearer",exp,u));
}
// @DeleteMapping связывает DELETE-запрос с удалением сессии.
// Logout сразу удаляет текущий токен из Redis.
@DeleteMapping("/api/v1/auth/sessions/current") ResponseEntity<Void> logout(HttpServletRequest r) { auth(r); redis.delete(sessionKey(r.getHeader("Authorization").substring(7))); return ResponseEntity.noContent().build(); }
// GET-запрос возвращает данные текущего авторизованного пользователя.
@GetMapping("/api/v1/users/me") User me(HttpServletRequest r) { return user(auth(r)); }
// @Transactional объединяет несколько SQL-команд в одну транзакцию.
// Если одна команда завершится ошибкой, изменения откатываются.
// Вставка чата и всех его участников выполняется как одна транзакция.
@Transactional
// POST-запрос создаёт новый чат.
@PostMapping("/api/v1/chats") ResponseEntity<Chat> createChat(@RequestBody ChatIn in,HttpServletRequest r) {
// Владелец чата определяется по Bearer-сессии.
String title=in==null?null:string(in.title());
UUID owner=auth(r); if(!text(title,100)||in.member_ids()==null||in.member_ids().isEmpty()||in.member_ids().size()>100||new HashSet<>(in.member_ids()).size()!=in.member_ids().size()||!in.member_ids().contains(owner)) bad();
// Проверяем существование каждого участника.
for(UUID id:in.member_ids()) if(user(id)==null) bad();
// ID и время создаются сервером. PostgreSQL хранит микросекунды, поэтому ответ POST совпадает с GET.
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Записываем чат и участников в одной транзакции.
title=databaseText(title);
db.update("insert into chats values(?,?,?)",id,title,java.sql.Timestamp.from(now)); for(UUID m:in.member_ids()) db.update("insert into chat_members values(?,?)",id,m);
// Возвращаем созданную модель чата.
return ResponseEntity.status(201).body(new Chat(id,title,in.member_ids(),now));
}
// GET-запрос получает список чатов текущего пользователя.
@GetMapping("/api/v1/chats")
Page<Chat> chats(HttpServletRequest r) {
// Определяем пользователя, для которого строится список.
UUID u=auth(r);
String cursor=r.getParameter("cursor");
int limit=parseLimit(r.getParameter("limit"));
// Запрашиваем только чаты, где пользователь является участником.
String sql="select c.id,c.title,c.created_at from chats c join chat_members m on m.chat_id=c.id where m.user_id=? ";
List<Object> args=new ArrayList<>(List.of(u));
if(cursor!=null) {
try {
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=2) bad();
sql+="and (c.created_at,c.id)>(?,?) ";
args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[0]).toInstant()));
args.add(UUID.fromString(p[1]));
} catch(Exception e) { if(e instanceof ApiException a) throw a; bad(); }
}
sql+="order by c.created_at,c.id limit ?";
args.add(limit+1);
List<Chat> x=db.query(sql,(rs,n)->new Chat(rs.getObject(1,UUID.class),rs.getString(2),db.query("select user_id from chat_members where chat_id=?", (z,k)->z.getObject(1,UUID.class),rs.getObject(1)),rs.getTimestamp(3).toInstant()),args.toArray());
String next=x.size()>limit?Base64.getUrlEncoder().withoutPadding().encodeToString((x.get(limit-1).created_at()+"|"+x.get(limit-1).id()).getBytes(StandardCharsets.UTF_8)):null;
return new Page<>(x.subList(0,Math.min(limit,x.size())),next);
}
// {id} является переменной частью URL.
@GetMapping("/api/v1/chats/{id}")
// @PathVariable получает id из адреса запроса.
Chat chat(@PathVariable UUID id,HttpServletRequest r) {
// Сначала проверяем токен и членство в чате.
UUID u=auth(r); if(!member(id,u)) throw notFound();
// Загружаем чат напрямую, поэтому поздние записи не зависят от первой страницы списка.
Chat result=chatById(id);
if(result==null) throw notFound();
return result;
}
// POST-запрос добавляет сообщение в выбранный чат.
// @PathVariable получает id чата, а @RequestBody — текст из JSON.
@Transactional
@PostMapping("/api/v1/chats/{id}/messages") ResponseEntity<Message> message(@PathVariable UUID id,@RequestBody MessageIn in,HttpServletRequest r) {
// Автор сообщения берётся из сессии, а не из тела запроса.
String messageText=databaseText(in==null?null:string(in.text()));
UUID u=auth(r); if(!member(id,u)) throw notFound();
List<UUID> attachments=attachmentIds(in==null?null:in.attachment_ids());
// Пустой текст допустим только с вложением; непустой не может состоять из одних пробелов.
if(messageText==null || codePointLength(messageText)>4000 || (messageText.isEmpty()?attachments.isEmpty():messageText.isBlank())) bad();
// Проверяем обязательный Idempotency-Key.
String key=r.getHeader("Idempotency-Key");
if(key==null || !key.matches("[A-Za-z0-9._:-]{1,128}")) throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","valid Idempotency-Key required");
// Хеш тела для повторов с тем же ключом: отсутствующий attachment_ids и [] дают одно значение.
String bodyHash;
try { bodyHash=Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest((messageText+"\0"+attachments).getBytes(StandardCharsets.UTF_8))); }
catch(Exception e) { throw new IllegalStateException("hash unavailable",e); }
// Сервер создаёт ID и время сообщения.
UUID mid=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Сначала занимаем ключ. При одновременном повторе через другую реплику PostgreSQL ждёт
// её транзакцию, а ON CONFLICT DO NOTHING не обрывает нашу транзакцию ошибкой (иначе был бы 503).
if(db.update("insert into idempotency_keys values(?,?,?,?,?,?) on conflict do nothing",key,u,id,bodyHash,mid,java.sql.Timestamp.from(now))==0) {
// Ключ уже занят: тот же body — возвращаем созданное сообщение, другой body — 409.
UUID existingId=db.query("select message_id,request_hash from idempotency_keys where user_id=? and chat_id=? and idempotency_key=?",rs -> {
if(rs.next()) {
if(!bodyHash.equals(rs.getString(2))) throw new ApiException(HttpStatus.CONFLICT,"conflict","different body with same idempotency key");
return rs.getObject(1,UUID.class);
}
return null;
},u,id,key);
Message existing=db.queryForObject(MESSAGE_SELECT+"where m.id=?",this::messageRow,existingId);
return ResponseEntity.status(201).body(existing);
}
// Вложения этого чата: queued/processing/ready можно, failed — 409; чужое или неизвестное — 404.
// Проверка после ключа: повтор успешного запроса возвращает сохранённое сообщение; ошибка откатывает ключ.
if(!attachments.isEmpty()) {
List<String> states=db.queryForList("select state from attachments where chat_id=? and id=any(?) and state in ('queued','processing','ready','failed')",String.class,id,attachments.toArray(new UUID[0]));
if(states.size()!=attachments.size()) throw notFound();
if(states.contains("failed")) throw new ApiException(HttpStatus.CONFLICT,"conflict","failed attachment cannot be attached");
}
// Сообщение и его вложения пишутся в той же транзакции, что и ключ: появится всё или ничего.
db.update("insert into messages values(?,?,?,?,?)",mid,id,u,messageText,java.sql.Timestamp.from(now));
for(int i=0;i<attachments.size();i++) db.update("insert into message_attachments values(?,?,?)",mid,attachments.get(i),i);
return ResponseEntity.status(201).body(new Message(mid,id,u,messageText,now,attachments));
}
// Колонки сообщения; attachment_ids собираются из message_attachments в порядке отправки.
static final String MESSAGE_SELECT="select m.id,m.chat_id,m.sender_id,m.text,m.created_at,"
+"coalesce((select array_agg(x.attachment_id order by x.position) from message_attachments x where x.message_id=m.id),'{}') from messages m ";
Message messageRow(java.sql.ResultSet rs,int n) throws java.sql.SQLException {
return new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant(),List.of((UUID[])rs.getArray(6).getArray()));
}
// attachment_ids: отсутствует — []; иначе массив 0–10 уникальных UUID в каноническом виде.
List<UUID> attachmentIds(JsonNode value) {
if(value==null) return List.of();
if(!value.isArray() || value.size()>10) bad();
List<UUID> ids=new ArrayList<>();
for(JsonNode x:value) {
String s=x.isTextual()?x.textValue():"";
try { UUID id=UUID.fromString(s); if(!id.toString().equalsIgnoreCase(s)) bad(); ids.add(id); } catch(IllegalArgumentException e) { bad(); }
}
if(new HashSet<>(ids).size()!=ids.size()) bad();
return ids;
}
// GET-запрос возвращает историю сообщений с cursor-пагинацией.
// @RequestParam получает limit и cursor из параметров URL.
@GetMapping("/api/v1/chats/{id}/messages") Page<Message> messages(@PathVariable UUID id,@RequestParam(required=false) String limit,@RequestParam(required=false) String cursor,HttpServletRequest r) {
// Историю может читать только участник чата.
UUID u=auth(r); if(!member(id,u)) throw notFound(); int pageLimit=parseLimit(limit);
// Начинаем параметризованный запрос истории.
String sql=MESSAGE_SELECT+"where m.chat_id=? ";
// Список параметров передаётся в JdbcTemplate отдельно от SQL.
List<Object> args=new ArrayList<>(List.of(id));
if(cursor!=null) {
try {
// Cursor хранит время и ID последнего сообщения предыдущей страницы.
// Декодируем cursor из Base64 в обычную строку.
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=3 || !id.equals(UUID.fromString(p[0]))) bad();
// Добавляем условие keyset-пагинации после последнего сообщения.
sql+="and (m.created_at,m.id)>(?,?) "; args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[1]).toInstant())); args.add(UUID.fromString(p[2]));
} catch(Exception e) { bad(); }
}
// Сортируем историю и берём одну запись сверх лимита для следующего cursor.
sql+="order by m.created_at,m.id limit ?"; args.add(pageLimit+1);
// Выполняем запрос и превращаем строки базы в объекты Message.
List<Message> x=db.query(sql,this::messageRow,args.toArray());
// Если запись сверх лимита есть, кодируем её позицию как следующий cursor.
String next=x.size()>pageLimit?Base64.getUrlEncoder().withoutPadding().encodeToString((id+"|"+x.get(pageLimit-1).created_at()+"|"+x.get(pageLimit-1).id()).getBytes(StandardCharsets.UTF_8)):null; return new Page<>(x.subList(0,Math.min(pageLimit,x.size())),next);
}
// Преобразует limit списка чатов в число и проверяет диапазон.
int parseLimit(String value) { try { int limit=value==null?50:Integer.parseInt(value); if(limit<1||limit>100) bad(); return limit; } catch(NumberFormatException e) { bad(); return 0; } }
// Формируем ошибку, не раскрывая наличие чужого объекта.
ApiException notFound(){return new ApiException(HttpStatus.NOT_FOUND,"not_found","object not found");}
// Формируем общую ошибку некорректного запроса.
void bad(){throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","invalid request");}
}
// @RestControllerAdvice применяет обработчики ко всем REST-контроллерам.
// Благодаря этому ошибки возвращаются в одном формате JSON.
@RestControllerAdvice static class Errors {
// Все ошибки API приводятся к одному JSON-формату.
// @ExceptionHandler связывает тип исключения с методом обработки.
// Здесь обрабатываются специально созданные ошибки API.
@ExceptionHandler(ApiException.class) ResponseEntity<ErrorBody> api(ApiException e,HttpServletRequest r){
// Создаём заголовки ответа с ошибкой.
HttpHeaders h=new HttpHeaders();
if(e.status==HttpStatus.UNAUTHORIZED) h.set("WWW-Authenticate",r.getRequestURI().equals("/api/v1/auth/sessions")?"Basic realm=\"messenger\", charset=\"UTF-8\"":"Bearer realm=\"messenger\"");
// Возвращаем статус, заголовки и единое тело ошибки.
return ResponseEntity.status(e.status).headers(h).body(new ErrorBody(new Error(e.code,e.getMessage(),id(r))));
}
// Неожиданные исключения превращаем в безопасный ответ 500.
// Этот обработчик является запасным для неожиданных исключений.
@ExceptionHandler(Exception.class) ResponseEntity<ErrorBody> other(Exception e,HttpServletRequest r){
// Ошибки самого Spring MVC (неизвестный путь, метод, Content-Type) сохраняют свой 4xx, а не становятся 500.
if(e instanceof org.springframework.web.ErrorResponse x && x.getStatusCode().is4xxClientError()) {
int s=x.getStatusCode().value();
Error err=s==404?new Error("not_found","object not found",id(r)):s==415?new Error("unsupported_media_type","unsupported media type",id(r)):new Error("invalid_request","invalid request",id(r));
return ResponseEntity.status(s).headers(x.getHeaders()).body(new ErrorBody(err));
}
LoggerFactory.getLogger(Errors.class).error("request failed",e); return ResponseEntity.status(500).body(new ErrorBody(new Error("internal_error","internal server error",id(r)))); }
// Неправильный JSON считается ошибкой входных данных клиента.
// Этот обработчик ловит неправильный или повреждённый JSON.
@ExceptionHandler(HttpMessageNotReadableException.class) ResponseEntity<ErrorBody> malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка преобразования UUID или числового параметра означает неверный запрос.
@ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity<ErrorBody> mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка PostgreSQL возвращается как временная недоступность зависимости.
@ExceptionHandler(DataAccessException.class) ResponseEntity<ErrorBody> database(DataAccessException e,HttpServletRequest r){ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(new ErrorBody(new Error("unavailable","database is unavailable",id(r)))); }
// Получаем ID запроса, который добавил фильтр.
String id(HttpServletRequest r){ return String.valueOf(r.getAttribute("requestId")); }
}
}
@@ -0,0 +1,297 @@
package ru.mtusi.messenger;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.InputStream;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
// Сверка PostgreSQL и S3 (трек 2). Оба списка обходятся отсортированными по ключу и сливаются за O(n)
// с постоянной памятью: страница S3 по 1000 ключей и страница строк БД по 1000.
//
// Правила безопасности:
// - ничего моложе grace period (по LastModified объекта / updated_at строки) не трогаем:
// загрузка в процессе пишет строку до объекта и объект до ready;
// - ready-строки не удаляются никогда, а при отсутствии объекта (подтверждённом HEAD) помечаются lost;
// - строка, на которую ссылается сообщение, защищена FK message_attachments;
// - объект без строки удаляется только после повторной проверки по ключу в БД;
// - одновременно работает одна сверка (pg advisory lock), повторный запуск ничего не меняет;
// - queued/processing/failed — зона pipeline (lab5): оригинал публикует worker, сверка их не трогает.
@Component
class Reconciler {
static final long LOCK_ID = 4_040_404L;
static final int PAGE = 1000;
static final Logger log = LoggerFactory.getLogger(Reconciler.class);
final JdbcTemplate db;
final Storage storage;
final boolean enabled;
final long graceSeconds;
Reconciler(JdbcTemplate db, Storage storage, @Value("${reconcile.enabled:true}") boolean enabled, @Value("${reconcile.grace-seconds:3600}") long graceSeconds) {
this.db = db;
this.storage = storage;
this.enabled = enabled;
this.graceSeconds = graceSeconds;
}
// Автоматическая компенсация в API-репликах: раз в interval, в apply-режиме, с grace по умолчанию 1 час.
@Scheduled(initialDelayString = "${reconcile.initial-delay:PT1M}", fixedDelayString = "${reconcile.interval:PT15M}")
void scheduled() {
if (!enabled) return;
try {
Map<String, Object> report = run(true, Duration.ofSeconds(graceSeconds), false);
if (!Map.of().equals(report.get("actions"))) log.info("reconcile: {}", report);
} catch (RuntimeException e) {
log.warn("reconcile failed: {}", e.toString());
}
}
// CLI: reconcile [--apply] [--grace-seconds=N] [--verify-checksums]; по умолчанию dry-run.
int cli(String[] args) throws Exception {
boolean apply = false, verify = false;
long grace = graceSeconds;
for (String a : args) {
if (a.equals("--apply")) apply = true;
else if (a.equals("--dry-run")) apply = false;
else if (a.equals("--verify-checksums")) verify = true;
else if (a.startsWith("--grace-seconds=")) grace = Long.parseLong(a.substring(16));
else { System.err.println("unknown argument: " + a); return 2; }
}
Map<String, Object> report = run(apply, Duration.ofSeconds(grace), verify);
System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(report));
return report.containsKey("skipped") ? 3 : 0;
}
Map<String, Object> run(boolean apply, Duration grace, boolean verify) {
return db.execute((ConnectionCallback<Map<String, Object>>) c -> {
try (PreparedStatement st = c.prepareStatement("select pg_try_advisory_lock(?)")) {
st.setLong(1, LOCK_ID);
try (ResultSet rs = st.executeQuery()) {
rs.next();
if (!rs.getBoolean(1)) return Map.of("skipped", "another reconcile is running");
}
}
try {
return new Pass(apply, grace, verify).scan();
} finally {
try (PreparedStatement st = c.prepareStatement("select pg_advisory_unlock(?)")) {
st.setLong(1, LOCK_ID);
st.execute();
}
}
});
}
record Row(UUID id, String key, String state, long size, String sha256, Instant updated, boolean used) {}
// Один проход сверки со счётчиками для отчёта и оценки стоимости.
final class Pass {
final boolean apply, verify;
final Duration grace;
final Instant cutoff;
final Map<String, Long> findings = new LinkedHashMap<>(), actions = new LinkedHashMap<>(), cost = new LinkedHashMap<>();
final List<Map<String, Object>> details = new ArrayList<>();
Pass(boolean apply, Duration grace, boolean verify) {
this.apply = apply;
this.grace = grace;
this.verify = verify;
cutoff = Instant.now().minus(grace);
}
Map<String, Object> scan() {
long started = System.nanoTime();
Iterator<S3Object> objects = objects();
Iterator<Row> rows = rows();
S3Object o = next(objects);
Row r = next(rows);
while (o != null || r != null) {
int cmp = o == null ? 1 : r == null ? -1 : o.key().compareTo(r.key());
if (cmp < 0) { objectWithoutRow(o); o = next(objects); }
else if (cmp > 0) { rowWithoutObject(r); r = next(rows); }
else { both(o, r); o = next(objects); r = next(rows); }
}
Map<String, Object> report = new LinkedHashMap<>();
report.put("mode", apply ? "apply" : "dry-run");
report.put("grace_seconds", grace.toSeconds());
report.put("verify_checksums", verify);
report.put("duration_ms", (System.nanoTime() - started) / 1_000_000);
report.put("cost", cost);
report.put("findings", findings);
report.put("actions", actions);
report.put("details", details.size() > 50 ? details.subList(0, 50) : details);
return report;
}
void objectWithoutRow(S3Object o) {
if (o.lastModified().isAfter(cutoff)) { count(findings, "orphan_object_fresh_kept"); return; }
count(findings, "orphan_object");
detail("orphan_object", o.key(), null);
if (!apply) return;
// Повторная проверка: строка могла появиться после чтения страницы БД.
count(cost, "db_queries");
if (Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from attachments where object_key=?)", Boolean.class, o.key()))) return;
count(cost, "s3_delete_requests");
storage.delete(o.key());
count(actions, "objects_deleted");
}
void rowWithoutObject(Row r) {
switch (r.state()) {
case "uploading" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "upload_in_progress_kept"); return; }
count(findings, "stale_upload");
detail("stale_upload", r.key(), r.id());
if (apply && deleteStaleRow(r)) count(actions, "rows_deleted");
}
case "ready" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "fresh_row_kept"); return; }
// Листинг не считаем доказательством: отсутствие подтверждает HEAD (404).
count(cost, "s3_head_requests");
if (storage.size(r.key()) != null) return;
count(findings, r.used() ? "missing_object_used" : "missing_object");
detail("missing_object", r.key(), r.id());
if (apply && markLost(r)) count(actions, "marked_lost");
}
case "queued", "processing", "failed" -> count(findings, "pipeline_not_published");
default -> count(findings, "lost_known");
}
}
void both(S3Object o, Row r) {
switch (r.state()) {
case "queued", "processing", "failed" -> count(findings, "pipeline_in_progress");
case "uploading" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "upload_in_progress_kept"); return; }
// PUT прошёл, ready не записан: клиент получил ошибку и id не знает — объект и строку удаляем.
count(findings, "stale_upload_with_object");
detail("stale_upload_with_object", r.key(), r.id());
if (!apply || !deleteStaleRow(r)) return;
count(cost, "s3_delete_requests");
storage.delete(r.key());
count(actions, "rows_deleted");
count(actions, "objects_deleted");
}
case "ready" -> {
if (r.updated().isAfter(cutoff)) return;
String problem = o.size() != r.size() ? "size_mismatch" : verify && !checksumMatches(r) ? "checksum_mismatch" : null;
if (problem == null) return;
count(findings, problem);
detail(problem, r.key(), r.id());
if (apply && markLost(r)) count(actions, "marked_lost");
}
default -> {
// lost, но объект снова на месте: вернуть в ready можно только после сверки SHA-256,
// иначе файл, помеченный за неверную контрольную сумму, «воскрес» бы по одному размеру.
if (o.size() != r.size()) { count(findings, "lost_known"); return; }
if (!verify) { count(findings, "lost_object_back_unverified"); return; }
if (!checksumMatches(r)) { count(findings, "lost_known"); return; }
count(findings, "lost_object_back");
detail("lost_object_back", r.key(), r.id());
if (!apply) return;
count(cost, "db_queries");
if (db.update("update attachments set state='ready', updated_at=now() where id=? and state='lost'", r.id()) == 1) count(actions, "restored");
}
}
}
boolean deleteStaleRow(Row r) {
count(cost, "db_queries");
return db.update("delete from attachments a where id=? and state='uploading' and updated_at<? and not exists(select 1 from message_attachments x where x.attachment_id=a.id)",
r.id(), Timestamp.from(cutoff)) == 1;
}
boolean markLost(Row r) {
count(cost, "db_queries");
return db.update("update attachments set state='lost', updated_at=now() where id=? and state='ready'", r.id()) == 1;
}
boolean checksumMatches(Row r) {
count(cost, "s3_get_requests");
MessageDigest sha = Attachments.sha256();
try (InputStream in = new DigestInputStream(storage.get(r.key()), sha)) {
cost.merge("bytes_read", in.transferTo(java.io.OutputStream.nullOutputStream()), Long::sum);
} catch (java.io.IOException e) {
throw new IllegalStateException(e);
}
return java.util.HexFormat.of().formatHex(sha.digest()).equals(r.sha256());
}
// Ленивый обход листинга S3 постранично.
Iterator<S3Object> objects() {
Iterator<ListObjectsV2Response> pages = storage.list().iterator();
return new Iterator<>() {
Iterator<S3Object> page = List.<S3Object>of().iterator();
public boolean hasNext() {
while (!page.hasNext() && pages.hasNext()) {
count(cost, "s3_list_requests");
page = pages.next().contents().iterator();
}
return page.hasNext();
}
public S3Object next() {
S3Object o = page.next();
count(cost, "s3_objects");
return o;
}
};
}
// Keyset-пагинация строк по object_key (COLLATE "C" — тот же порядок, что у S3).
Iterator<Row> rows() {
return new Iterator<>() {
Iterator<Row> page = List.<Row>of().iterator();
String after = "";
boolean done;
public boolean hasNext() {
if (!page.hasNext() && !done) {
count(cost, "db_queries");
List<Row> rows = db.query("select id,object_key,state,size_bytes,sha256,updated_at,exists(select 1 from message_attachments x where x.attachment_id=a.id)"
+ " from attachments a where object_key>? order by object_key limit ?", (rs, n) -> new Row(rs.getObject(1, UUID.class), rs.getString(2),
rs.getString(3), rs.getLong(4), rs.getString(5), rs.getTimestamp(6).toInstant(), rs.getBoolean(7)), after, PAGE);
done = rows.size() < PAGE;
if (!rows.isEmpty()) after = rows.get(rows.size() - 1).key();
page = rows.iterator();
}
return page.hasNext();
}
public Row next() {
count(cost, "db_rows");
return page.next();
}
};
}
<T> T next(Iterator<T> it) { return it.hasNext() ? it.next() : null; }
void count(Map<String, Long> map, String name) { map.merge(name, 1L, Long::sum); }
void detail(String kind, String key, UUID id) {
Map<String, Object> d = new LinkedHashMap<>();
d.put("kind", kind);
d.put("key", key);
if (id != null) d.put("attachment_id", id);
details.add(d);
}
}
}
@@ -0,0 +1,90 @@
package ru.mtusi.messenger;
import java.net.URI;
import java.nio.file.Path;
import java.time.Duration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
import software.amazon.awssdk.services.s3.model.S3Object;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;
// Байты вложений в приватном S3-bucket. Ключи API имеют права только на этот bucket.
@Component
class Storage {
// Опубликованные оригиналы (их обходит сверка), устойчивый staging приёма и варианты worker.
static final String ORIGINALS = "originals/", STAGING = "staging/", VARIANTS = "variants/";
final S3Client s3;
final String bucket;
Storage(@Value("${s3.endpoint}") String endpoint, @Value("${s3.region:us-east-1}") String region, @Value("${s3.bucket}") String bucket,
@Value("${s3.access-key}") String accessKey, @Value("${s3.secret-key}") String secretKey) {
this.bucket = bucket;
// Короткий connect timeout: недоступный S3 быстро даёт 503, а не держит поток API.
s3 = S3Client.builder()
.endpointOverride(URI.create(endpoint))
.region(Region.of(region))
.forcePathStyle(true)
.credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey.trim(), secretKey.trim())))
.httpClientBuilder(ApacheHttpClient.builder().maxConnections(64).connectionTimeout(Duration.ofSeconds(2)).socketTimeout(Duration.ofSeconds(30)))
.overrideConfiguration(c -> c.apiCallTimeout(Duration.ofSeconds(60)).apiCallAttemptTimeout(Duration.ofSeconds(30)))
.build();
}
// Файл читается потоком с диска: размер известен заранее, в RAM целиком не попадает.
void put(String key, Path file, String contentType) {
s3.putObject(b -> b.bucket(bucket).key(key).contentType(contentType), RequestBody.fromFile(file));
}
ResponseInputStream<GetObjectResponse> get(String key) {
return s3.getObject(b -> b.bucket(bucket).key(key));
}
// Скачивание во временный файл worker (файла ещё не должно быть).
void download(String key, Path file) {
s3.getObject(b -> b.bucket(bucket).key(key), file);
}
// Серверное копирование staging → конечный префикс: байты не проходят через worker.
void copy(String from, String to) {
s3.copyObject(b -> b.sourceBucket(bucket).sourceKey(from).destinationBucket(bucket).destinationKey(to));
}
void delete(String key) {
s3.deleteObject(b -> b.bucket(bucket).key(key));
}
// null — объекта точно нет (404); иначе его размер. Прочие ошибки S3 пробрасываются.
Long size(String key) {
try {
return s3.headObject(b -> b.bucket(bucket).key(key)).contentLength();
} catch (NoSuchKeyException e) {
return null;
} catch (S3Exception e) {
if (e.statusCode() == 404) return null;
throw e;
}
}
// Ленивый постраничный листинг (по 1000 ключей) в побайтовом порядке ключей.
ListObjectsV2Iterable list() {
return list(ORIGINALS);
}
ListObjectsV2Iterable list(String prefix) {
return s3.listObjectsV2Paginator(b -> b.bucket(bucket).prefix(prefix));
}
static boolean isOriginal(S3Object o) {
return o.key().startsWith(ORIGINALS);
}
}
@@ -0,0 +1,313 @@
package ru.mtusi.messenger;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.ShutdownSignalException;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.DoubleHistogram;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.StatusCode;
import jakarta.annotation.PreDestroy;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HexFormat;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
import javax.imageio.ImageIO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.core.exception.SdkException;
// Worker — отдельный процесс (режим worker). Потребляет attachments.process с ручным ack:
// ack только после зафиксированного результата или осознанного no-op для дубля.
// Конкуренция ограничена: WORKER_CONCURRENCY каналов, у каждого prefetch 1.
@Component
@ConditionalOnProperty(name = "worker.enabled", havingValue = "true")
class Worker {
static final Logger log = LoggerFactory.getLogger(Worker.class);
static final int CONCURRENCY = Jobs.env("WORKER_CONCURRENCY", 2);
static final Path ALIVE = Path.of("/tmp/worker-alive");
// Свои метрики заданий (реализацию даёт OTel Java agent). Labels только низкой кардинальности:
// тип задания и исход; ID вложений/заданий в метрики не попадают.
static final Meter METER = GlobalOpenTelemetry.getMeter("ru.mtusi.messenger.worker");
static final AttributeKey<String> JOB_TYPE = AttributeKey.stringKey("job.type"), OUTCOME = AttributeKey.stringKey("outcome"),
QUEUE = AttributeKey.stringKey("queue");
// Границы под ожидаемые попытки (доли секунды … JOB_TIMEOUT_SECONDS=60), а не дефолтные 0/5/10/25… с.
static final List<Double> DURATION_BUCKETS = List.of(0.05, 0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0);
static final LongCounter PROCESSED = METER.counterBuilder("messenger.jobs.processed").setUnit("{job}")
.setDescription("Сообщения заданий по исходу: done, retry, failed, duplicate, fenced").build();
static final DoubleHistogram DURATION = METER.histogramBuilder("messenger.job.duration").setUnit("s")
.setDescription("Время попытки от захвата до фиксации исхода").setExplicitBucketBoundariesAdvice(DURATION_BUCKETS).build();
final Broker broker;
final Jobs jobs;
final Storage storage;
final Set<Jobs.Claim> inflight = ConcurrentHashMap.newKeySet();
final ExecutorService consumers = Executors.newFixedThreadPool(CONCURRENCY);
final ScheduledExecutorService timer = Executors.newScheduledThreadPool(3);
final Map<Channel, String> subscriptions = new LinkedHashMap<>();
Connection connection;
volatile boolean stopping;
Worker(Broker broker, Jobs jobs, Storage storage) {
this.broker = broker;
this.jobs = jobs;
this.storage = storage;
ImageIO.setUseCache(false);
int beat = Math.max(1, Jobs.LEASE_SECONDS / 3);
timer.scheduleWithFixedDelay(() -> quietly("broker supervisor", this::supervise), 0, 2, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("heartbeat", this::heartbeat), beat, beat, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("lease sweep", jobs::sweep), 2, 2, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("staging sweep", () -> jobs.sweepStaging(storage)), 10, 60, TimeUnit.SECONDS);
// Насыщение worker; метрики очереди — в Jobs, чтобы их отдавал и API, когда worker остановлен.
METER.gaugeBuilder("messenger.worker.busy").ofLongs().setUnit("{job}").setDescription("Попытки в работе").buildWithCallback(m -> m.record(inflight.size()));
METER.gaugeBuilder("messenger.worker.capacity").ofLongs().setUnit("{job}").setDescription("WORKER_CONCURRENCY").buildWithCallback(m -> m.record(CONCURRENCY));
}
static void record(String outcome, double seconds) {
Attributes a = Attributes.of(JOB_TYPE, Jobs.TYPE, OUTCOME, outcome);
PROCESSED.add(1, a);
if (seconds >= 0) DURATION.record(seconds, a);
}
// Исход попытки — на consumer span агента RabbitMQ (его родитель — span publish из headers AMQP):
// в trace upload видно, какая попытка ушла в retry/failed и какая дошла до done.
static void tag(int attempt, String outcome) {
Span span = Span.current().setAttribute("job.attempt", attempt).setAttribute("job.outcome", outcome);
if (outcome.equals("retry") || outcome.equals("failed")) span.setStatus(StatusCode.ERROR, outcome);
}
static void quietly(String what, Runnable task) {
try {
task.run();
} catch (RuntimeException e) {
log.warn("{} failed: {}", what, e.toString());
}
}
// (Пере)подключение к брокеру; файл ALIVE — healthcheck контейнера.
synchronized void supervise() {
if (stopping) return;
try {
if (connection == null || !connection.isOpen()) {
subscriptions.clear();
connection = broker.connect("worker-" + Jobs.ACTOR, consumers);
for (int i = 0; i < CONCURRENCY; i++) {
Channel ch = connection.createChannel();
ch.basicQos(1);
subscriptions.put(ch, ch.basicConsume(Broker.QUEUE, false, consumer(ch)));
}
log.info("consuming {} with concurrency {}", Broker.QUEUE, CONCURRENCY);
}
Files.writeString(ALIVE, Instant.now().toString());
} catch (Exception e) {
log.warn("broker unavailable: {}", e.toString());
if (connection != null) connection.abort();
connection = null;
}
}
DefaultConsumer consumer(Channel ch) {
return new DefaultConsumer(ch) {
@Override
public void handleDelivery(String tag, Envelope envelope, AMQP.BasicProperties props, byte[] body) {
deliver(ch, envelope.getDeliveryTag(), body);
}
};
}
void deliver(Channel ch, long tag, byte[] body) {
Jobs.Msg m;
try {
m = Jobs.parse(body);
} catch (IOException | RuntimeException e) {
log.warn("malformed job message rejected to DLQ: {}", e.toString());
settle(() -> ch.basicReject(tag, false));
return;
}
try {
process(m);
} catch (DataAccessException e) {
// Без БД нельзя ни захватить, ни зафиксировать: вернуть сообщение после паузы (delivery-limit → DLQ).
log.warn("database unavailable, requeue job {}: {}", m.job_id(), e.toString());
sleep(5000);
settle(() -> ch.basicNack(tag, false, true));
return;
}
settle(() -> ch.basicAck(tag, false));
}
interface Io {
void run() throws IOException;
}
// Канал закрыт (рестарт брокера) — неподтверждённое сообщение брокер доставит повторно.
static void settle(Io action) {
try {
action.run();
} catch (IOException | ShutdownSignalException e) {
log.warn("ack/nack failed, broker will redeliver: {}", e.toString());
}
}
record Result(List<Jobs.Variant> variants, boolean fromStaging) {}
void process(Jobs.Msg m) {
Jobs.Claim c = jobs.claim(m);
if (c == null) {
record("duplicate", -1);
tag(m.attempt(), "duplicate");
return;
}
inflight.add(c);
String outcome = "retry";
try {
jobs.crash("crash-after-claim", c.attachment, c.filename);
Result r = run(c);
jobs.crash("crash-after-s3", c.attachment, c.filename);
if (Jobs.FAULTS && c.filename.startsWith("fault-slow") && c.version == 1) sleep(40000);
c.check();
if (!jobs.complete(c, r.variants())) {
outcome = "fenced";
return;
}
outcome = "done";
jobs.crash("crash-after-commit", c.attachment, c.filename);
// Staging удаляем только после COMMIT результата; не вышло — уберёт sweepStaging.
if (r.fromStaging()) {
try { storage.delete(Storage.STAGING + c.attachment); } catch (SdkException e) { log.warn("staging cleanup deferred: {}", e.toString()); }
}
log.atInfo().addKeyValue("event", "job.done").log("job {} attempt {} done: attachment {} v{}", c.job, c.attempt, c.attachment, c.version);
} catch (Jobs.Fenced e) {
outcome = "fenced";
log.atWarn().addKeyValue("event", "job.fenced").log("job {} attempt {}: lease lost, stopping without commit", c.job, c.attempt);
} catch (ImagePipeline.Invalid e) {
outcome = "failed";
log.atWarn().addKeyValue("event", "job.failed").log("job {} attempt {}: invalid_image", c.job, c.attempt);
jobs.fail(c, "invalid_image", e.getMessage());
} catch (Jobs.Permanent e) {
outcome = "failed";
log.atWarn().addKeyValue("event", "job.failed").log("job {} attempt {}: {}", c.job, c.attempt, e.code);
jobs.fail(c, e.code, e.getMessage());
} catch (DataAccessException e) {
throw e;
} catch (Exception e) {
log.atWarn().addKeyValue("event", "job.retry").log("job {} attempt {} failed: {}", c.job, c.attempt, e.toString());
jobs.retry(c, e);
} finally {
inflight.remove(c);
record(outcome, c.elapsedNanos() / 1e9);
tag(c.attempt, outcome);
}
}
Result run(Jobs.Claim c) throws Exception {
Path dir = Files.createTempDirectory("job-");
try {
// Доверенные метаданные — из БД; из сообщения берётся только ID.
Jobs.Source s = jobs.source(c.attachment);
String staging = Storage.STAGING + c.attachment;
boolean fromStaging = storage.size(staging) != null;
if (!fromStaging && storage.size(s.key()) == null) throw new Jobs.Permanent("source_missing", "neither staging nor original object exists");
Path src = dir.resolve("source");
storage.download(fromStaging ? staging : s.key(), src);
if (Files.size(src) != s.size() || !sha256(src).equals(s.sha256())) throw new Jobs.Permanent("processing_failed", "source checksum mismatch");
c.check();
// Публикация оригинала в конечный префикс: серверная копия тех же байтов, повтор безопасен.
if (fromStaging) storage.copy(staging, s.key());
if (Jobs.FAULTS && c.filename.startsWith("fault-transient") && c.attempt <= Jobs.MAX_ATTEMPTS) throw new IOException("injected transient fault");
// Один retry и успех: цепочка upload → попытка 1 (ERROR retry) → попытка 2 → S3/DB в одной трассе.
if (Jobs.FAULTS && c.filename.startsWith("fault-flaky") && c.attempt == 1) throw new IOException("injected transient fault, attempt 1 only");
List<Jobs.Variant> variants = new ArrayList<>();
for (ImagePipeline.Output o : ImagePipeline.render(src, s.contentType(), c.version, dir, c)) {
c.check();
// Детерминированный ключ эффекта (attachment, version, variant): повтор перезаписывает тот же объект.
String key = Storage.VARIANTS + c.attachment + "/v" + c.version + "/" + o.file();
storage.put(key, o.path(), o.contentType());
variants.add(new Jobs.Variant(o.name(), o.contentType(), Files.size(o.path()), o.width(), o.height(), sha256(o.path()), key));
}
return new Result(variants, fromStaging);
} finally {
try (Stream<Path> files = Files.walk(dir)) {
files.sorted(Comparator.reverseOrder()).forEach(p -> p.toFile().delete());
}
}
}
// Продление аренды работающих попыток; не продлилась (истекла/перехвачена) — прервать без фиксации.
void heartbeat() {
for (Jobs.Claim c : inflight) {
if (c.elapsedSeconds() >= Jobs.TIMEOUT_SECONDS) {
c.abort();
continue;
}
try {
if (!jobs.extend(c)) {
c.fenced = true;
c.abort();
}
} catch (RuntimeException e) {
log.warn("heartbeat for job {} failed: {}", c.job, e.toString());
}
}
}
static String sha256(Path file) throws IOException {
MessageDigest sha = Attachments.sha256();
try (InputStream in = new DigestInputStream(Files.newInputStream(file), sha)) {
in.transferTo(java.io.OutputStream.nullOutputStream());
}
return HexFormat.of().formatHex(sha.digest());
}
static void sleep(long ms) {
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
// SIGTERM: перестать брать новые сообщения, дождаться текущих попыток (≤ 25 с), закрыть соединение.
@PreDestroy
void stop() {
stopping = true;
synchronized (this) {
subscriptions.forEach((ch, tag) -> {
try { ch.basicCancel(tag); } catch (Exception ignored) {}
});
}
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(25);
while (!inflight.isEmpty() && System.nanoTime() < deadline) sleep(200);
timer.shutdownNow();
synchronized (this) {
if (connection != null) connection.abort();
}
consumers.shutdown();
}
}
+18
View File
@@ -0,0 +1,18 @@
# Graceful shutdown: завершаем обработку текущих запросов перед остановкой.
server.shutdown=graceful
# Ожидание текущих запросов при shutdown: 20 с, меньше stop_grace_period 30s в compose.yaml,
# чтобы Docker не прислал SIGKILL посреди закрытия пулов PostgreSQL/Redis.
spring.lifecycle.timeout-per-shutdown-phase=20s
# Простой между пакетами тела запроса; медленную загрузку дополнительно буферизует nginx.
server.tomcat.connection-timeout=10s
# Лишние поля в JSON (например sender_id) по контракту дают 400, а не игнорируются.
spring.jackson.deserialization.fail-on-unknown-properties=true
# Секреты из /run/secrets: имя файла = имя свойства (spring.datasource.password, s3.access-key, ...).
spring.config.import=optional:configtree:/run/secrets/
# Миграции выполняет только контейнер migration (режим migrate), реплики их не запускают.
spring.flyway.enabled=false
# Два потока планировщика: долгий обход Reconciler не задерживает outbox relay (раз в секунду).
spring.task.scheduling.pool.size=2
@@ -0,0 +1,20 @@
-- Version 1: базовая схема мессенджера (lab2). Версии миграций ведёт Flyway (flyway_schema_history).
CREATE TABLE users (
id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL,
display_name VARCHAR(100) NOT NULL, password_hash VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chat_members (
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE messages (
id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID REFERENCES users(id), text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX messages_history ON messages(chat_id, created_at, id);
@@ -0,0 +1,11 @@
-- Version 2: идемпотентность отправки сообщения (lab3).
CREATE TABLE idempotency_keys (
idempotency_key VARCHAR(128) NOT NULL,
user_id UUID NOT NULL,
chat_id UUID NOT NULL,
request_hash VARCHAR(64) NOT NULL,
message_id UUID NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
PRIMARY KEY (user_id, chat_id, idempotency_key)
);
CREATE INDEX idempotency_cleanup ON idempotency_keys(created_at);
@@ -0,0 +1,29 @@
-- Version 3: вложения (lab4). Байты лежат в S3, здесь только метаданные и связь с сообщениями.
CREATE TABLE attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id),
-- Только отображаемое имя: в путях и S3-ключах не используется. VARCHAR считает code points.
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(20) NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes BIGINT NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
sha256 CHAR(64) NOT NULL,
width INT NOT NULL CHECK (width > 0),
height INT NOT NULL CHECK (height > 0),
-- uploading: намерение записано до S3 PUT; ready: объект сохранён; lost: сверка не нашла объект.
state VARCHAR(16) NOT NULL CHECK (state IN ('uploading', 'ready', 'lost')),
-- Ключ назначает сервер. COLLATE "C" даёт побайтовый порядок, как у листинга S3: сверка идёт слиянием.
object_key TEXT COLLATE "C" NOT NULL UNIQUE,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX attachments_chat ON attachments(chat_id);
CREATE INDEX attachments_unfinished ON attachments(state, updated_at) WHERE state <> 'ready';
-- FK на attachments не даёт удалить вложение, на которое ссылается сообщение.
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id),
position SMALLINT NOT NULL,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX message_attachments_attachment ON message_attachments(attachment_id);
@@ -0,0 +1,78 @@
-- Version 4 (lab5): асинхронная обработка вложений. Состояния, задания, outbox, результаты по ключу эффекта.
ALTER TABLE attachments DROP CONSTRAINT attachments_state_check;
-- uploading — только строки lab4; queued → processing → ready | failed; lost ставит сверка.
ALTER TABLE attachments ADD CONSTRAINT attachments_state_check
CHECK (state IN ('uploading', 'queued', 'processing', 'ready', 'failed', 'lost'));
-- error_code — безопасный машинный код для failed; pipeline_version — текущая (последняя зафиксированная) версия вариантов.
ALTER TABLE attachments ADD COLUMN error_code VARCHAR(32), ADD COLUMN pipeline_version INT;
-- Одна логическая работа на (вложение, версия pipeline). attempt — номер управляемой попытки и fencing token.
CREATE TABLE jobs (
job_id UUID PRIMARY KEY,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
pipeline_version INT NOT NULL CHECK (pipeline_version >= 1),
state VARCHAR(16) NOT NULL CHECK (state IN ('queued', 'processing', 'done', 'failed')),
attempt INT NOT NULL CHECK (attempt >= 1),
attempts_limit INT NOT NULL,
lease_owner TEXT,
lease_until TIMESTAMPTZ,
started_at TIMESTAMPTZ,
next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
error_code VARCHAR(32),
last_error TEXT,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
UNIQUE (attachment_id, pipeline_version)
);
CREATE INDEX jobs_leases ON jobs(lease_until) WHERE state = 'processing';
CREATE INDEX jobs_failed ON jobs(updated_at) WHERE state = 'failed';
-- Transactional outbox: намерение опубликовать попытку, пишется в одной транзакции с её созданием.
CREATE TABLE outbox (
id BIGSERIAL PRIMARY KEY,
job_id UUID NOT NULL REFERENCES jobs(job_id) ON DELETE CASCADE,
attempt INT NOT NULL,
available_at TIMESTAMPTZ NOT NULL DEFAULT now(),
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX outbox_available ON outbox(available_at, id);
-- Результат: PK = ключ эффекта (attachment_id, pipeline_version, variant) — повтор не создаёт второй набор.
CREATE TABLE attachment_variants (
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
pipeline_version INT NOT NULL,
name VARCHAR(16) NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
content_type VARCHAR(20) NOT NULL,
size_bytes BIGINT NOT NULL CHECK (size_bytes > 0),
width INT NOT NULL CHECK (width > 0),
height INT NOT NULL CHECK (height > 0),
sha256 CHAR(64) NOT NULL,
object_key TEXT COLLATE "C" NOT NULL UNIQUE,
job_id UUID NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (attachment_id, pipeline_version, name)
);
-- Журнал для оператора и экспериментов: захваты, повторы, погашенные дубли, replay.
CREATE TABLE job_audit (
id BIGSERIAL PRIMARY KEY,
job_id UUID NOT NULL,
attempt INT NOT NULL,
event VARCHAR(32) NOT NULL,
actor TEXT NOT NULL,
detail TEXT,
at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX job_audit_job ON job_audit(job_id);
-- Однократные точки внедрения сбоев (FAULT_INJECTION=1), см. Jobs.crash.
CREATE TABLE fault_marks (
point TEXT NOT NULL,
attachment_id UUID NOT NULL,
PRIMARY KEY (point, attachment_id)
);
-- Перенос данных lab4: готовые оригиналы получают задание v1 (оригинал уже в originals/, staging нет).
INSERT INTO jobs(job_id, attachment_id, pipeline_version, state, attempt, attempts_limit, created_at, updated_at)
SELECT gen_random_uuid(), id, 1, 'queued', 1, 5, now(), now() FROM attachments WHERE state = 'ready';
INSERT INTO outbox(job_id, attempt) SELECT job_id, 1 FROM jobs;
@@ -0,0 +1,4 @@
-- Version 5 (lab6): W3C trace context причины попытки рядом с намерением её опубликовать.
-- Причина — upload в API или неудачная попытка в worker; relay публикует в этом контексте,
-- поэтому span publish/process попадают в trace исходного запроса. Нет активного span — NULL.
ALTER TABLE outbox ADD COLUMN traceparent TEXT, ADD COLUMN tracestate TEXT;
+224
View File
@@ -0,0 +1,224 @@
#!/usr/bin/env python3
"""Собственные проверки вложений (с lab4; в lab5 upload → 202 queued), только стандартная библиотека.
Покрывают: слишком большой файл, повреждённые PNG/JPEG, подмену MIME, decompression bomb,
опасные filename, чужое/неизвестное attachment_id, вложение другого чата, постороннего пользователя,
идемпотентность с вложениями. Ни одна пользовательская ошибка не должна давать 500.
--with-docker дополнительно (через docker compose из корня репозитория):
* останавливает S3: загрузка/скачивание -> 503, текстовые сообщения и /health/ready работают,
неудачная загрузка не оставляет строк в БД;
* останавливает API-реплику, принявшую загрузку, и скачивает файл через другую.
Синтетический fixture tests/fixtures/sample.jpg получен из sample.png (sips, quality 85).
"""
import json
import os
import struct
import subprocess
import time
import urllib.error
import urllib.request
import uuid
import zlib
from urllib.parse import quote
from client import ROOT, Client, arguments, check, run
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
JPEG = (ROOT / 'tests/fixtures/sample.jpg').read_bytes()
MIB = 1024 * 1024
def png(width, height, idat=None, depth=8, color=2):
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
if idat is None:
row = b'\x00' + bytes(width * 3)
idat = zlib.compress(row * height, 9)
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', width, height, depth, color, 0, 0, 0))
+ chunk(b'IDAT', idat) + chunk(b'IEND', b''))
def flip(data, at):
return data[:at] + bytes([data[at] ^ 0xff]) + data[at + 1:]
def compose(*args, check_rc=True):
return subprocess.run(['docker', 'compose', *args], cwd=ROOT, check=check_rc, capture_output=True, text=True).stdout
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-c', query).strip()
def main():
def configure(p):
p.add_argument('--with-docker', action='store_true', help='also stop S3 and the uploading replica via docker compose')
args = arguments('Negative attachment checks for lab4; creates synthetic data', configure)
c = Client(args.base_url, args.ca_file, timeout=20)
alice, bob, eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой чат', 'member_ids': [alice['id'], eve['id']]}, schema='Chat')['json']
passed = []
def upload(data, ctype='image/png', expected=202, actor=alice, target=chat, name='file.png'):
r = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (target['id'], quote(name, safe='')), expected,
actor=actor, raw=data, headers={'Content-Type': ctype}, schema='Attachment' if expected == 202 else None)
if expected >= 400:
check(r['json']['error']['code'] != 'internal_error', 'user error turned into 500')
return r
def ok(name):
passed.append(name)
print('PASS', name)
# Валидные форматы и побайтовое скачивание.
att_png = c.wait_ready(bob, upload(PNG)['json'])
att_jpg = c.wait_ready(bob, upload(JPEG, 'image/jpeg', name='photo.jpg')['json'])
check(att_jpg['content_type'] == 'image/jpeg' and att_jpg['status'] == 'ready', 'jpeg metadata')
for att, data, ctype in ((att_png, PNG, 'image/png'), (att_jpg, JPEG, 'image/jpeg')):
got = c.call('GET', '/api/v1/attachments/' + att['id'] + '/content', actor=bob)
check(got['bytes'] == data and got['headers'].get_content_type() == ctype, 'download differs')
ok('valid PNG and JPEG upload/download byte-for-byte')
# Размер: API отклоняет 10 MiB + 1 байт, nginx — всё больше 11 MiB, оба JSON 413.
upload(PNG[:8] + bytes(10 * MIB + 1 - 8), expected=413)
req = urllib.request.Request(c.base + '/api/v1/chats/%s/attachments?filename=big.png' % chat['id'], data=bytes(12 * MIB), method='POST',
headers={'Authorization': 'Bearer ' + alice['token'], 'Content-Type': 'image/png'})
try:
urllib.request.urlopen(req, timeout=20)
check(False, 'oversized body accepted')
except urllib.error.HTTPError as e:
body = json.loads(e.read())
check(e.code == 413 and body['error']['code'] == 'payload_too_large' and e.headers.get('X-Request-Id'), 'nginx 413 must be contract JSON')
# Почти 10 MiB: случайные пиксели не сжимаются; у каждой строки байт фильтра 0.
big = png(1800, 1900, idat=zlib.compress(b''.join(b'\x00' + os.urandom(1800 * 3) for _ in range(1900)), 1))
check(len(big) <= 10 * MIB, 'fixture too large')
upload(big)
ok('10 MiB + 1 byte -> 413 (API), 12 MiB -> 413 JSON (nginx), valid %.1f MiB accepted' % (len(big) / MIB))
# Повреждённые изображения.
idat_at = PNG.find(b'IDAT') + 8
for broken in (flip(PNG, idat_at), PNG[:len(PNG) // 2], PNG + b'trailing', PNG[:8] + b'garbage' * 10):
upload(broken, expected=415)
for broken in (JPEG[:len(JPEG) // 2], JPEG[:4] + b'\x00' * 100, JPEG[:2] + b'\xff\xda\x00\x02' + JPEG[2:]):
upload(broken, 'image/jpeg', expected=415)
ok('corrupted/truncated PNG and JPEG -> 415')
# Подмена MIME: проверяется содержимое, а не заголовок.
upload(PNG, 'image/jpeg', expected=415)
upload(JPEG, 'image/png', expected=415)
upload(b'GIF89a' + bytes(100), 'image/png', expected=415)
upload(b'<svg xmlns="http://www.w3.org/2000/svg"/>', 'image/png', expected=415)
upload(PNG, 'text/plain', expected=415)
upload(PNG, 'image/gif', expected=415)
ok('MIME spoofing (content vs Content-Type) -> 415')
# Decompression bomb: заголовок > 40 Мпикс -> 413 до распаковки; ложный маленький заголовок -> 415;
# честные 36 Мпикс (≈108 МБ пикселей) принимаются без декодирования в RAM.
upload(png(10000, 10000, idat=zlib.compress(bytes(1000))), expected=413)
upload(png(100, 100, idat=zlib.compress(bytes(50 * MIB), 9)), expected=415)
upload(png(6000, 6000))
ok('decompression bomb: >40 MP -> 413, lying header -> 415, honest 36 MP accepted')
# filename: только отображение; пути, NUL, управляющие символы и длина — 400.
for name in ('../evil.png', 'a/b.png', 'a\\b.png', 'a\x00b.png', 'a\x07b.png', 'line\nbreak.png', ' ', '..', 'x' * 256):
upload(PNG, name=name, expected=400)
c.call('POST', '/api/v1/chats/%s/attachments' % chat['id'], 400, actor=alice, raw=PNG, headers={'Content-Type': 'image/png'})
for name in ('фото 😀.png', '😀' * 255):
got = upload(PNG, name=name)['json']
check(got['filename'] == name, 'filename changed')
ok('dangerous filenames -> 400, Unicode up to 255 code points preserved')
# Доступ: посторонний не загружает и не читает, без сессии — 401, неизвестный id — 404.
upload(PNG, actor=eve, expected=404)
for suffix in ('', '/content'):
c.call('GET', '/api/v1/attachments/' + att_png['id'] + suffix, 404, actor=eve)
c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()) + suffix, 404, actor=alice)
c.call('GET', '/api/v1/attachments/not-a-uuid', 400, actor=alice)
c.call('POST', '/api/v1/chats/%s/attachments?filename=a.png' % chat['id'], 401, raw=PNG, headers={'Content-Type': 'image/png'})
ok('outsider/unknown attachment -> 404, no session -> 401')
# attachment_ids в сообщении.
path = '/api/v1/chats/%s/messages' % chat['id']
foreign = upload(PNG, target=other)['json']
def send(body, expected=201, key=None):
return c.call('POST', path, expected, actor=alice, body=body, headers={'Idempotency-Key': key or uuid.uuid4().hex},
schema='Message' if expected == 201 else None)
send({'text': 'чужое', 'attachment_ids': [foreign['id']]}, 404)
send({'text': 'неизвестное', 'attachment_ids': [str(uuid.uuid4())]}, 404)
send({'text': 'смесь', 'attachment_ids': [att_png['id'], foreign['id']]}, 404)
for bad in (['not-a-uuid'], [att_png['id'], att_png['id']], [str(uuid.uuid4()) for _ in range(11)], None, att_png['id'], [1]):
send({'text': 'x', 'attachment_ids': bad}, 400)
send({'text': ''}, 400)
send({'text': '', 'attachment_ids': []}, 400)
send({'text': ' ', 'attachment_ids': [att_png['id']]}, 400)
two = send({'text': '', 'attachment_ids': [att_jpg['id'], att_png['id']]})['json']
check(two['attachment_ids'] == [att_jpg['id'], att_png['id']] and two['text'] == '', 'attachment order or text changed')
history = c.call('GET', path + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
check(any(m == two for m in history), 'history lost attachment_ids')
ok('foreign/unknown attachment -> 404, malformed attachment_ids -> 400, order preserved')
# Идемпотентность: отсутствующий attachment_ids == [], другой набор с тем же ключом — 409.
key = uuid.uuid4().hex
first = send({'text': 'ключ'}, key=key)['json']
check(send({'attachment_ids': [], 'text': 'ключ'}, key=key)['json'] == first, 'missing vs [] must be equal')
send({'text': 'ключ', 'attachment_ids': [att_png['id']]}, 409, key=key)
key = uuid.uuid4().hex
first = send({'text': 'с файлом', 'attachment_ids': [att_png['id']]}, key=key)['json']
check(send({'text': 'с файлом', 'attachment_ids': [att_png['id']]}, key=key)['json'] == first, 'replay with attachment differs')
send({'text': 'с файлом', 'attachment_ids': [att_jpg['id']]}, 409, key=key)
ok('idempotency with attachment_ids (missing == [], different set -> 409)')
# Варианты lab5: thumbnail/crop JPEG, optimized WebP; мусорное имя — 400.
types = {'original': 'image/png', 'thumbnail': 'image/jpeg', 'crop': 'image/jpeg', 'optimized': 'image/webp'}
for name, ctype in types.items():
got = c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (att_png['id'], name), actor=bob)
check(got['headers'].get_content_type() == ctype, 'variant %s has wrong content type' % name)
c.call('GET', '/api/v1/attachments/%s/content?variant=../../etc' % att_png['id'], 400, actor=bob)
ok('variants: original/thumbnail/crop/optimized 200 with own types, garbage 400')
if args.with_docker:
# Недоступный S3: вложения 503, текстовый путь живёт, после сбоя нет зависших строк.
compose('stop', 's3')
try:
rows_before = sql('select count(*) from attachments')
r = upload(PNG, expected=503)
check(r['json']['error']['code'] == 'unavailable', 'S3 outage must be 503 unavailable')
c.call('GET', '/api/v1/attachments/' + att_png['id'] + '/content', 503, actor=bob)
c.call('GET', '/api/v1/attachments/' + att_png['id'], actor=bob, schema='Attachment')
send({'text': 'S3 лежит, текст идёт'})
c.call('GET', '/health/ready', schema='Health')
check(sql('select count(*) from attachments') == rows_before, 'failed upload left a row')
finally:
compose('start', 's3')
deadline = time.monotonic() + 60
while True:
try:
got = c.call('GET', '/api/v1/attachments/' + att_png['id'] + '/content', actor=bob)
break
except AssertionError:
check(time.monotonic() < deadline, 'downloads did not recover after S3 start')
time.sleep(1)
check(got['bytes'] == PNG, 'download after S3 recovery differs')
ok('S3 down: attachments 503, messages/ready OK, no rows left; recovered after start')
# Остановка реплики, принявшей загрузку: другая скачивает тот же файл.
r = upload(PNG)
served = r['headers']['X-Instance-Id']
c.wait_ready(bob, r['json'])
cid = [x for x in compose('ps', '-q', 'api-1', 'api-2').split() if x.startswith(served)]
check(len(cid) == 1, 'cannot map X-Instance-Id to a container')
subprocess.run(['docker', 'stop', cid[0]], check=True, capture_output=True)
try:
for _ in range(5):
got = c.call('GET', '/api/v1/attachments/' + r['json']['id'] + '/content', actor=bob)
check(got['bytes'] == PNG and got['headers']['X-Instance-Id'] != served, 'download through other replica failed')
finally:
subprocess.run(['docker', 'start', cid[0]], check=True, capture_output=True)
ok('upload replica %s stopped: other replica serves identical bytes' % served)
print('PASS: %d attachment checks' % len(passed))
if __name__ == '__main__':
run(main)
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 10 KiB

+408
View File
@@ -0,0 +1,408 @@
#!/usr/bin/env python3
"""Lab6 experiments on a running stack: `slo` (track 2: burn-rate alerts vs a spike, a long degradation and
an outage) and `incidents` (level 4: worker stop, slow DB, telemetry backends down). Reads telemetry through
the Grafana datasource proxy (admin password from secrets/, never printed); drives faults with docker compose,
so run it with the same COMPOSE_PROJECT_NAME/COMPOSE_FILE as the stack. `traces` (level 3/4 trace+log correlation,
upload chain with one retry, leak check) and `slo` need FAULT_INJECTION=1."""
import argparse
import base64
import json
import subprocess
import threading
import time
import urllib.parse
import urllib.request
from client import ROOT, Client, Failure, check, run
T0 = time.monotonic()
def now():
return round(time.monotonic() - T0, 1)
class Grafana:
def __init__(self, url):
password = (ROOT / 'secrets/grafana_admin_password').read_text().strip()
self.url = url.rstrip('/')
self.auth = 'Basic ' + base64.b64encode(('admin:' + password).encode()).decode()
def get(self, path):
req = urllib.request.Request(self.url + path, headers={'Authorization': self.auth})
with urllib.request.urlopen(req, timeout=20) as r:
return json.loads(r.read())
def prom(self, query):
return self.get('/api/datasources/proxy/uid/prometheus/api/v1/query?query=' + urllib.parse.quote(query))['data']['result']
def value(self, query):
result = self.prom(query)
return round(float(result[0]['value'][1]), 4) if result else None
def alerts(self):
data = self.get('/api/datasources/proxy/uid/prometheus/api/v1/alerts')['data']['alerts']
return {a['labels']['alertname']: a['state'] for a in data}
class AlertLog(threading.Thread):
"""Polls Prometheus alert states every 2 s and keeps transitions with experiment-relative time."""
def __init__(self, grafana):
super().__init__(daemon=True)
self.grafana, self.state, self.events, self.stop = grafana, {}, [], threading.Event()
def run(self):
while not self.stop.is_set():
try:
current = self.grafana.alerts()
except OSError:
current = self.state
for name in set(current) | set(self.state):
old, new = self.state.get(name, 'inactive'), current.get(name, 'inactive')
if old != new:
self.events.append({'t': now(), 'alert': name, 'from': old, 'to': new})
self.state = current
self.stop.wait(2)
def intervals(self, name):
"""Firing intervals [start, end) of one alert; end None = still firing."""
out, start = [], None
for e in self.events:
if e['alert'] != name:
continue
if e['to'] == 'firing':
start = e['t']
elif e['from'] == 'firing' and start is not None:
out.append([start, e['t']])
start = None
if start is not None:
out.append([start, None])
return out
class Load:
"""Paced POST-message load: `rps` total; share `fault` of requests carries X-Fault-Inject: http-500."""
def __init__(self, base_url, rps, threads=5):
self.client = Client(base_url)
self.alice, _, _, self.chat = self.client.bootstrap()
self.fault, self.phase, self.stop = 0.0, 'warmup', threading.Event()
self.counts, self.lock = {}, threading.Lock()
self.interval = threads / rps
self.threads = [threading.Thread(target=self.worker, args=(Client(base_url, timeout=5),), daemon=True) for _ in range(threads)]
def start(self):
for t in self.threads:
t.start()
def worker(self, client):
due, debt, n = time.monotonic(), 0.0, 0
path = '/api/v1/chats/' + self.chat['id'] + '/messages'
while not self.stop.is_set():
debt += self.fault
inject = debt >= 1
if inject:
debt -= 1
headers = {'Idempotency-Key': 'obs-%d-%d-%f' % (id(client), n, time.time())}
if inject:
headers['X-Fault-Inject'] = 'http-500'
try:
status = client.call('POST', path, [201, 500], body={'text': 'obs %d' % n}, actor=self.alice, headers=headers)['status']
outcome = 'injected_500' if status == 500 and inject else ('ok' if status == 201 else 'unexpected_500')
except Failure:
outcome = 'failed'
with self.lock:
bucket = self.counts.setdefault(self.phase, {})
bucket[outcome] = bucket.get(outcome, 0) + 1
n += 1
due += self.interval
time.sleep(max(0.0, due - time.monotonic()))
def compose(*args, check_rc=True):
return subprocess.run(['docker', 'compose', *args], cwd=ROOT, capture_output=True, text=True, check=check_rc).stdout
def slo(args):
g = Grafana(args.grafana_url)
probe = Client(args.base_url)
a, _, _, chat = probe.bootstrap()
status = probe.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', [201, 500], body={'text': 'probe'}, actor=a,
headers={'Idempotency-Key': 'probe-%f' % time.time(), 'X-Fault-Inject': 'http-500'})['status']
check(status == 500, 'fault injection is off: start the stack with FAULT_INJECTION=1')
check(wait_alerts(g, list(g.alerts()), False, 600) is not None, 'alerts still active before the experiment')
phases = [('baseline', args.baseline, 0.0), ('spike', args.spike, 1.0), ('after_spike', args.quiet, 0.0),
('degradation', args.degradation, args.degradation_ratio), ('after_degradation', args.quiet + 30, 0.0),
('outage', args.outage, 1.0), ('after_outage', args.quiet, 0.0)]
load = Load(args.base_url, args.rps)
watcher = AlertLog(g)
load.start()
watcher.start()
timeline, samples = [], []
for name, seconds, ratio in phases:
load.phase, load.fault = name, ratio
start = now()
print('%7.1fs phase %-18s %4ds fault=%.2f' % (start, name, seconds, ratio), flush=True)
while now() - start < seconds:
time.sleep(10)
samples.append({'t': now(), 'phase': name, **{w: g.value('slo:api_errors:ratio_rate' + w) for w in ('30s', '1m', '1m30s', '2m30s', '15m')}})
timeline.append({'phase': name, 'start': start, 'end': now(), 'fault_ratio': ratio})
load.stop.set()
watcher.stop.set()
watcher.join()
alerts = {name: watcher.intervals(name) for name in ('ApiAvailabilityFastBurn', 'ApiAvailabilitySlowBurn', 'ApiHighErrorRate')}
expected = {'ApiAvailabilityFastBurn': {'outage'}, 'ApiAvailabilitySlowBurn': {'degradation', 'outage'},
'ApiHighErrorRate': {'degradation', 'outage'}} # по политике SLO: всплеск < 2 % бюджета — не повод для реакции
phase_of = lambda t: next((p['phase'] for p in timeline if p['start'] <= t < p['end']), 'end')
fault_phase = {'spike', 'degradation', 'outage'}
analysis = {}
for name, spans in alerts.items():
rows = []
for start, end in spans:
cause = phase_of(start)
cause = cause.replace('after_', '') if cause.startswith('after_') else cause
origin = next(p for p in timeline if p['phase'] == cause) if cause in fault_phase else None
fault_end = origin['end'] if origin else None
rows.append({'fired_at': start, 'resolved_at': end, 'caused_by': cause,
'detect_s': round(start - origin['start'], 1) if origin else None,
'resolve_after_fault_end_s': round(end - fault_end, 1) if origin and end else None,
'expected': cause in expected[name]})
missed = sorted(expected[name] - {r['caused_by'] for r in rows})
analysis[name] = {'firings': rows, 'false_positives': sum(not r['expected'] for r in rows), 'missed': missed}
total = {k: sum(c.get(k, 0) for c in load.counts.values()) for k in ('ok', 'injected_500', 'unexpected_500', 'failed')}
result = {'design': {'rps': args.rps, 'slo': '99% non-5xx', 'compression': 24, 'phases': timeline},
'requests': load.counts, 'totals': total, 'alerts': analysis, 'events': watcher.events, 'ratios': samples}
out = ROOT / 'evidence/slo_experiment.json'
out.write_text(json.dumps(result, ensure_ascii=False, indent=1))
for name, a in analysis.items():
print(name, 'FP=%d missed=%s' % (a['false_positives'], a['missed']),
['%s: detect %ss, resolve +%ss' % (r['caused_by'], r['detect_s'], r['resolve_after_fault_end_s']) for r in a['firings']])
print('requests', total, '->', out.relative_to(ROOT))
check(total['unexpected_500'] == 0 and total['failed'] <= 3, 'unexpected request failures: %s' % total)
def wait_alerts(g, names, firing, timeout):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
active = {k for k, v in g.alerts().items() if v == 'firing'}
if (set(names) <= active) if firing else not (set(names) & set(g.alerts())):
return now()
time.sleep(2)
return None
def incidents(args):
g = Grafana(args.grafana_url)
report = {}
load = Load(args.base_url, 5, threads=2)
uploader = Client(args.base_url, timeout=10)
owner, _, _, chat = uploader.bootstrap()
uploads = {'accepted': 0, 'failed': 0}
stop_uploads = threading.Event()
def upload_loop():
while not stop_uploads.is_set():
try:
uploader.attachment(owner, chat)
uploads['accepted'] += 1
except Failure:
uploads['failed'] += 1
stop_uploads.wait(2)
watcher = AlertLog(g)
load.start()
watcher.start()
threading.Thread(target=upload_loop, daemon=True).start()
time.sleep(40)
# 1. Worker stopped: backlog grows, QueueLagHigh/WorkerAbsent fire; after start backlog drains, alerts resolve.
load.phase = 'worker_stopped'
t_stop = now()
compose('stop', 'worker')
queue = []
while now() - t_stop < args.worker_down:
time.sleep(10)
queue.append({'t': now(), 'depth': g.value('max(messenger_queue_depth)'), 'oldest_age_s': g.value('max(messenger_queue_oldest_age_seconds)')})
load.phase = 'worker_recovering'
t_start = now()
compose('start', 'worker')
drained = None
while now() - t_start < 300:
time.sleep(5)
depth = g.value('max(messenger_queue_depth)')
queue.append({'t': now(), 'depth': depth, 'oldest_age_s': g.value('max(messenger_queue_oldest_age_seconds)')})
if drained is None and depth == 0 and now() - t_start > 20:
drained = now()
if drained and wait_alerts(g, ['QueueLagHigh', 'WorkerAbsent'], False, 1):
break
report['worker_stop'] = {'stopped_at': t_stop, 'started_at': t_start, 'backlog_drained_at': drained, 'queue': queue}
print('worker stop: drained at', drained, json.dumps({n: watcher.intervals(n) for n in ('QueueLagHigh', 'WorkerAbsent')}), flush=True)
# 2. Slow DB: an exclusive lock on messages for N s; POST /messages waits in the INSERT span, not in the handler.
load.phase = 'db_locked'
t_lock = now()
compose('exec', '-T', 'postgres', 'psql', '-q', '-U', 'messenger', '-d', 'messenger', '-c',
'begin; lock table messages in access exclusive mode; select pg_sleep(%d); commit;' % args.db_lock)
load.phase = 'db_recovered'
time.sleep(25)
end_ns, start_ns = time.time_ns(), time.time_ns() - int((now() - t_lock + 30) * 1e9)
search = g.get('/api/datasources/proxy/uid/tempo/api/search?' + urllib.parse.urlencode(
{'tags': 'service.name=messenger-api', 'minDuration': '%ds' % max(2, args.db_lock // 2), 'limit': 5,
'start': start_ns // 10**9, 'end': end_ns // 10**9}))
slow = []
for t in search.get('traces', [])[:3]:
trace = g.get('/api/datasources/proxy/uid/tempo/api/traces/' + t['traceID'])
spans = [s for b in trace.get('batches') or trace.get('resourceSpans', []) for ss in b.get('scopeSpans', []) for s in ss['spans']]
dur = lambda s: (int(s['endTimeUnixNano']) - int(s['startTimeUnixNano'])) / 1e9
server = max((s for s in spans if s.get('kind') in ('SPAN_KIND_SERVER', 2)), key=dur, default=None)
db = max((s for s in spans if s.get('kind') in ('SPAN_KIND_CLIENT', 3) and any(a['key'].startswith('db.') for a in s.get('attributes', []))), key=dur, default=None)
slow.append({'trace_id': t['traceID'], 'root': t.get('rootTraceName'), 'server_s': server and round(dur(server), 2),
'slowest_db_span': db and db['name'], 'db_s': db and round(dur(db), 2)})
report['db_lock'] = {'locked_at': t_lock, 'lock_s': args.db_lock, 'slow_traces': slow,
'p99_messages_s_2m': g.value('histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api",http_route="/api/v1/chats/{id}/messages",http_request_method="POST"}[2m])))'),
'max_pending_connections_2m': g.value('max(max_over_time(db_client_connections_pending_requests[2m]))'),
'requests': {k: load.counts.get(k) for k in ('db_locked', 'db_recovered')}}
print('db lock:', json.dumps(slow), flush=True)
# 3. Telemetry backends down: API keeps serving; Collector memory stays bounded; losses are counted.
load.phase = 'telemetry_down'
# Собственные метрики Collector 0.115 приходят без суффикса _total; счётчик появляется при первой ошибке: нет = 0.
lost = lambda k: sum(g.value('sum(otelcol_exporter_%s_%s)' % (kind, k)) or 0 for kind in ('send_failed', 'enqueue_failed'))
before = {k: lost(k) for k in ('spans', 'log_records')}
compose('stop', 'loki', 'tempo')
t_down, memory = now(), []
while now() - t_down < args.telemetry_down:
time.sleep(10)
stats = compose('stats', '--no-stream', '--format', '{{.Name}} {{.MemUsage}}', 'otel-collector', check_rc=False).strip()
memory.append({'t': now(), 'collector_mem': stats.split(' ', 1)[-1],
'queue_batches': g.value('sum(otelcol_exporter_queue_size)'),
'refused_spans': g.value('sum(otelcol_receiver_refused_spans)')})
compose('start', 'loki', 'tempo')
load.phase = 'telemetry_recovered'
time.sleep(75)
after = {k: lost(k) for k in ('spans', 'log_records')}
report['telemetry_down'] = {'down_s': args.telemetry_down, 'collector': memory, 'lost_before': before, 'lost_after': after,
'requests': {k: load.counts.get(k) for k in ('telemetry_down', 'telemetry_recovered')}}
print('telemetry down:', json.dumps(memory[-1]), 'lost', before, '->', after, flush=True)
stop_uploads.set()
load.stop.set()
watcher.stop.set()
time.sleep(2)
report['alerts'] = {n: watcher.intervals(n) for n in sorted({e['alert'] for e in watcher.events})}
report['uploads'] = uploads
report['requests'] = load.counts
report['events'] = watcher.events
out = ROOT / 'evidence/incidents.json'
out.write_text(json.dumps(report, ensure_ascii=False, indent=1))
print('requests', load.counts, 'uploads', uploads, '->', out.relative_to(ROOT))
def trace_tree(g, trace_id, wait=60):
"""Spans of one trace from Tempo (waits for ingestion): service, kind, name, parent, status, key attributes."""
deadline = time.monotonic() + wait
while True:
try:
data = g.get('/api/datasources/proxy/uid/tempo/api/traces/' + trace_id)
except OSError:
data = {}
spans = []
for b in data.get('batches') or data.get('resourceSpans', []):
service = next((a['value'].get('stringValue') for a in b['resource']['attributes'] if a['key'] == 'service.name'), '?')
for ss in b.get('scopeSpans', []):
for sp in ss['spans']:
attrs = {a['key']: next(iter(a['value'].values()), None) for a in sp.get('attributes', [])}
spans.append({'service': service, 'kind': str(sp.get('kind', '')).replace('SPAN_KIND_', ''), 'name': sp['name'],
'span_id': sp['spanId'], 'parent': sp.get('parentSpanId') or None,
'start_ns': int(sp['startTimeUnixNano']), 'ms': round((int(sp['endTimeUnixNano']) - int(sp['startTimeUnixNano'])) / 1e6, 1),
'status': sp.get('status', {}).get('code', 'UNSET'),
**{k: attrs[k] for k in ('job.attempt', 'job.outcome', 'http.response.status_code', 'messaging.destination.name') if k in attrs}})
if any(s['kind'] == 'CONSUMER' and s.get('job.outcome') == 'done' for s in spans) or time.monotonic() > deadline:
return sorted(spans, key=lambda s: s['start_ns']), json.dumps(data)
time.sleep(5)
def logs_for(g, service, trace_id):
end = time.time_ns()
q = urllib.parse.quote('{service_name="%s"} | trace_id="%s"' % (service, trace_id))
data = g.get('/api/datasources/proxy/uid/loki/loki/api/v1/query_range?query=%s&limit=50&start=%d&end=%d&direction=forward' % (q, end - 900 * 10**9, end))
return [{'ts': v[0], 'line': v[1][:160], **{k: s['stream'].get(k) for k in ('event', 'severity_text', 'trace_id', 'span_id', 'request_id', 'http_route', 'http_response_status_code')}}
for s in data['data']['result'] for v in s['values']]
def traces(args):
"""Level 3/4 evidence: a controlled request → its trace + log; one upload with one retry → one trace to S3/DB."""
import os
g = Grafana(args.grafana_url)
c = Client(args.base_url)
alice, _, _, chat = c.bootstrap()
tid = lambda: os.urandom(16).hex()
marker = 'leak-marker-' + os.urandom(6).hex()
req_trace = tid()
r = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, body={'text': marker}, actor=alice, schema='Message',
headers={'Idempotency-Key': os.urandom(8).hex(), 'traceparent': '00-%s-%s-01' % (req_trace, os.urandom(8).hex())})
request_id = r['headers'].get('X-Request-Id')
content = (ROOT / 'tests/fixtures/sample.png').read_bytes()
up_trace = tid()
att = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=fault-flaky-trace.png', 202, actor=alice, raw=content, schema='Attachment',
headers={'Content-Type': 'image/png', 'traceparent': '00-%s-%s-01' % (up_trace, os.urandom(8).hex())})['json']
ready = c.wait_ready(alice, att, 90)
time.sleep(15)
req_spans, req_raw = trace_tree(g, req_trace, 30)
up_spans, up_raw = trace_tree(g, up_trace, 90)
req_logs = logs_for(g, 'messenger-api', req_trace)
up_logs = logs_for(g, 'messenger-api', up_trace) + logs_for(g, 'messenger-worker', up_trace)
by_id = {s['span_id']: s for s in up_spans}
chain = [{'service': s['service'], 'kind': s['kind'], 'name': s['name'], 'parent': by_id[s['parent']]['name'] if s['parent'] in by_id else None,
'ms': s['ms'], 'status': s['status'], **{k: s[k] for k in ('job.attempt', 'job.outcome') if k in s}}
for s in up_spans if s['kind'] in ('SERVER', 'PRODUCER', 'CONSUMER')]
effects = sorted({s['name'] for s in up_spans if s['service'] == 'messenger-worker' and s['kind'] == 'CLIENT' and (s['name'].startswith('S3.') or s['name'].split(' ')[0] in ('UPDATE', 'INSERT'))})
token = alice['token']
leaks = {'message_text_in_logs_or_traces': sum(x.count(marker) for x in (json.dumps(req_logs), req_raw)),
'session_token_in_logs_or_traces': sum(x.count(token) for x in (json.dumps(req_logs + up_logs), req_raw, up_raw))}
lq = urllib.parse.quote('{service_name=~"messenger-api|messenger-worker"} |= "%s"' % marker)
end = time.time_ns()
leaks['message_text_in_loki_all_logs'] = len(g.get('/api/datasources/proxy/uid/loki/loki/api/v1/query_range?query=%s&limit=10&start=%d&end=%d' % (lq, end - 900 * 10**9, end))['data']['result'])
result = {'controlled_request': {'trace_id': req_trace, 'request_id': request_id, 'spans': [{k: s[k] for k in ('service', 'kind', 'name', 'ms', 'status')} for s in req_spans], 'logs': req_logs},
'upload_with_retry': {'trace_id': up_trace, 'attachment_status': ready['status'], 'chain': chain, 'worker_effect_spans': effects,
'logs': [{k: l[k] for k in ('event', 'severity_text', 'line', 'span_id')} for l in up_logs]},
'leak_check': leaks}
out = ROOT / 'evidence/trace_chain.json'
out.write_text(json.dumps(result, ensure_ascii=False, indent=1))
print(json.dumps({'request_spans': len(req_spans), 'request_logs': len(req_logs), 'chain': [(x['kind'], x['name'], x.get('job.outcome')) for x in chain],
'effects': effects, 'leaks': leaks}, ensure_ascii=False))
check(req_spans and req_logs, 'controlled request: trace or log not found')
check(any(x.get('job.outcome') == 'retry' for x in chain) and any(x.get('job.outcome') == 'done' for x in chain), 'upload trace lacks retry→done chain')
check(not any(leaks.values()), 'telemetry leak: %s' % leaks)
print('PASS: trace/log correlation and upload chain ->', out.relative_to(ROOT))
def ttr(args):
"""Baseline time to ready under light load: N uploads one per second, client-side (request start → ready, poll 0.3 s)."""
c = Client(args.base_url)
owner, _, _, chat = c.bootstrap()
seconds, lock = [], threading.Lock()
def one():
start = time.monotonic()
att, _ = c.attachment(owner, chat)
c.wait_ready(owner, att, 120)
with lock:
seconds.append(round(time.monotonic() - start, 2))
threads = []
for _ in range(args.uploads):
threads.append(threading.Thread(target=one))
threads[-1].start()
time.sleep(1)
for t in threads:
t.join()
seconds.sort()
q = lambda f: seconds[min(len(seconds) - 1, int(f * len(seconds)))]
result = {'uploads': len(seconds), 'p50_s': q(0.5), 'p95_s': q(0.95), 'max_s': seconds[-1], 'over_10s': sum(x > 10 for x in seconds), 'all_s': seconds}
out = ROOT / 'evidence/ttr_baseline.json'
out.write_text(json.dumps(result, indent=1))
print({k: v for k, v in result.items() if k != 'all_s'}, '->', out.relative_to(ROOT))
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('mode', choices=['traces', 'slo', 'incidents', 'ttr'])
p.add_argument('--base-url', default=None)
p.add_argument('--grafana-url', default='http://localhost:3000')
p.add_argument('--rps', type=float, default=10)
p.add_argument('--baseline', type=int, default=300)
p.add_argument('--spike', type=int, default=15)
p.add_argument('--quiet', type=int, default=120)
p.add_argument('--degradation', type=int, default=360)
p.add_argument('--degradation-ratio', type=float, default=0.1)
p.add_argument('--outage', type=int, default=60)
p.add_argument('--worker-down', type=int, default=150)
p.add_argument('--db-lock', type=int, default=20)
p.add_argument('--telemetry-down', type=int, default=120)
p.add_argument('--uploads', type=int, default=30)
args = p.parse_args()
{'traces': traces, 'slo': slo, 'incidents': incidents, 'ttr': ttr}[args.mode](args)
if __name__ == '__main__':
run(main)
+285
View File
@@ -0,0 +1,285 @@
#!/usr/bin/env python3
"""Сквозная проверка pipeline lab5 (уровни 3–4) и эксперимент трека 2 «доказанная идемпотентность».
Гипотеза: при at-least-once доставке, дублях, перестановке сообщений, падениях до/после побочного
эффекта и устаревшей job после новой версии ни одна принятая (202) работа не теряется, на ключ эффекта
(attachment_id, pipeline_version, variant) приходится ровно один результат, а указатель версии не откатывается.
Сценарии (FAULT_INJECTION=1 включает точки сбоя по префиксу имени файла fault-<point>, каждая — один раз):
A worker остановлен → upload 202, content 409, сообщение с вложением 201 → рестарт API и брокера → worker → ready;
B падения: relay до publish (разрыв COMMIT/publish), relay после publish до удаления outbox (дубль),
worker после захвата (до эффекта), после записи в S3 до COMMIT, после COMMIT до ack; временная ошибка до
исчерпания попыток (backoff+jitter → failed) и replay; постоянная ошибка (arithmetic JPEG);
C устаревшая job: v1 медленная (40 с перед COMMIT), v2 (jobctl reprocess) фиксируется раньше; дубли v1 во время и после обработки;
затем инварианты по БД, S3 и API.
Запуск из корня репозитория при работающем стенде (docker compose из этого каталога; для другого проекта —
COMPOSE_PROJECT_NAME/COMPOSE_FILE):
python3 tests/pipeline_experiment.py --output evidence/pipeline_experiment.json
Скрипт пересоздаёт api-1, api-2 и worker с FAULT_INJECTION=1 и арендой 6 с, в конце возвращает обычный режим.
"""
import hashlib
import json
import os
import re
import struct
import subprocess
import time
from pathlib import Path
from client import ROOT, Client, arguments, check, run
from image_probe import jpeg_size
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
BUCKET = 'messenger-attachments'
LEASE = 6
FAULT_ENV = {'FAULT_INJECTION': '1', 'JOB_LEASE_SECONDS': str(LEASE)}
CRASHES = ['crash-before-publish', 'crash-after-publish', 'crash-after-claim', 'crash-after-s3', 'crash-after-commit']
def compose(*args, env=None, stdin=None):
p = subprocess.run(['docker', 'compose', *args], cwd=ROOT, input=stdin, capture_output=True, text=True, env={**os.environ, **(env or {})})
check(p.returncode == 0, 'docker compose %s failed: %s' % (' '.join(args[:2]), p.stderr[-400:]))
return p.stdout
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-F', '|', '-c', query).strip()
def rows(query):
out = sql(query)
return [line.split('|') for line in out.split('\n')] if out else []
def queue():
out = compose('exec', '-T', 'rabbitmq', 'rabbitmqctl', '-q', 'list_queues', 'name', 'messages')
return {k: int(v) for k, v in (line.split('\t') for line in out.strip().split('\n') if '\t' in line and not line.startswith('name'))}
def s3(commands):
# Подписанные запросы ключами API из контейнера s3-probe; ключи передаются curl через stdin.
script = ('sign() { printf \'user = "%s:%s"\\n\' "$(cat /run/secrets/s3.access-key)" "$(cat /run/secrets/s3.secret-key)"; }\n'
'url=http://s3:8333/' + BUCKET + '\n' + '\n'.join(commands) + '\n')
return compose('run', '--rm', '-T', 's3-probe', stdin=script)
def s3_keys(prefix):
return re.findall(r'<Key>([^<]+)</Key>', s3(['sign | curl -K - -s --aws-sigv4 aws:amz:us-east-1:s3 "$url?list-type=2&prefix=%s"' % prefix]))
def s3_sha256(keys):
out = s3(['echo "%s $(sign | curl -K - -s --aws-sigv4 aws:amz:us-east-1:s3 "$url/%s" | sha256sum | cut -d" " -f1)"' % (k, k) for k in keys])
return dict(line.split(' ') for line in out.strip().split('\n') if line)
def jobctl(*args):
out = compose('run', '--rm', '-T', 'jobctl', *args)
return json.loads(out[out.index('{'):])
def arithmetic_jpeg():
# Структурно корректный JPEG (SOF9, arithmetic coding): API принимает, ImageIO декодировать не умеет.
seg = lambda marker, body: b'\xff' + bytes([marker]) + struct.pack('>H', len(body) + 2) + body
return (b'\xff\xd8' + seg(0xC9, struct.pack('>BHHB', 8, 16, 16, 1) + b'\x01\x11\x00')
+ seg(0xDA, b'\x01\x01\x00\x00\x3f\x00') + b'\x00' * 32 + b'\xff\xd9')
def wait_until(what, condition, timeout):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
value = condition()
if value:
return value
except Exception:
pass # API-реплика или брокер перезапускаются после внедрённого падения
time.sleep(0.5)
check(False, 'timeout waiting for ' + what)
def events(job):
return [(int(a), e, d) for a, e, d in rows("select attempt,event,coalesce(detail,'') from job_audit where job_id='%s' order by id" % job)]
def invariants(ids, invalid_id):
in_list = ','.join("'%s'" % i for i in ids)
jobs_of = 'select job_id from jobs where attachment_id in (%s)' % in_list
states = dict(rows('select id,state from attachments where id in (%s)' % in_list))
check(all(states[i] == 'ready' for i in ids if i != invalid_id) and states[invalid_id] == 'failed', 'I1: accepted work lost or stuck: %s' % states)
effects = rows('select attachment_id,pipeline_version,count(*) from attachment_variants where attachment_id in (%s) group by 1,2' % in_list)
check(all(int(n) == 3 for _, _, n in effects), 'I2: effect key has not exactly 3 variants')
db_sha = dict(rows('select object_key,sha256 from attachment_variants where attachment_id in (%s)' % in_list))
s3_variants = sorted(k for i in ids for k in s3_keys('variants/' + i + '/'))
check(s3_variants == sorted(db_sha), 'I2: S3 variant objects differ from DB rows')
s3_sha = s3_sha256(sorted(db_sha))
check(s3_sha == db_sha, 'I3: S3 bytes differ from committed checksums')
# I4: каждое done-задание зафиксировано ровно один раз, failed — ни разу; после done захватов нет.
commits = rows("select j.state,count(a.*) filter (where a.event='done') from jobs j left join job_audit a on a.job_id=j.job_id where j.job_id in (%s) group by j.job_id,j.state" % jobs_of)
check(all(int(n) == (1 if s == 'done' else 0) for s, n in commits), 'I4: a job was committed more than once (or failed job committed): %s' % commits)
after_done = sql("select count(*) from job_audit a join job_audit d on d.job_id=a.job_id and d.event='done' and a.event='claimed' and a.id>d.id where a.job_id in (%s)" % jobs_of)
check(after_done == '0', 'I4: a done job was claimed again')
# I5: staging ready-вложений удалён (сразу после COMMIT или sweepStaging), failed хранится до retention.
ready_ids = {i for i in ids if states[i] == 'ready'}
staging = wait_until('staging cleanup', lambda: (lambda left: {'staging_left_for_run': sorted(left & set(ids))} if not left & ready_ids else None)(
{k.split('/')[1] for k in s3_keys('staging/')}), 90)
duplicates = dict(rows("select event,count(*) from job_audit where event in ('duplicate_done','duplicate_in_progress','stale_attempt') and job_id in (%s) group by 1" % jobs_of))
result = {'I1_no_lost_accepted_work': states, 'I2_variants_per_effect_key': {'%s/v%s' % (a, v): int(n) for a, v, n in effects},
'I2_s3_variant_objects': len(s3_variants), 'I3_checksums_equal': len(s3_sha),
'I4_commits_per_job': sorted(int(n) for _, n in commits), 'I5_staging': staging,
'duplicates_dropped': {k: int(v) for k, v in duplicates.items()}, 'result': 'PASS'}
print('PASS invariants: %d attachments final, %d variant objects = DB rows, checksums equal, every done job committed once, dropped %s'
% (len(ids), len(s3_variants), result['duplicates_dropped']))
return result
def main():
def configure(p):
p.add_argument('--output', default=None)
args = arguments('Lab5 pipeline end-to-end checks and track-2 idempotency experiment', configure)
c = Client(args.base_url, args.ca_file, timeout=20)
started = time.monotonic()
compose('up', '-d', '--wait', 'api-1', 'api-2', 'worker', env=FAULT_ENV)
alice, bob, eve, chat = c.bootstrap()
report = {'experiment': 'lab5 pipeline: grade 3/4 scenarios and track 2 idempotency', 'lease_seconds': LEASE, 'scenarios': {}}
def upload(name, data=PNG, ctype='image/png'):
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), 202, actor=alice, raw=data,
headers={'Content-Type': ctype}, schema='Attachment')['json']
check(att['status'] == 'queued' and att['variants'] == [] and att['error_code'] is None, 'upload must return a queued snapshot')
return att
def meta(att):
return c.call('GET', '/api/v1/attachments/' + att['id'], actor=bob, schema='Attachment')['json']
def final(att, timeout=120):
return wait_until('final state of ' + att['filename'], lambda: (lambda m: m if m['status'] in ('ready', 'failed') else None)(meta(att)), timeout)
def job_of(att, version=1):
return sql("select job_id from jobs where attachment_id='%s' and pipeline_version=%d" % (att['id'], version))
# A. Worker остановлен: приём не зависит от worker, задание переживает рестарт API и брокера.
t0 = time.monotonic()
# Сначала очередь пуста (worker разобрал прежнее); счётчик list_queues у quorum-очереди обновляется
# с задержкой до ~5 с, поэтому пустоту подтверждаем двумя чтениями с паузой.
empty = lambda: queue().get('attachments.process', 1) == 0
wait_until('queue drained', lambda: empty() and (time.sleep(6) or empty()), 120)
compose('stop', 'worker')
demo = upload('demo.png')
for suffix in ('/content', '/content?variant=thumbnail'):
c.call('GET', '/api/v1/attachments/%s%s' % (demo['id'], suffix), 409, actor=bob)
linked = c.message(alice, chat, '', attachments=[demo['id']])['json']
c.message(bob, chat, 'worker остановлен, текст идёт')
depth = lambda least: (lambda q: q if q.get('attachments.process', 0) >= least else None)(queue())
depth_before = wait_until('job message in broker', lambda: depth(1), 30)
compose('restart', 'api-1', 'api-2', 'rabbitmq')
# После рестарта quorum-очередь сначала выбирает лидера; ждём, пока она снова покажет сообщение.
depth_after = wait_until('queued job after broker restart', lambda: depth(1), 90)
wait_until('API after restart', lambda: c.call('GET', '/health/ready', schema='Health'), 90)
check(meta(demo)['status'] == 'queued', 'attachment must stay queued while worker is down')
compose('start', 'worker')
ready = final(demo)
check(ready['status'] == 'ready' and ready['error_code'] is None, 'demo attachment did not become ready')
got = {v: c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (demo['id'], v), actor=bob) for v in ('original', 'thumbnail', 'crop', 'optimized')}
check(got['original']['bytes'] == PNG, 'original changed')
variants = {v['name']: v for v in ready['variants']}
check(sorted(variants) == ['crop', 'optimized', 'thumbnail'], 'expected thumbnail, crop, optimized')
check(jpeg_size(got['thumbnail']['bytes']) == (256, 160) and jpeg_size(got['crop']['bytes']) == (128, 128), 'JPEG variant dimensions')
check(got['optimized']['bytes'][:4] == b'RIFF' and got['optimized']['bytes'][8:12] == b'WEBP', 'optimized is not WebP')
check((variants['optimized']['width'], variants['optimized']['height']) == (320, 200), 'optimized must not upscale 320x200')
for v in ('thumbnail', 'crop', 'optimized'):
check(hashlib.sha256(got[v]['bytes']).hexdigest() == variants[v]['sha256'], 'variant checksum mismatch: ' + v)
report['scenarios']['A_worker_down_restart'] = {
'attachment_id': demo['id'], 'job_id': job_of(demo), 'message_id': linked['id'],
'queue_before_restart': depth_before, 'queue_after_restart': depth_after,
'content_while_queued': 409, 'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS A: worker down -> 202/409/message 201 -> API+broker restart keeps job -> worker -> ready')
# B. Падения в окнах отказа, временная и постоянная ошибки. Relay работает и в API-репликах:
# его падение роняет реплику, поэтому эти два сценария идут по одному, остальные — параллельно.
t0 = time.monotonic()
crash = {}
for p in CRASHES[:2]:
crash[p] = upload('fault-%s.png' % p)
final(crash[p], 180)
wait_until('API after relay crash', lambda: c.call('GET', '/health/ready', schema='Health'), 90)
crash.update({p: upload('fault-%s.png' % p) for p in CRASHES[2:]})
transient = upload('fault-transient.png')
invalid = upload('arith.jpg', arithmetic_jpeg(), 'image/jpeg')
# Перестановка: устаревшее сообщение attempt=1, когда задание уже на attempt≥2.
tjob = job_of(transient)
wait_until('transient job retry', lambda: int(sql("select attempt from jobs where job_id='%s'" % tjob)) >= 2, 240)
sql("insert into outbox(job_id,attempt) values('%s',1)" % tjob)
results = {p: final(a, 300) for p, a in crash.items()}
bad = final(invalid)
exhausted = final(transient, 300)
check(all(r['status'] == 'ready' for r in results.values()), 'crash scenario did not reach ready: %s' % {p: r['status'] for p, r in results.items()})
check(bad['status'] == 'failed' and bad['error_code'] == 'invalid_image', 'arithmetic JPEG must fail with invalid_image')
check(exhausted['status'] == 'failed' and exhausted['error_code'] == 'retry_exhausted', 'transient job must end with retry_exhausted')
c.call('GET', '/api/v1/attachments/%s/content' % bad['id'], 409, actor=bob)
c.call('POST', '/api/v1/chats/%s/messages' % chat['id'], 409, actor=alice, body={'text': '', 'attachment_ids': [bad['id']]},
headers={'Idempotency-Key': 'failed-' + bad['id']})
fired = sorted(r[0] for r in rows('select point from fault_marks'))
check(all(p in fired for p in CRASHES), 'not all crash points fired: %s' % fired)
per = {p: events(job_of(a)) for p, a in crash.items()}
check(any(e == 'lease_expired' for _, e, _ in per['crash-after-claim']), 'crash before effect: lease did not expire')
check(any(e == 'lease_expired' for _, e, _ in per['crash-after-s3']), 'crash after S3 write: lease did not expire')
check([a for a, e, _ in per['crash-after-commit'] if e == 'done'] == [1] and any(e == 'duplicate_done' for _, e, _ in per['crash-after-commit']),
'crash after commit: redelivery must be a no-op')
check(any(e.startswith('duplicate') or e == 'stale_attempt' for _, e, _ in per['crash-after-publish']), 'duplicate publish not observed')
tev = events(tjob)
delays = [int(re.search(r'delay_ms=(\d+)', d).group(1)) for _, e, d in tev if e == 'retry_scheduled']
check(len(delays) == 4 and [a for a, e, _ in tev if e == 'claimed'] == [1, 2, 3, 4, 5], 'transient job: expected 5 attempts, 4 backoffs')
check(any(e == 'stale_attempt' for _, e, _ in tev), 'stale attempt=1 message was not dropped')
check(sum(e == 'failed' for _, e, _ in events(job_of(invalid))) == 1 and not any(e == 'retry_scheduled' for _, e, _ in events(job_of(invalid))),
'permanent error must not be retried')
# Replay: failed → queued (новая попытка того же job_id); повтор replay и replay done-задания — no-op.
replay = jobctl('replay', tjob, job_of(crash['crash-after-commit']))
replayed = final(transient, 60)
check(replayed['status'] == 'ready', 'replayed job did not become ready')
again = jobctl('replay', tjob)
check(again[tjob].startswith('skipped') and replay[job_of(crash['crash-after-commit'])].startswith('skipped'), 'replay of done job must be skipped')
report['scenarios']['B_faults'] = {
'fired_points': fired,
'audit': {p: [list(e) for e in v] for p, v in per.items()},
'transient': {'job_id': tjob, 'backoff_delays_ms': delays, 'audit': [list(e) for e in events(tjob)], 'replay': replay, 'replay_again': again},
'invalid_image': {'job_id': job_of(invalid), 'audit': [list(e) for e in events(job_of(invalid))]},
'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS B: crash windows recovered, duplicates dropped, backoff %s ms -> retry_exhausted -> replay -> ready, invalid_image not retried' % delays)
# C. Устаревшая job после новой версии + дубли во время и после обработки.
t0 = time.monotonic()
slow = upload('fault-slow.png')
v1 = job_of(slow)
wait_until('v1 claimed', lambda: sql("select state from jobs where job_id='%s'" % v1) == 'processing', 30)
created = jobctl('reprocess', '--pipeline-version=2', slow['id'])
for _ in range(3):
sql("insert into outbox(job_id,attempt) values('%s',1)" % v1)
wait_until('v1 done', lambda: sql("select state from jobs where job_id='%s'" % v1) == 'done', 90)
for _ in range(2):
sql("insert into outbox(job_id,attempt) values('%s',1)" % v1)
time.sleep(3)
m = meta(slow)
v2 = job_of(slow, 2)
v1_events, v2_events = events(v1), events(v2)
check(sql("select pipeline_version from attachments where id='%s'" % slow['id']) == '2', 'stale v1 job rolled back the version pointer')
check(('superseded' in [d for _, e, d in v1_events if e == 'done']), 'v1 must be committed as superseded after v2')
v2_rows = {r[0]: r[1] for r in rows("select name,sha256 from attachment_variants where attachment_id='%s' and pipeline_version=2" % slow['id'])}
check({v['name']: v['sha256'] for v in m['variants']} == v2_rows and len(v2_rows) == 3, 'API must serve v2 variants')
check(sum(e == 'duplicate_in_progress' for _, e, _ in v1_events) >= 1 and sum(e == 'duplicate_done' for _, e, _ in v1_events) >= 2, 'duplicates of v1 were not dropped')
report['scenarios']['C_stale_version'] = {'attachment_id': slow['id'], 'v1_job': v1, 'v2_job': v2, 'reprocess': created,
'v1_audit': [list(e) for e in v1_events], 'v2_audit': [list(e) for e in v2_events],
'pointer': 2, 'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS C: v2 committed first, late v1 committed as superseded, pointer stays 2, duplicates dropped')
# Инварианты по всем вложениям прогона.
ids = [demo['id'], slow['id'], transient['id'], invalid['id']] + [a['id'] for a in crash.values()]
report['invariants'] = invariants(ids, invalid['id'])
report['seconds_total'] = round(time.monotonic() - started, 1)
compose('up', '-d', '--wait', 'api-1', 'api-2', 'worker')
if args.output:
Path(args.output).parent.mkdir(parents=True, exist_ok=True)
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
if __name__ == '__main__':
run(main)
+107
View File
@@ -0,0 +1,107 @@
#!/usr/bin/env python3
"""Эксперимент уровня 4: N одновременных загрузок ~10 MiB и пик памяти контейнеров.
Память читается из cgroup v2 внутри контейнеров (memory.current и anon из memory.stat) каждые 0.2 с
через docker compose exec, пока идут загрузки. anon — память процессов (heap JVM и native),
memory.current дополнительно включает page cache временных файлов.
Пример: python3 tests/upload_memory.py --runs 1,10,20 --output evidence/upload_memory.json
"""
import json
import os
import struct
import subprocess
import threading
import time
import zlib
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from client import ROOT, Client, Failure, arguments, check, run
SERVICES = ('api-1', 'api-2', 'nginx', 's3')
# Свой дедлайн: docker exec не завершает процесс в контейнере, когда клиент отключается.
SAMPLER = ('end=$(($(date +%s)+180)); while [ $(date +%s) -lt $end ]; do '
'echo $(cat /sys/fs/cgroup/memory.current) $(grep "^anon " /sys/fs/cgroup/memory.stat | cut -d" " -f2) || exit; sleep 0.2; done')
def big_png():
# 1800×1900 RGB из случайных байтов не сжимается: файл ≈9.8 MiB, чуть меньше лимита 10 MiB.
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
raw = b''.join(b'\x00' + os.urandom(1800 * 3) for _ in range(1900))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 1800, 1900, 8, 2, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(raw, 1)) + chunk(b'IEND', b''))
class Sampler:
"""Фоновое чтение памяти одного контейнера; хранит максимум за время измерения."""
def __init__(self, service):
self.service, self.peak_current, self.peak_anon, self.base = service, 0, 0, None
self.proc = subprocess.Popen(['docker', 'compose', 'exec', '-T', service, 'sh', '-c', SAMPLER], cwd=ROOT,
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
threading.Thread(target=self.read, daemon=True).start()
def read(self):
for line in self.proc.stdout:
parts = line.split()
if len(parts) != 2:
continue
current, anon = map(int, parts)
if self.base is None:
self.base = (current, anon)
self.peak_current, self.peak_anon = max(self.peak_current, current), max(self.peak_anon, anon)
def stop(self):
self.proc.terminate()
mib = lambda v: round(v / 2**20, 1)
return {'baseline_current_mib': mib(self.base[0]), 'baseline_anon_mib': mib(self.base[1]),
'peak_current_mib': mib(self.peak_current), 'peak_anon_mib': mib(self.peak_anon)}
def main():
def configure(p):
p.add_argument('--runs', default='1,10,20', help='comma-separated concurrency levels')
p.add_argument('--output', default=None)
args = arguments('Concurrent ~10 MiB uploads with peak container memory', configure)
c = Client(args.base_url, args.ca_file, timeout=120)
alice, bob, eve, chat = c.bootstrap()
data = big_png()
check(len(data) <= 10 * 2**20, 'fixture exceeds 10 MiB')
results = []
for n in [int(x) for x in args.runs.split(',')]:
samplers = [Sampler(s) for s in SERVICES]
time.sleep(1.5)
def one(_):
local = Client(args.base_url, args.ca_file, timeout=120)
started = time.monotonic()
try:
r = local.call('POST', '/api/v1/chats/%s/attachments?filename=big.png' % chat['id'], [202, 503], actor=alice,
raw=data, headers={'Content-Type': 'image/png'})
return r['status'], time.monotonic() - started, r['headers'].get('X-Instance-Id')
except Failure as e:
return str(e), time.monotonic() - started, None
started = time.monotonic()
with ThreadPoolExecutor(max_workers=n) as pool:
done = list(pool.map(one, range(n)))
wall = time.monotonic() - started
time.sleep(1)
memory = {s.service: s.stop() for s in samplers}
statuses = {}
for status, _, _ in done:
statuses[str(status)] = statuses.get(str(status), 0) + 1
latencies = sorted(d for _, d, _ in done)
result = {'concurrent_uploads': n, 'file_mib': round(len(data) / 2**20, 2), 'statuses': statuses,
'replicas_used': len({i for _, _, i in done if i}), 'wall_seconds': round(wall, 2),
'latency_seconds': {'p50': round(latencies[len(latencies) // 2], 2), 'max': round(latencies[-1], 2)},
'memory': memory}
print(json.dumps(result, ensure_ascii=False))
results.append(result)
report = {'experiment': 'concurrent ~10 MiB PNG uploads through nginx', 'api_memory_limit': '512M per replica, JVM heap max 128 MiB',
'max_concurrent_uploads_per_replica': 8, 'results': results}
if args.output:
Path(args.output).parent.mkdir(parents=True, exist_ok=True)
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
if __name__ == '__main__':
run(main)