Author SHA1 Message Date
celis 66367ca653 Проверять фильтры строк PNG и таблицы JPEG при загрузке
PNG: тип фильтра каждой строки (с учётом Adam7) только 0–4, длина PLTE
кратна 3 и не больше 256 цветов. JPEG: заголовки и таблицы проверяются
так же, как в libjpeg-turbo — вид SOF, 8 бит, 1/3/4 компонента,
прореживание, DQT/DHT для каждого скана, параметры SOS, непустой скан.
Файлы из замечаний (PNG 1x1 с фильтром 5, JPEG 27 байт без таблиц и
данных скана) теперь получают 415; добавлены тесты.
2026-10-31 10:30:56 +03:00
celis 51b02a541d Реализовать лабораторную 6: OpenTelemetry, Grafana, SLO и burn-rate alerts
- api и worker отдают traces, metrics и logs по OTLP в Collector
  (memory_limiter, redaction, batch, ограниченная очередь и retry);
  хранилища: Prometheus (OTLP receiver), Loki, Tempo; Grafana с
  provisioning datasources и dashboard «Messenger lab6»
- W3C trace context через outbox и RabbitMQ: producer/consumer spans
  связывают upload, публикации и попытки worker в одном trace
- SLO доступности API (SLI на HAProxy) и времени до ready, multiwindow
  burn-rate alerts, ApiHighErrorRate, JobQueueLagGrowing,
  DbPoolSaturated, TelemetryExportFailing; unit-тесты promtool, runbooks
- кампания трека 2 (k6, 6 отказов по расписанию), разбор и графики;
  проверки сигналов и истории telemetry, evidence и REPORT.md
2026-10-31 01:45:56 +03:00
89 changed files with 14231 additions and 16 deletions
+3
View File
@@ -18,3 +18,6 @@ __pycache__
node_modules
evidence
.DS_Store
research
student-tests
tests
+26
View File
@@ -23,8 +23,34 @@ WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
# Implementation knobs (compose.yaml interpolation), see REPORT.md:
LB_PORT=8080
DB_POOL_MAX=8
API_CPUS=1
API_MEMORY=256m
DB_CPUS=2
SHUTDOWN_DRAIN_MS=2500
# Reconciler DB <-> S3: never touches pending rows / unreferenced objects younger than grace.
RECONCILE_GRACE_SECONDS=900
RECONCILE_INTERVAL_SECONDS=300
# Lab5: stats port, worker replicas/limits, pipeline and retry tuning.
LB_STATS_PORT=8404
WORKER_REPLICAS=2
WORKER_CPUS=1
WORKER_MEMORY=768m
PIPELINE_VERSION=1
JOB_RETRY_BASE_MS=2000
JOB_REPUBLISH_SECONDS=600
# Test stand only: an upload named failpoint-<point>.png kills the process once at that point (see REPORT.md).
FAILPOINTS=0
# Lab6: OpenTelemetry (SDK api/worker → Collector). service.name задаёт compose.yaml у каждого сервиса:
# messenger-api и messenger-worker; OTEL_SERVICE_NAME ниже — имя API для запуска вне compose.
OTEL_SERVICE_NAME=messenger-api
# Worker must set a distinct service.name.
OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
# true — приложение без telemetry (сравнение/отладка); стек наблюдаемости при этом продолжает работать.
OTEL_SDK_DISABLED=false
# Grafana на 127.0.0.1 (логин admin, пароль — secrets/grafana_admin_password).
GRAFANA_PORT=3000
+12
View File
@@ -0,0 +1,12 @@
# Node 24 исполняет .ts напрямую (type stripping), отдельной сборки нет; типы проверяет `npm run typecheck`.
FROM node:24.22.2-alpine3.24
WORKDIR /app
ENV NODE_ENV=production
COPY package.json package-lock.json ./
RUN npm ci --omit=dev && npm cache clean --force
COPY src ./src
USER node
EXPOSE 8080
# node работает как PID 1 и сам обрабатывает SIGTERM (graceful shutdown в src/main.ts).
# --import подключает OpenTelemetry SDK до загрузки приложения (src/telemetry.ts); migrate/s3-init/reconcile без него.
CMD ["node", "--import", "./src/telemetry.ts", "src/main.ts"]
+482 -16
View File
@@ -1,37 +1,503 @@
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Морару С. С., БПИ2303
- Целевая оценка: **5**, трек 2 «SLO и обнаружение инцидентов»
- Commit/PR: ветка `solution/bpi2303-moraru` (fork `s.s.moraru/mtusi2026lab6` и PR — при публикации)
- Источники: OpenTelemetry JS (`@opentelemetry/sdk-node` 0.223.0, `api` 1.9.1, `api-logs` 0.223.0, `core` 2.12.0,
instrumentation `http` 0.223.0, `pg` 0.76.0, `aws-sdk` 0.78.0, `runtime-node` 0.36.1), OpenTelemetry Collector
contrib 0.163.2, Prometheus 3.15.1, Loki 3.7.9, Tempo 2.10.10, Grafana 13.2.5, k6 1.8.2; база — lab5 (Node.js 24,
`pg` 8.23.1, `@aws-sdk/client-s3` 3.1152.0, `amqplib` 2.2.0, `sharp` 0.35.5, PostgreSQL 18, RabbitMQ 4.3, SeaweedFS 4.48,
HAProxy 3.2). Документация: [Collector configuration](https://opentelemetry.io/docs/collector/configuration/),
[Context propagation](https://opentelemetry.io/docs/concepts/context-propagation/),
[W3C Trace Context](https://www.w3.org/TR/trace-context/), семантические конвенции OpenTelemetry (HTTP, database,
messaging), [Prometheus histograms](https://prometheus.io/docs/practices/histograms/),
[Grafana provisioning](https://grafana.com/docs/grafana/latest/administration/provisioning/), Google SRE Workbook,
гл. 5 «Alerting on SLOs» (multiwindow, multi-burn-rate alerts).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Engine + Compose v2 (проверено Docker 29.8.2, Compose 5.5.0, OrbStack), Python 3.9+ (тесты),
OpenSSL. Образы закреплены версией, сторонние — и digest:
| Роль | Сервис | Образ | Volume | Сеть / порт | Лимит |
| --- | --- | --- | --- | --- | --- |
| LB | `lb` | `haproxy:3.2.26-alpine@sha256:58938405…` | — | frontend, backend; `127.0.0.1:${LB_PORT}`, stats `127.0.0.1:${LB_STATS_PORT}` | 1 CPU, 128 MiB |
| API ×2, worker ×2, migrate, s3-init, reconciler | `api`, `worker`, … | `messenger-lab6-app:dev` (сборка, `node:24.22.2-alpine3.24`) | — | backend | api 1 CPU/256 MiB, worker 1 CPU/768 MiB |
| БД | `postgres` | `postgres:18.6-alpine@sha256:10a5c69a…` | `pgdata` | backend | 2 CPU, 1 GiB |
| Брокер | `rabbitmq` | `rabbitmq:4.3.6-alpine@sha256:6931816a…` | `rabbitmq-data` | backend | 1 CPU, 512 MiB |
| S3 | `seaweedfs`, `s3` | `chrislusf/seaweedfs:4.48@sha256:4e61d15f…` | `s3data` | storage (+ backend у шлюза) | 1 CPU, 512/768 MiB |
| Collector | `otel-collector` | `otel/opentelemetry-collector-contrib:0.163.2@sha256:7f22d2a6…` | — (очередь в памяти) | backend, telemetry | 1 CPU, 256 MiB |
| Метрики + alert rules | `prometheus` | `prom/prometheus:v3.15.1@sha256:fa330227…` | `prometheus-data` | telemetry | 1 CPU, 512 MiB |
| Логи | `loki` | `grafana/loki:3.7.9@sha256:0db216b6…` | `loki-data` | telemetry | 1 CPU, 384 MiB |
| Трассы | `tempo` | `grafana/tempo:2.10.10@sha256:12b0820f…` | `tempo-data` | telemetry | 1 CPU, 512 MiB |
| UI | `grafana` | `grafana/grafana:13.2.5@sha256:9f7aa1e1…` | `grafana-data` | frontend, telemetry; `127.0.0.1:${GRAFANA_PORT}` | 0.5 CPU, 256 MiB |
| Нагрузка (вне стенда) | — | `grafana/k6:1.8.2@sha256:00fdcebа…` | — | frontend стенда | 2 CPU |
Полные digest — в `compose.yaml` и `scripts/load.sh`. Сеть `telemetry` — `internal`: Prometheus, Loki и Tempo на хост
не опубликованы, снаружи доступна только Grafana (на 127.0.0.1).
```sh
scripts/init-secrets.sh # .env из .env.example, secrets/ (вне Git): как в lab5 +
# secrets/grafana_admin_password (пароль admin Grafana)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait # хранилища → migrate, s3-init → api ×2, worker ×2,
# reconciler → lb; otel-collector, prometheus, loki, tempo, grafana
python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt
make check && make validate PYTHON=.venv/bin/python
make test BASE_URL=http://localhost:8096 # LB на 127.0.0.1:${LB_PORT:-8080}
python3 student-tests/telemetry_check.py --base-url http://localhost:8096 --grafana http://localhost:3096
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8096
python3 student-tests/telemetry_history.py --grafana http://localhost:3096 --trace-id <trace до перезапуска> --before <unix-время>
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://localhost:8096 && docker compose start api
scripts/check-s3-security.sh
docker run --rm -v "$PWD/infra/prometheus:/etc/prometheus:ro" --entrypoint promtool prom/prometheus:v3.15.1 \
test rules /etc/prometheus/tests/alerts.test.yml # unit-тесты alert rules (5 сценариев)
RATE=20 DURATION=10m scripts/load.sh # нагрузка k6 (open model) изнутри сети стенда
python3 research/campaign.py run --out evidence/track2 # нагрузка + 6 ограниченных отказов по расписанию (~22 мин)
python3 research/campaign.py analyze --out evidence/track2 # разбор только по сохранённым наблюдениям
python3 research/timeline.py --out evidence/track2 --metric api # график: доли 5xx, SLI 1h/6h, firing alerts
python3 research/timeline.py --out evidence/track2 --metric ready # то же для времени до ready
docker compose stop # безопасная остановка; удаление учебных данных: docker compose down -v
```
Grafana: `http://127.0.0.1:${GRAFANA_PORT}`, пользователь `admin`, пароль — файл `secrets/grafana_admin_password`
(регистрация и анонимный доступ выключены). Datasources (Prometheus, Loki, Tempo) и dashboard «Messenger lab6»
(папка Messenger) загружаются provisioning-ом из `infra/grafana/` при старте — вручную ничего не создаётся; правка
dashboard — в `infra/grafana/build_dashboard.py`, затем `python3 infra/grafana/build_dashboard.py`.
Типы: `npm ci && npm run typecheck`. На стенде автора заняты 8080–8095, в `.env` стоят `LB_PORT=8096`,
`LB_STATS_PORT=8416`, `GRAFANA_PORT=3096`; все проверки ниже запускались с этими портами.
Телеметрию можно выключить без пересборки: `OTEL_SDK_DISABLED=true` в `.env` (приложение работает, стек остаётся).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ─► lb (HAProxy) ─► api ×2 ─► postgres, s3, rabbitmq ─► worker ×2 (бизнес-часть — как в lab5)
│ :8404/metrics │ OTLP/HTTP: traces, metrics, logs │ OTLP/HTTP
│ ▼ ▼
└──── scrape ─► otel-collector ◄── scrape rabbitmq:15692/metrics/detailed, собственные метрики :8888
│ memory_limiter → redaction → batch → ограниченная очередь + retry
├─ traces ─► tempo (OTLP gRPC) volume tempo-data, хранение 7 дней
├─ logs ───► loki (OTLP HTTP /otlp) volume loki-data, 7 дней
└─ metrics ► prometheus (OTLP receiver) volume prometheus-data, 15 дней / 1 GB;
правила SLO и alerts
grafana (127.0.0.1:3096) ── datasources Prometheus / Loki / Tempo, dashboard из provisioning
```
**Из lab5 перенесено без изменений**: весь API lab1–5 и контракт, HAProxy, PostgreSQL, SeaweedFS, RabbitMQ (quorum
queue, publisher confirms), transactional outbox с relay/sweeper в API, worker с арендой и fencing, reconciler,
скрипты `init-secrets`, `restart`, `stop-one`, `check-s3-security`. Валидатор доработан по замечаниям к lab4 (как в lab4): PNG — тип фильтра каждой строки только 0–4 и длина PLTE; JPEG — заголовки и таблицы проверяются так же, как в libjpeg-turbo (8 бит, 1/3/4 компонента, прореживание, DQT/DHT для каждого скана, параметры SOS, непустой скан). Файлы с фильтром 5 и JPEG без DQT/DHT и данных скана → 415. **Добавлено/изменено**:
- `src/telemetry.ts` — OpenTelemetry SDK, загружается до приложения (`node --import ./src/telemetry.ts src/main.ts`
в api и worker; migrate/s3-init/reconciler без SDK). `src/otel.ts` — tracer, meter, структурный лог, перенос
контекста; без SDK всё в нём no-op, поэтому `OTEL_SDK_DISABLED=true` оставляет рабочее приложение.
- Все `console.*` заменены на `log(level, event, message, attrs)`: JSON-строка в stdout (docker logs) и OTLP-запись
в Loki с `trace_id`/`span_id` активного span.
- Миграция `004_trace_context.sql`: в `outbox` колонки `traceparent`, `tracestate`; поля сообщения брокера
`traceparent`/`tracestate` (уже разрешены `contracts/jobs.schema.json`).
- Метрики заданий и очереди (`src/jobs/metrics.ts`, `relay.ts`, `worker.ts`), процессные CPU/RSS.
- Compose: `otel-collector`, `prometheus`, `loki`, `tempo`, `grafana`, сеть `telemetry` (internal), 4 volume,
секрет `grafana_admin_password`; конфиги в `infra/otel`, `infra/prometheus`, `infra/loki`, `infra/tempo`,
`infra/grafana`; runbook — `infra/runbooks.md`.
- `start_period` healthcheck API — 60 с: инициализация SDK (загрузка instrumentations через ESM-hook) на занятом
хосте растягивает старт реплики до ~25 с; успешная проверка всё равно делает контейнер healthy сразу.
### Назначение хранилищ
| Хранилище | Что хранит | На какой вопрос отвечает | Индекс / кардинальность |
| --- | --- | --- | --- |
| Prometheus | числовые ряды: счётчики, gauge, histogram buckets; результаты recording rules; состояние alerts (`ALERTS`) | «сколько, как часто, насколько медленно, растёт ли» по всей системе; SLO и alerts | каждая комбинация labels — отдельный ряд, поэтому только низкокардинальные labels |
| Loki | структурные логи (события) | «что именно случилось» с конкретным запросом/заданием: событие, `error.type`, `request_id` | в индексе 3 label: `service_name`, `service_instance_id`, `deployment_environment_name`; `event`, `request_id`, `trace_id`, `span_id`, `error.type`, `severity_text` — structured metadata (не индекс) |
| Tempo | trace: дерево spans одного запроса/задания с длительностями и атрибутами | «где тратится время и где ошибка» по цепочке API → БД/S3 → брокер → worker | поиск по trace_id и TraceQL; хранение блоками без индекса по атрибутам |
| Collector | ничего долговременно | приём OTLP и scrape, ограничение памяти, маскирование, batching, retry, маршрутизация | очередь экспортёра в памяти (до 20 000 элементов) |
| Grafana | только свою БД (пользователь, состояние provisioning) | интерфейс и запросы к трём источникам, переходы лог ↔ trace | — |
### Сигналы: соответствие `contracts/observability.md`
Имена — как в Prometheus после перевода OTLP (`translation_strategy: UnderscoreEscapingWithSuffixes`: точки → `_`,
единица и `_total` в суффиксе). Resource attributes: `service.name` (`messenger-api` / `messenger-worker`, из
`OTEL_SERVICE_NAME`), `service.version` (из `package.json`, 6.0.0), `service.instance.id` (hostname контейнера =
`X-Instance-Id`), `deployment.environment.name=lab`; в Prometheus они становятся `job`, `instance` и `target_info`,
в Loki — индексными labels.
| Сигнал контракта | Источник | Имя | Измерения | Единица |
| --- | --- | --- | --- | --- |
| HTTP requests | instrumentation-http (стабильная semconv) | `http_server_request_duration_seconds_count` | `http_request_method`, `http_route` (шаблон), `http_response_status_code` (класс — `label_replace`/regex) | запросы |
| HTTP duration | там же | `http_server_request_duration_seconds_bucket` | те же; границы 5 мс…10 с (14 buckets) | секунды |
| Jobs processed / failed | `src/jobs/metrics.ts` | `messenger_job_duration_seconds_count` | `job_type=attachment.process.v1`, `outcome` (done, retry, failed, noop, discarded, invalid, error) | задания |
| Job processing duration | там же | `messenger_job_duration_seconds_bucket` | `job_type`, `outcome`; 0.05…60 с | секунды |
| API/worker logs | `log()` → OTLP → Loki | поля `timestamp`, `severity_text`, `service_name`, `event`, `trace_id`, `span_id` (+ `request_id`, `error.type`, `messenger.job.*`) | — | — |
| API/worker traces | instrumentation http/pg/aws-sdk + свои spans | SERVER `POST /api/v1/chats/{chat_id}/attachments`, CLIENT `pg.query:*`, `pg-pool.connect`, `S3.*`, PRODUCER `publish attachments`, CONSUMER `process attachments.process`, INTERNAL `claim job`, `render variants`, `commit result` | статус ERROR, `messenger.job.outcome` | длительность span |
| Queue depth / oldest job age | gauges relay (из таблицы `jobs`, источник истины) + RabbitMQ | `messenger_jobs_backlog{state}`, `messenger_outbox_pending`, `messenger_jobs_oldest_age_seconds{queue}`, `rabbitmq_detailed_queue_messages_ready/unacked`, `rabbitmq_detailed_queue_consumers` | `queue`, `state` | задания / секунды |
| DB pool | instrumentation-pg | `db_client_connection_count{db_client_connection_state=idle\|used}`, `db_client_connection_pending_requests`, `db_client_connection_max`, `db_client_operation_duration_seconds` | `db_client_connection_pool_name=postgres:5432/messenger` | соединения / секунды |
| Worker saturation | `worker.ts` | `messenger_worker_busy`, `messenger_worker_capacity` (= prefetch) | `instance` | задания |
| Process CPU/RAM | `telemetry.ts`, runtime-node | `process_cpu_time_seconds_total{cpu_mode}`, `process_memory_usage_bytes`, `nodejs_eventloop_delay_p99_seconds` | `job`, `instance` | секунды CPU / байты / секунды |
| upload → publish → consume → S3/DB | W3C `traceparent`/`tracestate` через outbox и сообщение | один trace: SERVER → PRODUCER → CONSUMER → S3/SQL | parent-child | — |
| End-to-end time to ready | worker при фиксации ready | `messenger_attachment_time_to_ready_seconds_bucket` | `outcome` (ready/failed), `error_type`; 0.5…600 с | секунды |
`X-Request-Id` пишется в атрибут server span `messenger.request_id` и в поле `request_id` логов: ответ клиента →
лог → trace. Health-запросы (`/health/*`, проверки HAProxy и Docker раз в секунду) не создают spans и метрик.
### Trace context через очередь (уровень 4)
1. Upload: server span API; в той же транзакции, что и задание, в строку `outbox` записывается `traceparent` текущего
контекста (`traceCarrier()`).
2. Relay (фоновый цикл, запускается в `ROOT_CONTEXT`, чтобы его SQL не попадал в trace запроса) для каждой строки
создаёт PRODUCER span `publish attachments` с родителем из `outbox.traceparent` и кладёт в сообщение уже его
контекст.
3. Worker создаёт CONSUMER span `process attachments.process` с родителем из сообщения: внутри — `claim job`,
`S3.GetObject`, `render variants`, `S3.PutObject` ×3, `S3.CopyObject`, `commit result` (SQL), `S3.DeleteObject`.
4. Повтор: новая строка outbox получает контекст CONSUMER span неудачной попытки → в том же trace
`publish#1 → process#1 (ERROR, retry) → publish#2 → process#2 (ready)`. Sweeper и `jobs replay` копируют контекст
последней строки outbox задания.
Выбрана связь parent-child, а не link: у задания ровно один инициатор (upload), и весь путь до ready читается одним
trace. Цена — длинный trace при многих повторах (не больше `JOB_MAX_ATTEMPTS=5` публикаций).
### Что не попадает в telemetry
- Тела запросов и ответов, заголовки (в том числе `Authorization`, cookie) instrumentation-http не записывает;
в `url.query` server span значения `filename` и `cursor` заменяются на `REDACTED`.
- SQL — только текст запроса с плейсхолдерами `$1…` (`enhancedDatabaseReporting: false`): ни текста сообщений, ни
хешей паролей, ни токенов. S3 spans — только операция и bucket, без ключей объектов. Байты изображений не
передаются никуда.
- В атрибутах логов — только технические поля (`request_id`, `messenger.job.id`, `messenger.attachment.id`,
`error.type`), без текста исключений с данными пользователя.
- Collector, процессор `redaction` — страховка: значения ключей вида `authorization|password|secret|token|cookie`
и строки `Bearer …`/`Basic …` маскируются до экспорта.
- В spans и логах остаются технические UUID (путь `url.path`, `messenger.attachment.id`): они нужны, чтобы найти
конкретный запрос и задание (runbook: поиск trace по id вложения); в labels метрик их нет — проверяется
автоматически (шаг 5 `telemetry_check.py`).
### Collector: ограничение памяти и недоступный backend (уровень 4)
`receivers: otlp (HTTP :4318), prometheus` → `processors: memory_limiter (200 MiB, spike 40 MiB; GOMEMLIMIT 180 MiB,
контейнер 256 MiB), redaction, batch (1024/2048, 2 с)` → `exporters: otlp_grpc/tempo, otlp_http/loki,
otlp_http/prometheus`. У каждого экспортёра `sending_queue` 20 000 элементов (sizer items, 2 consumers) и
`retry_on_failure` 1 → 10 с, не дольше 60 с; затем данные отбрасываются и считаются в
`otelcol_exporter_send_failed_*`, при полной очереди — `otelcol_exporter_enqueue_failed_*`; при нехватке памяти
memory_limiter отказывает в приёме (`otelcol_receiver_refused_*`). Собственные метрики Collector публикуются на
127.0.0.1:8888 и собираются им же (job `otel-collector`).
SDK: BatchSpanProcessor и BatchLogRecordProcessor — очередь 2048 записей, отправка раз в 1 с; метрики — раз в 10 с.
Экспорт асинхронный, запрос пользователя его не ждёт; при недоступном Collector SDK отбрасывает пачку.
### Конфигурация (`.env.example` → реальная)
Переменные lab5 используются как раньше. Новые: `OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318`,
`OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf`, `OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab`,
`OTEL_SDK_DISABLED` — передаются api и worker через `x-otel-env` в `compose.yaml`; `OTEL_SERVICE_NAME` задаётся у
каждого сервиса (`messenger-api`, `messenger-worker`), значение в `.env.example` — только для запуска вне compose.
Дополнительно в compose: `OTEL_PROPAGATORS=tracecontext`, `OTEL_METRIC_EXPORT_INTERVAL=10000`,
`OTEL_BSP_SCHEDULE_DELAY=1000`, `OTEL_BLRP_SCHEDULE_DELAY=1000`, `OTEL_NODE_EXPERIMENTAL_SDK_METRICS=true`
(метрики самого SDK: `otel_sdk_span_started_total`, очередь процессоров). `GRAFANA_PORT` — порт Grafana на 127.0.0.1.
## Dashboard «Messenger lab6»
`infra/grafana/dashboards/messenger.json` (генерируется `build_dashboard.py`), 29 панелей в 6 рядах; у каждой панели
задана единица (`fieldConfig.unit`). Квантили — `histogram_quantile` по сумме buckets всех реплик
(`sum by (le) (rate(..._bucket[$__rate_interval]))`), а не среднее или усреднение p99 реплик.
| Ряд | Панели (запрос → единица) |
| --- | --- |
| SLO и alerts | доступность у клиентов за 1 ч `1 - slo:api_error_ratio:rate1h` (%); остаток бюджета за 30 д; ready ≤ 30 с за 1 ч; burn rate API и time-to-ready по окнам 5m/30m/1h/6h (× бюджет); состояние alerts из `ALERTS` |
| API | RPS по `http_route`/методу (req/s); RPS по классу статуса (`label_replace` кода в `Nxx`); доля 5xx в метриках API и у клиентов (HAProxy) (%); p50/p95/p99 и p99 по маршрутам из `http_server_request_duration_seconds_bucket` (с); p99 SQL `db_client_operation_duration_seconds_bucket` по сервису (с) |
| Worker и задания | jobs/с по `outcome`; p50/p95/p99 обработки (done) (с); p50/p95/p99 времени до ready (с, порог 30 с); насыщение `busy/capacity` (%); backlog: `messenger_jobs_backlog`, outbox, RabbitMQ ready/unacked; возраст старейшего задания (с, порог 60 с) и consumers |
| Насыщение | пул PostgreSQL used/idle/ждут/max; CPU процессов `rate(process_cpu_time_seconds_total)` (доля ядра); RSS процессов и Collector (байты); event loop p99 (с) |
| Telemetry pipeline | принято/отправлено Collector (элементов/с); потери (send/enqueue failed, refused); очередь экспортёров и ёмкость |
| Логи и трассы | логи ERROR/WARN (Loki, `{service_name=~"messenger-.+"} \| severity_text=~"ERROR\|WARN"`); trace с ошибками (Tempo, `{ status = error }`) |
Связи между источниками: в Loki поле `trace_id` — ссылка на trace в Tempo; в Tempo у span — «Logs for this span»
(логи по `trace_id`) и ссылка на p99 HTTP этого сервиса в Prometheus (`tracesToMetrics`).
## SLO и alerts
**SLO-1, доступность API: 99.5 % за 30 дней.** SLI = 1 − 5xx / все ответы клиентам на HAProxy (frontend `public`).
4xx — ошибка клиента (неверный пароль, чужой чат), не сервиса. Бюджет 0.5 % ≈ 3.6 часа полного отказа в месяц;
99.5 %, а не 99.9 %, потому что стенд — один Docker-хост с одной БД без реплики, и плановый перезапуск БД
(`scripts/restart.sh`, ~50 с) уже съедает ~2 % месячного бюджета 99.9 %.
Почему SLI на LB, а не в метриках API: readiness API зависит от PostgreSQL, HAProxy проверяет её раз в секунду, и
при недоступной БД обе реплики за ~2 с выходят из ротации — дальше HAProxy отвечает 503 сам, а зависшие дольше 10 с
запросы получают 504 от LB. Процесс API этих ответов не видит. Проверено пробой (PostgreSQL на 0.05 CPU, 40 с):
в метриках API 101 ответ 5xx, у клиентов — 190. SLI в метриках API занизил бы именно самые тяжёлые отказы. Метрики
API остаются для диагностики (маршрут, код, реплика).
**SLO-2, время до ready: 99 % вложений становятся `ready` не позже 30 с после durable acceptance за 30 дней.**
Обычно это доли секунды (публикация relay + обработка); 30 с покрывают два повтора после временного сбоя (таймаут
S3 8 с + backoff 1–2 с, ещё 8 с + 2–4 с). Плохое событие — ready позже 30 с или `failed` по вине системы; `invalid_image` и
`unsupported_pipeline` — свойство файла и в SLI не входят. Событие пишется при завершении задания, поэтому полностью
остановленный worker SLI не видит, пока задания не завершатся, — этот случай закрывает `JobQueueLagGrowing`
(возраст старейшего задания в реальном времени).
**Alerts** (`infra/prometheus/rules/`; runbook — `infra/runbooks.md`, ссылка в аннотации `runbook_url`). Вычисление
раз в 10 с; доставка наружу не настроена — состояние pending/firing/resolved видно в Prometheus (серия `ALERTS`),
Grafana → Alerting и на dashboard.
| Alert | Условие | Окно | Порог | for | Severity |
| --- | --- | --- | --- | --- | --- |
| `ApiAvailabilityFastBurn` | доля 5xx у клиентов | 1h **и** 5m | > 14.4 × 0.5 % = 7.2 % | — | page |
| `ApiAvailabilitySlowBurn` | то же | 6h **и** 30m | > 6 × 0.5 % = 3 % | — | ticket |
| `ReadyLatencyFastBurn` | доля плохих вложений | 1h **и** 5m | > 14.4 × 1 % | — | page |
| `ReadyLatencySlowBurn` | то же | 6h **и** 30m | > 6 × 1 % | — | ticket |
| `ApiHighErrorRate` (простой порог, уровень 4) | доля 5xx у клиентов | 5m | > 5 % | 2m | warning |
| `JobQueueLagGrowing` (уровень 4) | `max by (queue) (messenger_jobs_oldest_age_seconds)` | мгновенно | > 60 с | 1m | page |
| `DbPoolSaturated` | `max by (job, instance) (db_client_connection_pending_requests)` | мгновенно | > 0 | 1m | warning |
| `TelemetryExportFailing` | `rate(otelcol_exporter_send_failed_*[5m]) > 0` или очередь экспортёра > 1000 | 5m | > 0 / > 1000 | 1m | warning |
Burn rate 14.4 за 1 ч = 2 % месячного бюджета за час (весь бюджет — за ~2 дня), 6 за 6 ч = 5 % за 6 часов. Короткое
окно (1/12 длинного) нужно для быстрого снятия: после восстановления доля за 1 ч ещё высока, а за 5 мин — уже нет.
Recording rules `slo:api_error_ratio:rate{5m,30m,1h,6h}`, `slo:ready_bad_ratio:rate{…}`, бюджет за 30 д — раз в 5 мин.
Unit-тесты правил (`infra/prometheus/tests/alerts.test.yml`, `promtool test rules` — SUCCESS) с полной 6-часовой
историей: всплеск 1 мин 100 % ошибок — burn-rate alerts молчат, простой порог срабатывает; 30 % ошибок в течение
часа — fast firing на 15-й минуте, slow на 37-й, fast снят через 4 мин после конца, slow — через 28 мин; 5 % ошибок
6 часов — только slow на 217-й минуте; time-to-ready 50 % плохих — fast на 18-й минуте; остановка worker — lag alert
pending через 2 мин (возраст > 60 с), firing ещё через 1 мин (`for: 1m`), снят после запуска worker.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke при включённой telemetry | `make check`, `make validate`, `make test` | PASS всех трёх (и повторно на финальной сборке) | `evidence/checks/check-validate-test.txt`, `smoke-final.txt` |
| Persistence (API, все хранилища, стек telemetry) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS за 54 с; `StartedAt` всех 17 контейнеров (включая one-shot migrate, s3-init) сменился | `evidence/checks/persistence.txt` |
| История telemetry после перезапуска | `student-tests/telemetry_history.py` | trace, его лог и 11 точек метрик API за 10 мин до перезапуска читаются после | `evidence/checks/telemetry-history.txt` |
| Failover | `make test-failover` ×2 | PASS: остановлены api-2, затем api-1; 0 неудачных попыток, запись восстановилась через 2.9 и 4.9 с | `evidence/checks/failover-1.txt`, `failover-2.txt` |
| Возможности lab5 сохранены | `student-tests/worker_outage.py` | PASS: upload при остановленном worker пережил рестарт API и брокера, ready через 1.3 с после старта worker | `evidence/checks/worker-outage.txt` |
| Валидатор вложений (замечания к lab4) | `student-tests/attachments.py` | PASS: 43 случая upload, 5xx нет; PNG с фильтром строки 5, JPEG 27 байт без DQT/DHT и данных скана, JPEG без DQT → 415 | `evidence/checks/attachments.txt` |
| S3 по-прежнему приватен; опубликованы только grafana и lb | `scripts/check-s3-security.sh` | PASS | `evidence/checks/s3-security.txt` |
| Ур. 3: OTLP из api и worker, RED API, jobs, логи и реальные trace | `student-tests/telemetry_check.py` шаги 1–3 | trace с `traceparent` клиента; server span с шаблоном маршрута, `service.instance.id = X-Instance-Id`; лог с тем же `trace_id`/`span_id`; 404 → лог по `request_id` → trace | `evidence/signals/telemetry-check.txt` |
| Ур. 3: секреты/контент не экспортируются, labels низкой кардинальности | шаги 5–6 | пароль, session token, текст сообщения, имя файла не найдены ни в trace/логах, ни во всём Loki за 30 мин; в labels метрик нет UUID и id; `http_route` — только шаблоны OpenAPI | там же |
| Ур. 3: импортируемый dashboard | шаг 7 | dashboard из provisioning, все запросы Prometheus/Loki/Tempo находят данные (пуста только панель потерь telemetry: за последние 15 мин потерь не было) | там же |
| Ур. 4: upload → publish → consume → S3/DB, включая retry | шаги 3–4 | 39 spans одного trace; при «зависшем» S3 — `publish#1 → process#1 (ERROR, retry) → publish#2 → process#2 (ready)` | там же |
| Ур. 4: alerts проверены искусственным отказом | `promtool test rules`; `research/campaign.py` | SUCCESS; worker остановлен — `JobQueueLagGrowing` firing через 3:10, resolved через 0:36 после запуска; БД замирает — `ApiHighErrorRate` и `ApiAvailabilityFastBurn` firing через 2:30 и 2:50, resolved через 4:20 после восстановления | `evidence/track2/summary.md`, `timeline-*.svg` |
| Ур. 4: остановка хранилища telemetry | фазы telemetry-backends и collector-down | при остановленных Tempo и Loki 2400 ответов, все 2xx; очередь Collector до 19 368 из 20 000, RSS ≤ 121 MiB, потеряно 5.8 % spans; `TelemetryExportFailing` firing через 1:20, resolved через 4:59 | там же |
| Ур. 4: разбор инцидентов | `research/campaign.py analyze` | три инцидента с шагами диагностики — раздел «Инциденты» | там же |
| Трек 2 | `research/campaign.py run/analyze`, `research/timeline.py` | раздел «Трек 2» | `evidence/track2/` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Инциденты (уровень 4)
## Эксперименты и отказы
Три инцидента воспроизведены в одном прогоне кампании трека 2 (30.10.2026, 22:13–22:36 UTC; расписание и методика —
в разделе трека) под постоянной нагрузкой k6 20 итераций/с. Числа — `evidence/track2/summary.md` (`summary.json`),
графики — `evidence/track2/timeline-api.svg` и `timeline-ready.svg`. Время — мин:с от начала отказа, снятие alert — от
конца отказа. Диагностика — по `infra/runbooks.md` (ссылка в аннотации `runbook_url` каждого alert).
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Инцидент 1. Остановлен worker: вложения не становятся ready
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
Отказ: `docker compose stop worker` (обе реплики) на 6:02, поток загрузок ≈ 1/с не прерывается.
- **Клиенты.** Upload по-прежнему 202: приём durable (строка в БД и outbox), публикация в RabbitMQ не зависит от
worker. Вложения остаются `pending`; 5xx от самого отказа нет.
- **Обнаружение.** `JobQueueLagGrowing`: pending через 2:10, firing через 3:10, снят через 0:36 после запуска worker.
Первая минута остановки совпала с замороженной БД (фаза spike): новых заданий не было, поэтому от первого
незабранного задания до firing прошло ≈ 2:10 = порог 60 с + `for: 1m` + шаг правил 10 с. Возраст старейшего задания
дошёл до 297 с, backlog — до 282 заданий, подписчиков очереди — 0.
- **SLO времени до ready** во время остановки ничего не видел: событие SLI пишется при завершении задания, завершений не
было (burn 5m = 0). Сработал только после запуска worker: backlog разобран меньше чем за минуту, но из 417 вложений,
ставших ready за 3 мин, 282 (68 %) ждали дольше 30 с (до ~6 мин). `ReadyLatencyFastBurn` — firing через 0:38 после
запуска, снят через 5:38; `ReadyLatencySlowBurn` — тогда же и до конца прогона (короткая история, см. трек 2).
- **Путь к причине** (runbook `job-queue-lag`): (1) панель «Возраст старейшего задания» — растёт линейно, линия
consumers = 0 → (2) `docker compose ps -a worker` — обе реплики `Exited`. Причина найдена за два шага;
восстановление — `docker compose start worker` (или `up -d --no-deps worker`), alert снят через 36 с.
### Инцидент 2. Медленная или недоступная БД против медленного обработчика
Отказы: PostgreSQL заморожен (`docker compose pause`) на 60 с (spike) и на 25 с каждые 60 с в течение 5 мин
(api-degradation); отдельно api-1 ограничен 0.1 CPU на 2 мин (`docker update --cpus 0.1`, handler-slow).
| Сигнал | БД заморожена 1 мин | БД замирает 25 с из 60, 5 мин | api-1 на 0.1 CPU, 2 мин |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| 5xx у клиентов (HAProxy) | 1177 из 1806 ответов за 90 с; за 1 мин — до 100 % | в среднем 41.8 % (2509) | ≤ 0.4 % |
| 5xx в метриках API | 64 — остальные 95 % ответил сам LB | 6.6 % (247) | 0.1 % |
| p99 API | 10 с у обеих реплик (таймаут LB → 504) | 10 с у обеих | api-1 5.0 с, api-2 0.65 с |
| Задержка event loop p99 | 0.02–0.03 с | ≤ 0.1 с | **api-1 7.3 с**, api-2 0.07 с |
| CPU процесса API (доля ядра) | 0.05–0.06 | ≤ 0.09 | api-1 0.089 при лимите 0.1 |
| Пул: ждут соединения | 0 — реплики вне ротации, запросы до API не доходят | до 11 (сумма двух реплик) | api-1 до 7 (8 из 8 заняты), api-2 0 |
| p99 SQL | 0.03 с — зависшие запросы не завершились и в histogram не попали | API 1.0 с, worker 0.37 с | api-1 0.62 с |
| Медленные trace (> 300 мс), медиана | 2004 мс, из них ожидание `pg-pool.connect` 2001 мс | 2001 мс, из них ожидание пула 1999 мс | 898 мс: `pg.query` 600 мс, «своё» время 4 мс; 18 из 19 — api-1 |
| ERROR/WARN в логах | `http.dependency_unavailable` 63 (`error.type=Error` — таймаут пула 2 с), `sweeper.error` 24, `relay.db_unavailable` 2 | то же: 303 / 46 / 4 | 3 |
| Alerts | `ApiHighErrorRate` 2:30; fast burn — нет (всплеск короткий) | `ApiHighErrorRate` 2:30, `ApiAvailabilityFastBurn` 2:50 | нет (`DbPoolSaturated` только pending) |
**Путь к причине для БД** (runbook `api-availability-burn` → `db-pool-saturated`), фаза api-degradation:
(1) панель «Доля 5xx»: линия «у клиентов (HAProxy)» 42 % намного выше линии «в метриках API» 7 % — отвечает сам LB,
реплики выходят из ротации (`haproxy_backend_active_servers` и `/stats`: 0 из 2 во время каждой паузы) → (3) логи `http.dependency_unavailable`,
`error.type=Error` (таймаут ожидания пула) → (4) trace: 2 с в `pg-pool.connect` → `db-pool-saturated`: (1) event loop и CPU
обеих реплик в норме — дело не в процессе → (2) `docker compose ps postgres` — `paused`. Четыре шага.
**Медленный обработчик.** Alert не сработал (5xx нет), симптом — p99 api-1 на dashboard. Trace здесь **обманывает**:
время сидит в `pg.query` и `pg-pool.connect`, потому что span заканчивается в callback, а callback ждёт занятый event
loop. Первая версия runbook отправила бы в БД («медленный handler — длинный SERVER span при коротких дочерних»).
Различают другие сигналы: задержка event loop в секундах и CPU у лимита — только у одной реплики, медленные trace —
почти все с неё. Runbook исправлен по результату эксперимента: `db-pool-saturated` начинается с проверки event loop/CPU
реплики, `docker inspect -f '{{.HostConfig.NanoCpus}}'` показывает лимит 1e8 (0.1 CPU) — причина найдена.
### Инцидент 3. Недоступно хранилище telemetry, затем сам Collector
Отказы: `docker stop` Tempo и Loki на 121 с (telemetry-backends); `docker stop` otel-collector на 62 с (collector-down).
| Сигнал | Tempo и Loki остановлены | Collector остановлен |
| --- | --- | --- |
| Ответы клиентам | 2400 за время простоя, все 2xx | 1794 2xx и 6 5xx за 85 с вокруг простоя (ниже) |
| Очередь экспортёров Collector | `otlp_grpc/tempo` до 19 368 из 20 000, `otlp_http/loki` до 2 325 | — |
| Потери | отброшено 1102 из 19 023 принятых за простой spans (5.8 %) и 174 из 2723 log records — пачки, повторявшиеся дольше 60 с (`max_elapsed_time`); остальное дождалось в очереди и ушло после запуска; отказов memory_limiter — 0 | SDK API за фазу начал 19 095 spans; в Tempo за окно простоя 117 trace против 1021 в таком же окне baseline (11 %), все — из последних 16 с перед запуском (пачки, которые SDK ещё не отбросил); остальное потеряно |
| Память | RSS Collector ≤ 121 MiB (лимит контейнера 256 MiB, memory_limiter 200 MiB) | RSS API ≤ 100 MiB (в baseline 96 MiB): очередь SDK ограничена 2048 spans |
| Alert | `TelemetryExportFailing`: pending 0:20, firing 1:20, снят через 4:59 после запуска (окно `rate` 5 мин) | не сработал: метрики потерь отдаёт сам Collector — слепое пятно (ограничения) |
6 ответов 5xx при остановленном Collector с ним не связаны: в те же секунды у API и worker были таймауты соединения с
S3 и PostgreSQL (`s3.error` TimeoutError, `Connection terminated due to connection timeout`), а Tempo сам перезапустился
(exit 0, не OOM) — кратковременный сбой общего хоста. Экспорт telemetry асинхронный и в обработку запроса не входит.
**Путь к причине** (runbook `telemetry-export-failing`): (1) панели «Потери telemetry» и «Очередь экспортёров» —
растёт очередь `otlp_grpc/tempo` и `otlp_http/loki` → (2) `docker compose ps tempo loki` — `exited`. Остановка
Collector видна иначе: на всех панелях приложения разом пропадают данные, `docker compose ps otel-collector` — `exited`.
## Трек 2. SLO и обнаружение инцидентов
**Гипотезы.**
1. Простой порог (`ApiHighErrorRate`: > 5 % 5xx за 5 мин, держится 2 мин) срабатывает и на короткий всплеск, который
почти не тратит бюджет: минута полного отказа — 60 с из 216 мин месячного бюджета, 0.5 %. Для страницы это шум.
2. Multiwindow burn-rate alerts молчат на таком всплеске и срабатывают на длительной деградации тем раньше, чем
быстрее сгорает бюджет: при доле ошибок e fast burn сработает, когда доля за 1 ч превысит 7.2 %, то есть через
≈ 60 мин · 0.072 / e (при 28 % ошибок — ≈ 15 мин), а снимется через ≈ 5 мин после восстановления (короткое окно).
3. SLI на LB видит отказы, которых не видит SLI в метриках API (503/504 самого HAProxy).
4. SLI времени до ready считается по завершённым заданиям и поэтому запаздывает при остановленном worker; вовремя
ловит такой отказ только опережающий сигнал — возраст старейшего задания.
**Методика** (`research/campaign.py`, `research/k6/messenger.js`, `scripts/load.sh`). Одна непрерывная нагрузка k6
на всё время эксперимента: open model (constant-arrival-rate) 20 итераций/с — 65 % чтений истории (limit 20), 30 %
новых сообщений, 5 % загрузок PNG (≈ 1 вложение/с), 5 пар пользователей; k6 в контейнере в сети `frontend` стенда
через `lb:8080`. Отказы — по расписанию от начала (после 60 с прогрева), параллельными дорожками:
| Фаза | Начало, мин | Отказ | Длительность | Наблюдение после |
| --- | --- | --- | --- | --- |
| baseline | 0 | нет (ложные срабатывания) | 2.5 мин | — |
| spike — краткий всплеск | 2.5 | `docker compose pause postgres` | 60 с | 4.5 мин |
| worker-stop — инцидент 1 и деградация time-to-ready | 2.5 | `docker compose stop worker` | 6 мин | 5.5 мин |
| telemetry-backends — инцидент 3, часть 1 | 4 | `docker stop` tempo и loki | 2 мин | 5 мин |
| handler-slow — инцидент 2: медленный обработчик | 6.5 | `docker update --cpus 0.1` у api-1 | 2 мин | 1 мин |
| api-degradation — длительная деградация API | 9.5 | `pause postgres` на 25 с каждые 60 с | 5 мин | 4.5 мин |
| collector-down — инцидент 3, часть 2 | 19 | `docker stop` otel-collector | 1 мин | 1 мин |
Отказы, меняющие SLI доступности (всплеск и деградация), идут по очереди, всплеск — первым: так в его 1h-окне нет
ошибок деградации. Остановка worker, backend telemetry и медленный обработчик этот SLI не меняют и наложены на них;
трассы медленного обработчика пишутся уже после возврата Tempo. Остановка Collector рвёт все метрики (и SLI) и поэтому
последняя. Инцидент 2 «медленная/недоступная БД» — фазы spike и api-degradation (PostgreSQL заморожен), сравнение —
с handler-slow.
Отказы касаются только контейнеров `messenger-lab6` и снимаются в `finally` (unpause, start, прежний `--cpus`).
Разбор (`campaign.py analyze`) — только по сохранённым наблюдениям: интервалы pending/firing из серии `ALERTS`
(шаг 10 с = интервал вычисления правил), максимумы метрик в окне отказа, медленные (> 300 мс) trace API из Tempo
с разложением времени server span на ожидание пула, SQL, S3 и собственное время обработчика, число событий
ERROR/WARN в Loki. Время обнаружения — от начала отказа до firing; время снятия — от конца отказа до resolved.
Калибровка перед кампанией (по 40 с под той же нагрузкой): PostgreSQL на 0.05 CPU — 24 % ошибок, p99 7.2 с
(этот же прогон показал разницу SLI: 101 ответ 5xx в метриках API против 190 у клиентов); api-1 на 0.1 CPU —
0 ошибок, p99 2.7 с; worker на 0.05 CPU успевал за 1 загрузкой/с (изображения маленькие), поэтому деградация
time-to-ready сделана остановкой worker, а не ограничением CPU.
**Результаты** (один прогон 30.10.2026, 22:13–22:36 UTC; `evidence/track2/summary.md`, `summary.json`, `phases.json`,
`k6.json`; графики `timeline-api.svg` — доли 5xx у клиентов и в метриках API, SLI 1h/6h и firing; `timeline-ready.svg` —
то же для времени до ready). k6 за прогон: 26 590 запросов, open model держал 20 итераций/с без пропусков
(`dropped_iterations` 0), ошибки 14.4 % — в окнах отказов (в baseline 0); p50 4.7 мс, p95 95 мс, p99 2.0 с.
| Отказ | Что видели клиенты | Alert | firing после начала | снят после конца |
| --- | --- | --- | --- | --- |
| baseline, 2.5 мин | 0 % 5xx, p99 0.22 с | — | ни одного: ложных срабатываний нет | — |
| spike: БД заморожена 1 мин | 1177 ошибок из 1806 ответов за 90 с = 0.45 % месячного бюджета | `ApiHighErrorRate` | 2:30 | 4:49 |
| | | `ApiAvailabilityFastBurn` | не сработал: burn за 1 ч ≤ 7.6 × | — |
| | | `ApiAvailabilitySlowBurn` | 1:00 — артефакт короткой истории (ниже) | не снят до конца прогона |
| api-degradation: БД замирает 25 с из 60, 5 мин | 41.8 % 5xx | `ApiHighErrorRate` | 2:30 | 4:20 |
| | | `ApiAvailabilityFastBurn` | 2:50 | 4:20 |
| worker-stop: 6 мин | 5xx нет, вложения не становятся ready | `JobQueueLagGrowing` | 3:10 (2:10 от первого незабранного задания) | 0:36 |
| | | `ReadyLatencyFastBurn` | 6:40 — через 0:38 после запуска worker | 5:38 после запуска |
| | | `ReadyLatencySlowBurn` | 6:40 | не снят до конца прогона |
| handler-slow: api-1 на 0.1 CPU, 2 мин | p99 api-1 5 с, 5xx ≤ 0.4 % | — | ни одного (`DbPoolSaturated` только pending) | — |
| telemetry-backends: Tempo и Loki, 2 мин | 5xx нет | `TelemetryExportFailing` | 1:20 | 4:59 |
| collector-down: 1 мин | 5xx нет (6 из 1800 — сбой хоста) | `TelemetryExportFailing` | не сработал | — |
1. **Гипотеза 1 подтверждена.** Простой порог сработал на минутном всплеске (firing 2:30, горел 3:11), который стоил
0.45 % месячного бюджета, — так же, как на пятиминутной деградации (2:30). По нему эти инциденты не различить, а
страница на каждый такой всплеск — шум.
2. **Гипотеза 2 подтверждена для fast burn.** На всплеске fast burn молчал, на деградации сработал через 2:50 и снят
через 4:20 после восстановления (прогноз — ≈ 5 мин, окно 5m). Сработал раньше оценки 60 мин · 0.072 / 0.418 ≈ 10 мин:
к началу деградации в окне 1 ч уже были ошибки всплеска и калибровки (burn 7.5 ×), а ответов в нём — 37.7 тыс.,
как за 31 мин нагрузки, а не за час. **Slow burn сработал на всплеске — ложное срабатывание из-за короткой истории:** в окне 6 ч было
29.8 тыс. ответов — как за 25 мин нагрузки, а не ≈ 430 тыс. при 20 запросах/с. При полной истории те же 1177 ошибок дают burn за 6 ч
0.54 × и за 1 ч 3.27 × — ниже обоих порогов; это и проверяет unit-тест правил с полной 6-часовой историей (всплеск
1 мин: burn-rate alerts молчат). По той же причине slow burn не снялся до конца прогона.
3. **Гипотеза 3 подтверждена.** На всплеске HAProxy насчитал 1177 ответов 5xx, процесс API отдал 64: 95 % ошибок —
503/504 самого LB (реплики вне ротации). На деградации доля 5xx у клиентов — 41.8 %, в метриках API — 6.6 %.
SLI в метриках API занизил бы burn в 6 раз и не поднял бы fast burn вовсе (6.6 % < 7.2 %).
4. **Гипотеза 4 подтверждена.** Шесть минут остановленного worker SLI времени до ready не видел (burn 5m = 0): событие
пишется при завершении. Сработал через 0:38 после запуска, когда 282 из 417 вложений завершились позже 30 с.
Вовремя ловит только возраст старейшего задания (`JobQueueLagGrowing`, 3:10). При полной истории 282 плохих вложения —
7.8 % часового объёма (≈ 3600 при 1 загрузке/с) и 1.1 % месячного бюджета: fast burn не сработал бы, page даёт
только lag-alert — так и задумано.
**Ложные срабатывания.** В baseline — ни одного. Оба slow burn (API после всплеска, ready после остановки worker) —
артефакт короткого окна истории, объяснён выше. `DbPoolSaturated` не сработал ни разу: при замороженной БД пул пуст
(реплики вне ротации), при паузах 25 с из 60 и при медленном обработчике pending > 0 не держится минуту подряд — в
текущем виде он бесполезен (следующий шаг — доля времени с pending > 0 за 5 мин).
**Runbook.** От alert до причины — 2–4 шага по `infra/runbooks.md` (пути — в разделе «Инциденты»). Эксперимент нашёл
в runbook ошибку: при нехватке CPU у API trace выглядит как медленная БД (время в `pg.query`/`pg-pool.connect`, своё
время обработчика — 4 мс). Runbook исправлен: `db-pool-saturated` начинается с задержки event loop и CPU реплики, в
таблице «медленная БД / медленный handler» — значения из этого прогона.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Эксперимент короткий:** один прогон, фазы сокращены (отказы 1–6 мин, наблюдение 1–5.5 мин), часть фаз
наложена во времени, доверительных интервалов нет. В окнах 1 ч и 6 ч было лишь 25–31 мин нагрузки, поэтому
burn-rate alerts срабатывают раньше, чем при полной истории, slow burn дал ложное срабатывание на всплеске, а его
снятия (окно 30m) за время наблюдения не дождались; поведение при полной истории подтверждает только unit-тест
правил. Наложение фаз сдвинуло часть измерений: lag-alert сработал на минуту позже (при замороженной БД задания не
создавались), а окна метрик worker-stop и telemetry-backends в `summary.md` захватывают 5xx соседних фаз — числа
для этих отказов в разделе «Инциденты» посчитаны отдельно по точным интервалам. На том же хосте работали другие
стенды и сам k6 — абсолютные задержки шумные, выводы опираются на относительные изменения (×10 и больше).
- **Кампания прошла до шести исправлений по итогам ревью кода** (потеря аренды в worker, SLI для заданий с
исчерпанными повторами, таймаут запроса метрик очереди к БД, контекст ошибок пула, `created_at` при replay,
`OTEL_SDK_DISABLED`). Повлиять они могли только на метрики API во время заморозки БД (gauge очереди ждал БД без
таймаута); SLI доступности считается по HAProxy. Smoke и проверка сигналов повторены на финальной сборке.
- **Tempo один раз перезапустился сам** (exit 0, не OOM) в фазе collector-down — в те же секунды у API и worker были
таймауты соединений с S3 и PostgreSQL, то есть сбой общего хоста. Данные пережили перезапуск (trace всех фаз
разобраны после него); точную причину по логам уровня warn установить не удалось.
- **Стек наблюдаемости — один экземпляр без резерва.** Если недоступен Prometheus, alerts не вычисляются; нет
meta-мониторинга (watchdog-alert во внешнюю систему) и доставки (Alertmanager) — по заданию достаточно состояния
firing/resolved. Если упал LB, SLI доступности остаётся без данных, а не показывает 0 % — нужен alert на
`absent()` или внешний blackbox-probe. Так же `TelemetryExportFailing` не видит остановку самого Collector (его
метрики идут через Collector; проверено фазой collector-down) — нужен alert на отсутствие метрик Collector за
2 мин (`absent_over_time`) или прямой scrape Collector Prometheus-ом.
- **`DbPoolSaturated` в текущем виде бесполезен:** в кампании не сработал ни разу (трек 2). Следующий шаг — доля
времени с pending > 0 за 5 мин вместо `for: 1m` на мгновенном значении.
- **Очередь Collector в памяти:** при перезапуске Collector неотправленное теряется; SDK держит данные только в
ограниченной очереди (2048 spans) — при остановке Collector на 62 с дошли лишь trace последних 16 с (11 %).
Очередь экспортёра Tempo за 2 мин простоя заполнилась на 97 %: при более долгом простое Collector начнёт
отбрасывать данные уже при постановке в очередь (`enqueue_failed`), память при этом ограничена. Следующий шаг —
persistent queue (`file_storage`) и счётчик потерь на стороне SDK.
- **Трассы — 100 %:** на учебной нагрузке ~150 spans/с это дёшево; при реальном объёме нужен tail sampling
(сохранять ошибки и медленные, остальное — долю).
- **SLI time-to-ready считается по завершению:** полностью остановленный worker SLI не видит до запуска; это закрывает
`JobQueueLagGrowing`. Бюджет «30 дней» на стенде — вся доступная история.
- **Входящий `traceparent` клиента продолжается** (удобно для проверки); на публичной границе стоит начинать новый
trace и связывать его с клиентским через link.
- OpenTelemetry Logs API для JS — 0.x (экспериментальный), версии закреплены.
## Ответы на вопросы защиты
- **Лог, метрика и trace об одном инциденте.** Метрика отвечает «что и насколько» по всей системе дёшево и сразу
(доля 5xx выросла до 30 % на всех маршрутах, пул БД исчерпан) и запускает alert; trace — «где» в конкретном
запросе (2 с из 2 с в `pg-pool.connect` при нормальной задержке event loop — дело в БД; если event loop реплики
занят секундами, длинные дочерние spans — следствие нехватки CPU, это показал трек 2); лог — «что именно
случилось» (событие `http.dependency_unavailable`, `error.type=Error` — таймаут ожидания пула) и связывает ответ клиента
(`X-Request-Id`) с trace.
- **Почему `chat_id` в labels опасен.** Каждая уникальная комбинация labels — отдельный ряд Prometheus со своим
индексом и памятью в head-блоке. Число чатов растёт неограниченно: с `chat_id` × маршрут × статус × бакеты
histogram (15) рядов становятся миллионы, память и диск Prometheus исчерпываются, запросы замедляются. Поэтому
в labels — шаблон маршрута, а id — только в trace/логах.
- **Как очередь переносит причинную связь.** Контекст W3C (`traceparent`: trace-id, span-id родителя, флаги)
сохраняется вместе с заданием в outbox (та же транзакция), relay создаёт PRODUCER span с этим родителем и кладёт
его контекст в сообщение, worker извлекает его и делает CONSUMER span дочерним. Процесс и время разные, trace один.
- **Среднее и p99; усреднение p99 реплик.** Среднее прячет хвост: 1 % запросов по 5 с при остальных 10 мс даёт
среднее 60 мс, а пользователь каждого сотого запроса ждёт 5 с. Квантиль нельзя усреднять: p99 двух реплик 10 мс и
2.7 с (одна перегружена) в среднем дают 1.35 с, хотя реальный общий p99 определяется распределением всех
запросов. Правильно — сложить buckets histogram всех реплик и взять `histogram_quantile` от суммы.
+386
View File
@@ -0,0 +1,386 @@
# Клиент → lb (HAProxy) → api × N → postgres (метаданные, jobs, outbox) + s3 (SeaweedFS, staging/ оригинала).
# api (relay outbox) → rabbitmq (quorum-очередь attachments.process) → worker × M → s3 (originals/, variants/) + postgres.
# Наблюдаемость (lab6): api/worker → OTLP → otel-collector → prometheus (метрики) / loki (логи) / tempo (трассы) → grafana.
# Запуск: scripts/init-secrets.sh && docker compose --env-file .env up -d --build (см. REPORT.md)
name: messenger-lab6
x-app: &app
build: .
image: messenger-lab6-app:dev # уникальное имя: на общем Docker-host не перепутать с чужими стендами
networks: [backend]
logging: &logging
driver: json-file
options: { max-size: "10m", max-file: "3" } # stdout-логи ограничены; история логов — в Loki
# OpenTelemetry SDK api и worker (src/telemetry.ts). service.name задаётся у каждого сервиса отдельно.
# OTEL_SDK_DISABLED=true — приложение без telemetry (сравнение, отладка).
x-otel-env: &otel-env
OTEL_EXPORTER_OTLP_ENDPOINT: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://otel-collector:4318}
OTEL_EXPORTER_OTLP_PROTOCOL: ${OTEL_EXPORTER_OTLP_PROTOCOL:-http/protobuf}
OTEL_RESOURCE_ATTRIBUTES: ${OTEL_RESOURCE_ATTRIBUTES:-deployment.environment.name=lab}
OTEL_SDK_DISABLED: ${OTEL_SDK_DISABLED:-false}
OTEL_PROPAGATORS: tracecontext # W3C traceparent/tracestate; baggage клиентов не принимается
OTEL_METRIC_EXPORT_INTERVAL: "10000" # мс; окна rate() от 1 минуты
OTEL_BSP_SCHEDULE_DELAY: "1000"
OTEL_BLRP_SCHEDULE_DELAY: "1000"
OTEL_NODE_EXPERIMENTAL_SDK_METRICS: "true" # otel.sdk.*: сколько spans/логов SDK обработал и отбросил
x-s3-env: &s3-env
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
x-jobs-env: &jobs-env
DATABASE_URL_FILE: /run/secrets/database_url
BROKER_URL_FILE: /run/secrets/broker_url
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
PIPELINE_VERSION: ${PIPELINE_VERSION:-1}
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:-60}
JOB_RETRY_BASE_MS: ${JOB_RETRY_BASE_MS:-2000}
JOB_REPUBLISH_SECONDS: ${JOB_REPUBLISH_SECONDS:-600}
FAILPOINTS: ${FAILPOINTS:-0} # 1 только на тестовом стенде: файл failpoint-<точка>.png один раз роняет процесс
x-seaweedfs: &seaweedfs
image: chrislusf/seaweedfs:4.48@sha256:4e61d15fd35994cb1e43e1e553dff106794841fd9a99ade2fc8c8bfce4d7872d
restart: unless-stopped
stop_grace_period: 20s
services:
postgres:
image: postgres:18.6-alpine@sha256:10a5c69a83035ab5239f5620d708520e8b28f5aa1f2b20143e6024532edadfb5
command: ["postgres", "-c", "max_connections=200", "-c", "shared_buffers=256MB"]
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes: [pgdata:/var/lib/postgresql]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 2s
timeout: 2s
retries: 15
deploy:
resources:
limits: { cpus: "${DB_CPUS:-2}", memory: 1g }
stop_grace_period: 30s
restart: unless-stopped
networks: [backend]
# Хранилище SeaweedFS: master + volume + filer, данные в volume s3data. Только во внутренней сети storage:
# его HTTP-интерфейсы (master :9333, filer :8888, volume :8080) не требуют подписи S3 и недоступны даже из API.
seaweedfs:
<<: *seaweedfs
command: ["server", "-dir=/data", "-ip=seaweedfs", "-ip.bind=0.0.0.0", "-filer", "-master.volumeSizeLimitMB=1024"]
volumes: [s3data:/data]
healthcheck:
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:8888/"]
interval: 2s
timeout: 2s
retries: 30
start_period: 5s
deploy:
resources:
limits: { cpus: "1", memory: 512m }
networks: [storage]
# S3-шлюз — единственный путь к байтам: проверяет SigV4 и права identities (secrets/s3_identities.json).
# Встроенный IAM API, Iceberg и Lance выключены; порт не опубликован на хост.
s3:
<<: *seaweedfs
# concurrentUploadLimitMB: шлюз буферизует чанки (4 MiB) каждой загрузки; сверх лимита новые загрузки ждут,
# а не выводят шлюз за лимит памяти (эксперимент research/upload_memory.py: при 256m без лимита — OOM).
command: ["s3", "-filer=seaweedfs:8888", "-port=9000", "-config=/run/secrets/s3_identities",
"-iam=false", "-port.iceberg=0", "-port.lance=0", "-concurrentUploadLimitMB=256"]
secrets: [s3_identities]
depends_on:
seaweedfs: { condition: service_healthy }
healthcheck:
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:9000/healthz"]
interval: 2s
timeout: 2s
retries: 30
deploy:
resources:
limits: { cpus: "1", memory: 768m }
networks: [storage, backend]
# Одноразовые сервисы до старта реплик: схема БД (advisory lock) и bucket (повторный запуск ничего не меняет).
migrate:
<<: *app
command: ["node", "src/main.ts", "migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
restart: "no"
deploy:
resources:
limits: { cpus: "0.5", memory: 128m }
depends_on:
postgres: { condition: service_healthy }
s3-init:
<<: *app
command: ["node", "src/main.ts", "s3-init"]
environment: *s3-env
secrets:
- { source: s3_admin_access_key_id, target: s3_access_key_id }
- { source: s3_admin_secret_access_key, target: s3_secret_access_key }
restart: "no"
deploy:
resources:
limits: { cpus: "0.5", memory: 128m }
depends_on:
s3: { condition: service_healthy }
# Брокер: RabbitMQ, quorum-очередь на диске (volume rabbitmq-data), publisher confirms, ручной ack.
# hostname фиксирует имя узла rabbit@rabbitmq: данные в volume привязаны к нему и переживают пересоздание.
rabbitmq:
image: rabbitmq:4.3.6-alpine@sha256:6931816af1a943f471c038b278835d36692d55dec769232739296bb91b7de0f5
hostname: rabbitmq
volumes:
- rabbitmq-data:/var/lib/rabbitmq
- ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/conf.d/90-messenger.conf:ro
secrets: [rabbitmq_definitions]
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "check_port_connectivity"]
interval: 5s
timeout: 10s
retries: 30
start_period: 20s
deploy:
resources:
limits: { cpus: "1", memory: 512m }
stop_grace_period: 30s
restart: unless-stopped
networks: [backend]
api:
<<: *app
environment:
<<: [*s3-env, *jobs-env, *otel-env]
OTEL_SERVICE_NAME: messenger-api
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DB_POOL_MAX: ${DB_POOL_MAX:-8}
SHUTDOWN_DRAIN_MS: ${SHUTDOWN_DRAIN_MS:-2500}
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
secrets:
- database_url
- { source: broker_url_api, target: broker_url }
- { source: s3_api_access_key_id, target: s3_access_key_id }
- { source: s3_api_secret_access_key, target: s3_secret_access_key }
# rabbitmq не в depends_on: API принимает загрузки и без брокера, задания ждут в outbox.
depends_on:
migrate: { condition: service_completed_successfully }
s3-init: { condition: service_completed_successfully }
healthcheck:
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:8080/health/ready"]
interval: 2s
timeout: 2s
retries: 3
# Lab6: старт с OpenTelemetry SDK (загрузка instrumentations через ESM-hook) на занятом хосте — до ~25 с.
# Успешная проверка сразу делает контейнер healthy; start_period только прощает неудачи при старте.
start_period: 60s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: { cpus: "${API_CPUS:-1}", memory: "${API_MEMORY:-256m}" }
stop_grace_period: 15s
restart: unless-stopped # упавшая реплика поднимается сама; после `docker stop` остаётся остановленной
# Worker: отдельный процесс без HTTP, конкурирующие consumers одной очереди. WORKER_CONCURRENCY = prefetch =
# одновременных заданий на реплику; память ограничена контейнером, libvips — один поток, без кэша.
worker:
<<: *app
command: ["node", "--import", "./src/telemetry.ts", "src/main.ts", "worker"]
environment:
<<: [*s3-env, *jobs-env, *otel-env]
OTEL_SERVICE_NAME: messenger-worker
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-2}
secrets:
- database_url
- { source: broker_url_worker, target: broker_url }
- { source: s3_worker_access_key_id, target: s3_access_key_id }
- { source: s3_worker_secret_access_key, target: s3_secret_access_key }
depends_on:
migrate: { condition: service_completed_successfully }
s3-init: { condition: service_completed_successfully }
rabbitmq: { condition: service_healthy }
deploy:
replicas: ${WORKER_REPLICAS:-2}
resources:
limits: { cpus: "${WORKER_CPUS:-1}", memory: "${WORKER_MEMORY:-768m}" }
stop_grace_period: 15s # SIGTERM: consumer отменяется, текущие задания до 10 с, затем выход
restart: unless-stopped
# Периодическая сверка БД ↔ S3 с grace period (src/reconcile.ts). Свои S3-ключи: объекты + листинг bucket.
reconciler:
<<: *app
command: ["node", "src/main.ts", "reconcile", "--apply", "--every=${RECONCILE_INTERVAL_SECONDS:-300}"]
environment:
<<: *s3-env
DATABASE_URL_FILE: /run/secrets/database_url
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-900}
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:-86400}
secrets:
- database_url
- { source: s3_reconciler_access_key_id, target: s3_access_key_id }
- { source: s3_reconciler_secret_access_key, target: s3_secret_access_key }
depends_on:
migrate: { condition: service_completed_successfully }
s3-init: { condition: service_completed_successfully }
deploy:
resources:
limits: { cpus: "0.5", memory: 128m }
restart: unless-stopped
lb:
image: haproxy:3.2.26-alpine@sha256:5893840576071e6217cd52ebdcc14f454c6f7a631056fa6f4e0f40d3cac4215b
volumes: ["./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"]
ports:
- "127.0.0.1:${LB_PORT:-8080}:8080"
- "127.0.0.1:${LB_STATS_PORT:-8404}:8404" # статистика HAProxy для оператора, это не API
depends_on:
api: { condition: service_healthy }
deploy:
resources:
limits: { cpus: "${LB_CPUS:-1}", memory: 128m }
restart: unless-stopped
networks: [frontend, backend]
# ---------- Наблюдаемость (lab6). Конфиги — infra/otel, infra/prometheus, infra/loki, infra/tempo, infra/grafana.
# Collector — единственный компонент telemetry в сети backend: принимает OTLP от api/worker и скрейпит
# RabbitMQ и HAProxy; в хранилища пишет по сети telemetry. Ничего не публикуется на хост, кроме Grafana.
otel-collector:
image: otel/opentelemetry-collector-contrib:0.163.2@sha256:7f22d2a6748110ffb6a59bc0df448bccbf501cdb667d610ede4c61d3863d5849
volumes: ["./infra/otel/collector.yaml:/etc/otelcol-contrib/config.yaml:ro"]
environment:
GOMEMLIMIT: 180MiB # мягкий предел GC ниже лимита контейнера; жёсткий отказ приёма — memory_limiter
deploy:
resources:
limits: { cpus: "1", memory: 256m }
restart: unless-stopped
logging: *logging
networks: [backend, telemetry]
prometheus:
image: prom/prometheus:v3.15.1@sha256:fa3302279710be2f21a8301ec17a8b4f2301fd829bd113839b3b6b02b6f191a2
command:
- --config.file=/etc/prometheus/prometheus.yml
- --storage.tsdb.path=/prometheus
- --storage.tsdb.retention.time=15d
- --storage.tsdb.retention.size=1GB
- --web.enable-otlp-receiver
- --enable-feature=created-timestamp-zero-ingestion # новая серия счётчика начинается с 0: rate() видит первые ошибки
- --query.lookback-delta=1m # данные остановленной реплики перестают учитываться через минуту, а не через 5
volumes:
- ./infra/prometheus:/etc/prometheus:ro
- prometheus-data:/prometheus
healthcheck:
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:9090/-/ready"]
interval: 5s
timeout: 3s
retries: 20
deploy:
resources:
limits: { cpus: "1", memory: 512m }
stop_grace_period: 30s
restart: unless-stopped
logging: *logging
networks: [telemetry]
loki:
image: grafana/loki:3.7.9@sha256:0db216b630ae1f348a1584c67f3cead8b4c1fc839169a39501db664744158e28
command: ["-config.file=/etc/loki/loki.yaml"]
volumes:
- ./infra/loki/loki.yaml:/etc/loki/loki.yaml:ro
- loki-data:/loki
deploy:
resources:
limits: { cpus: "1", memory: 384m }
stop_grace_period: 30s
restart: unless-stopped
logging: *logging
networks: [telemetry]
tempo:
image: grafana/tempo:2.10.10@sha256:12b0820f13ffa10ce956b6e9acc3b03f3cffded99109be6cc09d106fe56e5d38
command: ["-config.file=/etc/tempo/tempo.yaml"]
volumes:
- ./infra/tempo/tempo.yaml:/etc/tempo/tempo.yaml:ro
- tempo-data:/var/tempo
deploy:
resources:
limits: { cpus: "1", memory: 512m }
stop_grace_period: 30s
restart: unless-stopped
logging: *logging
networks: [telemetry]
# Grafana: интерфейс и запросы к хранилищам; datasources и dashboard импортируются из Git (provisioning).
grafana:
image: grafana/grafana:13.2.5@sha256:9f7aa1e1e3246aade5792d35a738049f7f32f89cd51d1956cf426a4e86268a84
environment:
GF_SECURITY_ADMIN_USER: admin
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password
GF_USERS_ALLOW_SIGN_UP: "false"
GF_AUTH_ANONYMOUS_ENABLED: "false"
GF_SERVER_ROOT_URL: http://localhost:${GRAFANA_PORT:-3000}
GF_ANALYTICS_REPORTING_ENABLED: "false"
GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES: "false"
GF_PLUGINS_PREINSTALL_DISABLED: "true"
GF_NEWS_NEWS_FEED_ENABLED: "false"
secrets: [grafana_admin_password]
volumes:
- ./infra/grafana/provisioning:/etc/grafana/provisioning:ro
- ./infra/grafana/dashboards:/var/lib/grafana/dashboards:ro
- grafana-data:/var/lib/grafana
ports:
- "127.0.0.1:${GRAFANA_PORT:-3000}:3000"
healthcheck:
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:3000/api/health"]
interval: 5s
timeout: 3s
retries: 30
deploy:
resources:
limits: { cpus: "0.5", memory: 256m }
restart: unless-stopped
logging: *logging
networks: [frontend, telemetry]
networks:
frontend: {}
backend: { internal: true } # api, worker, postgres, rabbitmq и s3-шлюз недоступны с хоста и не имеют выхода наружу
storage: { internal: true } # внутренние компоненты SeaweedFS видит только s3-шлюз
telemetry: { internal: true } # collector → prometheus/loki/tempo ← grafana; приложение сюда не подключено
volumes:
pgdata: {}
s3data: {}
rabbitmq-data: {}
prometheus-data: {}
loki-data: {}
tempo-data: {}
grafana-data: {}
secrets:
database_url: { file: ./secrets/database_url }
postgres_password: { file: ./secrets/postgres_password }
s3_identities: { file: ./secrets/s3_identities.json }
s3_admin_access_key_id: { file: ./secrets/s3_admin_access_key_id }
s3_admin_secret_access_key: { file: ./secrets/s3_admin_secret_access_key }
s3_api_access_key_id: { file: ./secrets/s3_api_access_key_id }
s3_api_secret_access_key: { file: ./secrets/s3_api_secret_access_key }
s3_reconciler_access_key_id: { file: ./secrets/s3_reconciler_access_key_id }
s3_reconciler_secret_access_key: { file: ./secrets/s3_reconciler_secret_access_key }
s3_worker_access_key_id: { file: ./secrets/s3_worker_access_key_id }
s3_worker_secret_access_key: { file: ./secrets/s3_worker_secret_access_key }
rabbitmq_definitions: { file: ./secrets/rabbitmq_definitions.json }
broker_url_api: { file: ./secrets/broker_url_api }
broker_url_worker: { file: ./secrets/broker_url_worker }
grafana_admin_password: { file: ./secrets/grafana_admin_password }
+45
View File
@@ -0,0 +1,45 @@
$ python3 student-tests/attachments.py --base-url http://localhost:8096 # 2026-10-31
real JPEG + unicode filename 202 21 ms
PNG 9.90 MiB (noise 1860x1860) 202 201 ms
PNG ровно 40 000 000 px 202 95 ms
PNG 10.33 MiB > 10 MiB 413 payload_too_large 11 ms
10 MiB + 1 байт 413 payload_too_large 13 ms
PNG 40 006 400 px 413 payload_too_large 36 ms
pixel-bomb 30000x30000, файл 106 КБ 413 payload_too_large 50 ms
JPEG SOF 10000x10000 413 payload_too_large 18 ms
zip-bomb в IDAT (64 МБ при 100x100) 415 unsupported_media_type 165 ms
PNG: байт IDAT испорчен (CRC) 415 unsupported_media_type 21 ms
PNG: корректные CRC, мусор в zlib 415 unsupported_media_type 14 ms
PNG: данных меньше, чем пикселей 415 unsupported_media_type 11 ms
PNG обрезан 415 unsupported_media_type 14 ms
PNG + данные после IEND 415 unsupported_media_type 17 ms
PNG 1x1: фильтр строки 5 (допустимы 0–4) 415 unsupported_media_type 10 ms
JPEG 27 байт: без DQT/DHT и скана 415 unsupported_media_type 9 ms
JPEG без таблиц квантования DQT 415 unsupported_media_type 19 ms
JPEG обрезан (нет EOI) 415 unsupported_media_type 14 ms
PNG под видом image/jpeg 415 unsupported_media_type 21 ms
JPEG под видом image/png 415 unsupported_media_type 46 ms
GIF под видом image/png 415 unsupported_media_type 29 ms
SVG под видом image/png 415 unsupported_media_type 45 ms
Content-Type image/gif 415 unsupported_media_type 32 ms
Content-Type octet-stream 415 unsupported_media_type 25 ms
пустое тело 415 unsupported_media_type 10 ms
filename '../etc/passwd' 400 invalid_request 10 ms
filename 'a/b.png' 400 invalid_request 8 ms
filename 'a\\b.png' 400 invalid_request 6 ms
filename 'nul\x00.png' 400 invalid_request 6 ms
filename 'tab\t.png' 400 invalid_request 5 ms
filename 'line\n.png' 400 invalid_request 6 ms
filename 'c1\x85.png' 400 invalid_request 9 ms
filename '' 400 invalid_request 15 ms
filename ' ' 400 invalid_request 10 ms
filename 'xxxxxxxxxxxxxxxxxxxx' 400 invalid_request 7 ms
без filename 400 invalid_request 7 ms
chunked без Content-Length 400 invalid_request 5 ms
без действительной сессии 401 unauthorized 4 ms
посторонний грузит в чужой чат 404 not_found 4 ms
несуществующий чат 404 not_found 5 ms
chat_id не UUID 400 invalid_request 3 ms
обычный PNG 202 30 ms
PNG в другом чате 202 51 ms
PASS: 43 upload cases, ACL and message linking; no 5xx
+9
View File
@@ -0,0 +1,9 @@
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
$ make test BASE_URL=http://localhost:8096
python3 tests/smoke.py --base-url "http://localhost:8096"
PASS: lab6 public API scenario; infrastructure and grading evidence remain separate.
+11
View File
@@ -0,0 +1,11 @@
# replicas before
messenger-lab6-api-1 81757059610d running
messenger-lab6-api-2 71ee4d68b6e6 running
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://localhost:8096
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8096"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 2.942}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
# replicas after
messenger-lab6-api-1 81757059610d running
messenger-lab6-api-2 71ee4d68b6e6 exited
+11
View File
@@ -0,0 +1,11 @@
# replicas before (restored: docker compose start api)
messenger-lab6-api-1 81757059610d running
messenger-lab6-api-2 71ee4d68b6e6 running
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://localhost:8096
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8096"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 105, "failed_attempts": 0, "first_recovery_seconds": 4.884}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
# replicas after
messenger-lab6-api-1 81757059610d exited
messenger-lab6-api-2 71ee4d68b6e6 running
+42
View File
@@ -0,0 +1,42 @@
# before 2026-10-30T22:03:31Z
messenger-lab6-api-1 running started=2026-10-30T22:03:13.16572903Z
messenger-lab6-api-2 running started=2026-10-30T22:03:13.472982214Z
messenger-lab6-grafana-1 running started=2026-10-30T21:27:12.963076303Z
messenger-lab6-lb-1 running started=2026-10-30T21:27:49.144940174Z
messenger-lab6-loki-1 running started=2026-10-30T21:49:05.434203985Z
messenger-lab6-migrate-1 exited started=2026-10-30T22:03:25.18357094Z
messenger-lab6-otel-collector-1 running started=2026-10-30T21:49:04.841388966Z
messenger-lab6-postgres-1 running started=2026-10-30T21:27:02.601334894Z
messenger-lab6-prometheus-1 running started=2026-10-30T21:27:02.373327049Z
messenger-lab6-rabbitmq-1 running started=2026-10-30T22:03:17.333799174Z
messenger-lab6-reconciler-1 running started=2026-10-30T22:02:04.211864462Z
messenger-lab6-s3-1 running started=2026-10-30T21:27:38.005413897Z
messenger-lab6-s3-init-1 exited started=2026-10-30T22:03:25.701746746Z
messenger-lab6-seaweedfs-1 running started=2026-10-30T21:27:22.289141705Z
messenger-lab6-tempo-1 running started=2026-10-30T21:49:05.133731622Z
messenger-lab6-worker-1 running started=2026-10-30T22:03:29.390180094Z
messenger-lab6-worker-2 running started=2026-10-30T22:03:29.566901411Z
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8096
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8096"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
# after 2026-10-30T22:04:27Z
messenger-lab6-api-1 running started=2026-10-30T22:04:21.157055064Z
messenger-lab6-api-2 running started=2026-10-30T22:04:20.940382017Z
messenger-lab6-grafana-1 running started=2026-10-30T22:03:48.451183698Z
messenger-lab6-lb-1 running started=2026-10-30T22:04:26.884395625Z
messenger-lab6-loki-1 running started=2026-10-30T22:03:39.035816792Z
messenger-lab6-migrate-1 exited started=2026-10-30T22:04:18.354473742Z
messenger-lab6-otel-collector-1 running started=2026-10-30T22:03:39.13142939Z
messenger-lab6-postgres-1 running started=2026-10-30T22:03:38.38063198Z
messenger-lab6-prometheus-1 running started=2026-10-30T22:03:38.109558741Z
messenger-lab6-rabbitmq-1 running started=2026-10-30T22:03:39.316004195Z
messenger-lab6-reconciler-1 running started=2026-10-30T22:04:20.936750026Z
messenger-lab6-s3-1 running started=2026-10-30T22:04:17.090338152Z
messenger-lab6-s3-init-1 exited started=2026-10-30T22:04:19.79217583Z
messenger-lab6-seaweedfs-1 running started=2026-10-30T22:03:57.426716035Z
messenger-lab6-tempo-1 running started=2026-10-30T22:03:38.291222478Z
messenger-lab6-worker-1 running started=2026-10-30T22:04:20.931270603Z
messenger-lab6-worker-2 running started=2026-10-30T22:04:21.103570215Z
+30
View File
@@ -0,0 +1,30 @@
$ scripts/check-s3-security.sh
PASS анонимный GET объекта: 403
PASS анонимный LIST bucket: 403
PASS анонимный PUT объекта: 403
api GetObject own bucket: allowed
api ListObjectsV2 own bucket: denied (403 AccessDenied)
api CreateBucket other: denied (403 AccessDenied)
api PutObject other bucket: denied (403 AccessDenied)
api PutObject own bucket: allowed
api DeleteObject own bucket: allowed
reconciler GetObject own bucket: allowed
reconciler ListObjectsV2 own bucket: allowed
reconciler CreateBucket other: denied (403 AccessDenied)
reconciler PutObject other bucket: denied (403 AccessDenied)
reconciler PutObject own bucket: allowed
reconciler DeleteObject own bucket: allowed
PASS api GetObject: allowed
PASS api ListObjectsV2 (не нужен API): denied
PASS api CreateBucket: denied
PASS api PutObject в чужой bucket: denied
PASS reconciler ListObjectsV2: allowed
PASS reconciler CreateBucket: denied
PASS seaweedfs:8888 из контейнера api: unreachable
PASS seaweedfs:9333 из контейнера api: unreachable
PASS seaweedfs:8080 из контейнера api: unreachable
PASS filer по IP 192.168.228.2:8888 из контейнера api: unreachable
PASS сервисы с опубликованными портами: grafana lb
PASS повторный s3-init: bucket messenger-attachments: exists
PASS: bucket приватен, права минимальны, внутренние порты закрыты
exit=0
+3
View File
@@ -0,0 +1,3 @@
$ make test BASE_URL=http://localhost:8096
python3 tests/smoke.py --base-url "http://localhost:8096"
PASS: lab6 public API scenario; infrastructure and grading evidence remain separate.
+2
View File
@@ -0,0 +1,2 @@
$ python3 student-tests/telemetry_history.py --grafana http://localhost:3096 --trace-id 8fc9d84548b361b4a5bb788aff701bed --before 1793397811 # trace из telemetry-check.txt, записан до restart.sh (2026-10-30T22:03:31Z)
PASS история после перезапуска: trace 8fc9d84548b361b4a5bb788aff701bed (7 spans), 1 строк лога, 11 точек метрики API за 10 мин до перезапуска
+14
View File
@@ -0,0 +1,14 @@
$ python3 student-tests/worker_outage.py --base-url http://localhost:8096
0.8 s docker compose stop worker
0.9 s upload → 202 queued, attachment 5f65a400-9b2d-4582-be38-793474813edf
0.9 s сообщение с queued-вложением → 201, message 5cdc6020-756a-433c-9cb1-63e3068a8d78
0.9 s content и content?variant=thumbnail → 409 conflict
1.0 s другие сообщения без worker: POST 201, история 200
4.7 s job 164346fb-f5a9-41a5-af9e-13039146884a queued attempts=0; outbox опубликован (publisher confirm); очередь (messages, unacked, consumers) = (0, 0, 2)
9.2 s docker compose restart api (обе реплики, SIGTERM)
19.1 s docker compose restart rabbitmq; после рестарта очередь = (1, 0, 0)
19.2 s вложение после рестартов: queued (прежний токен)
24.4 s docker compose start worker
25.8 s ready через 1.3 s после старта worker; job: done attempts=1
25.9 s thumbnail 256x160 JPEG (sha256 = метаданным), оригинал совпадает побайтно; варианты: crop 128x128, optimized 320x200, thumbnail 256x160
PASS: job accepted while worker was down survived API + broker restart and reached ready
+9
View File
@@ -0,0 +1,9 @@
$ python3 student-tests/telemetry_check.py --base-url http://localhost:8096 --grafana http://localhost:3096
PASS 1 trace 3be3a52b1bc7592022498960d9b57175: server span POST /api/v1/chats/{chat_id}/messages (3 SQL), лог request_id=917016f0-d5b9-4e1d-b684-6036ed78bf5c
PASS 2 404 request_id=1a485fd8-d0ae-4ad4-b55b-39f7a183c316 → лог → trace 6f8b505591fc6085762a3910b43302a7
PASS 3 trace ceabc7efebed2673382e4eb476841b5e: upload → publish → process (39 spans), лог job.ready в том же trace
PASS 4 trace d16e7fd868b0192702c0722769ff773a: publish#1 → process#1 (retry, S3 timeout) → publish#2 → process#2 (ready)
PASS 5 метрики: 14 обязательных есть; 121 labels без id/URL; 10 шаблонов http_route
PASS 6 секреты/контент не найдены в 8 ответах Tempo/Loki и во всём Loki за 30 мин
PASS 7 dashboard «Messenger lab6»: 35 панелей, 58/60 запросов с данными (пусто: ['Потери telemetry (элементов/с)'])
PASS: сигналы lab6 (traces, logs, metrics, связь через очередь, retry, отсутствие секретов, dashboard)
+1
View File
@@ -0,0 +1 @@
{"offered_rps":20,"write_share":0.3,"upload_share":0.05,"duration":"60m","requests":26590,"failed":3837,"failed_by_op":{"read":2463,"write":1166,"upload":208},"error_ratio":0.144302,"dropped_iterations":0,"latency_ms":{"avg":80.18475536630328,"p50":4.6814564999999995,"p95":94.78351894999982,"p99":2006.9032155,"max":10403.959261},"read_ms":{"avg":71.39350546413576,"p50":3.77024,"p95":60.99043939999983,"p99":2006.3473886000002,"max":10084.566864},"write_ms":{"avg":90.3292678894906,"p50":5.861717,"p95":117.37453039999987,"p99":2008.46800368,"max":10103.985914},"upload_ms":{"avg":136.07883343711194,"p50":23.393403499999998,"p95":345.18651789999916,"p99":2006.78961351,"max":10403.959261},"max_vus":100}
+176
View File
@@ -0,0 +1,176 @@
[
{
"name": "baseline",
"actions": [],
"watch": [
"ApiHighErrorRate",
"ApiAvailabilityFastBurn",
"ApiAvailabilitySlowBurn",
"DbPoolSaturated",
"JobQueueLagGrowing",
"ReadyLatencyFastBurn",
"ReadyLatencySlowBurn",
"TelemetryExportFailing"
],
"fault_start": 1793398480.189784,
"fault_end": 1793398630.166636,
"end": 1793398630.16669
},
{
"name": "worker-stop",
"actions": [
[
1793398630.1,
"stop worker"
],
[
1793398991.8,
"start worker"
]
],
"watch": [
"JobQueueLagGrowing",
"ReadyLatencyFastBurn",
"ReadyLatencySlowBurn"
],
"fault_start": 1793398630.145775,
"fault_end": 1793398993.755093,
"end": 1793399323.7577658
},
{
"name": "spike",
"actions": [
[
1793398630.1,
"pause postgres"
],
[
1793398690.6,
"unpause postgres"
]
],
"watch": [
"ApiHighErrorRate",
"ApiAvailabilityFastBurn",
"ApiAvailabilitySlowBurn",
"DbPoolSaturated"
],
"fault_start": 1793398630.146558,
"fault_end": 1793398690.735362,
"end": 1793398960.736811
},
{
"name": "telemetry-backends",
"actions": [
[
1793398720.1,
"stop tempo loki"
],
[
1793398841.1,
"start tempo loki"
]
],
"watch": [
"TelemetryExportFailing"
],
"fault_start": 1793398720.145841,
"fault_end": 1793398842.366372,
"end": 1793399142.367826
},
{
"name": "handler-slow",
"actions": [
[
1793398870.2,
"messenger-lab6-api-1 --cpus 0.1"
],
[
1793398990.3,
"messenger-lab6-api-1 --cpus 1"
]
],
"watch": [
"ApiHighErrorRate",
"ApiAvailabilityFastBurn",
"ApiAvailabilitySlowBurn",
"DbPoolSaturated"
],
"fault_start": 1793398870.152113,
"fault_end": 1793398990.379742,
"end": 1793399050.384289
},
{
"name": "api-degradation",
"actions": [
[
1793399050.2,
"pause postgres"
],
[
1793399075.3,
"unpause postgres"
],
[
1793399110.5,
"pause postgres"
],
[
1793399136.1,
"unpause postgres"
],
[
1793399171.5,
"pause postgres"
],
[
1793399197.6,
"unpause postgres"
],
[
1793399232.8,
"pause postgres"
],
[
1793399258.0,
"unpause postgres"
],
[
1793399293.3,
"pause postgres"
],
[
1793399318.5,
"unpause postgres"
]
],
"watch": [
"ApiHighErrorRate",
"ApiAvailabilityFastBurn",
"ApiAvailabilitySlowBurn",
"DbPoolSaturated"
],
"fault_start": 1793399050.1484978,
"fault_end": 1793399350.1513112,
"end": 1793399620.1672971
},
{
"name": "collector-down",
"actions": [
[
1793399630.2,
"stop otel-collector"
],
[
1793399691.9,
"start otel-collector"
]
],
"watch": [
"TelemetryExportFailing"
],
"fault_start": 1793399630.1582222,
"fault_end": 1793399692.265625,
"end": 1793399752.266947
}
]
File diff suppressed because it is too large Load Diff
+168
View File
@@ -0,0 +1,168 @@
## Alerts по фазам (мин:с от начала отказа; снятие — от конца отказа)
| Фаза | Отказ | Alert | pending | firing | снят после конца | firing всего | интервалов |
|---|---|---|---|---|---|---|---|
| baseline | 2:30 | нет | — | — | — | — | — |
| worker-stop | 6:04 | JobQueueLagGrowing | 2:10 | 3:10 | 0:36 | 3:30 | 1 |
| worker-stop | 6:04 | ReadyLatencyFastBurn | — | 6:40 | — | 5:00 | 1 |
| worker-stop | 6:04 | ReadyLatencySlowBurn | — | 6:40 | — | 5:04 | 1 |
| spike | 1:01 | ApiAvailabilitySlowBurn | — | 1:00 | — | 4:41 | 1 |
| spike | 1:01 | ApiHighErrorRate | 0:30 | 2:30 | — | 3:11 | 1 |
| spike | 1:01 | DbPoolSaturated | 4:30 | — | — | 0:00 | 0 |
| telemetry-backends | 2:02 | TelemetryExportFailing | 0:20 | 1:20 | — | 5:40 | 1 |
| handler-slow | 2:00 | ApiAvailabilitySlowBurn (горел до отказа) | — | — | — | 3:10 | 1 |
| handler-slow | 2:00 | ApiHighErrorRate (горел до отказа) | — | — | −0:10 | 1:50 | 1 |
| handler-slow | 2:00 | DbPoolSaturated | 0:30 | — | — | 0:00 | 0 |
| api-degradation | 5:00 | ApiAvailabilityFastBurn | — | 2:50 | 4:20 | 6:30 | 1 |
| api-degradation | 5:00 | ApiAvailabilitySlowBurn (горел до отказа) | — | — | — | 9:40 | 1 |
| api-degradation | 5:00 | ApiHighErrorRate | 0:30 | 2:30 | 4:20 | 6:50 | 1 |
| api-degradation | 5:00 | DbPoolSaturated | 2:10 | — | — | 0:00 | 0 |
| collector-down | 1:02 | нет | — | — | — | — | — |
## Firing за весь прогон (мин:с от начала baseline)
- ApiAvailabilityFastBurn: 12:20–18:50
- ApiAvailabilitySlowBurn: 3:30–22:20
- ApiHighErrorRate: 5:00–8:20, 12:00–18:50
- JobQueueLagGrowing: 5:40–9:10
- ReadyLatencyFastBurn: 9:10–14:10
- ReadyLatencySlowBurn: 9:10–22:20
- TelemetryExportFailing: 5:20–11:00
## Метрики в окне отказа (максимум)
| Фаза | sli_5xx_clients_5m | 5xx_clients_1m | 5xx_api_metrics_1m | api_p99_s | oldest_job_age_s | ready_p95_s | worker_saturation | queue_consumers | api_burn_5m | api_burn_1h | api_burn_6h | ready_burn_5m | ready_burn_1h |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| baseline | 0 | 0 | 0 | 0.22 | 0.0417 | 0.5625 | 0 | 2 | 0 | 1.4233 | 1.4213 | 0 | 0.0803 |
| worker-stop | 0.2181 | 1 | 0.9172 | 10 | 296.8 | 0.4849 | 0 | 2 | 43.6168 | 9.0549 | 9.0335 | 0 | 0 |
| spike | 0.188 | 1 | 0.9172 | 10 | 0.076 | 0.4849 | 0 | 2 | 37.6092 | 7.6014 | 7.5856 | 0 | 0 |
| telemetry-backends | 0.21 | 0.441 | 0 | 0.2727 | 146.395 | — | — | 0 | 41.994 | 8.9979 | 8.976 | 0 | 0 |
| handler-slow | 0.209 | 0.0041 | 0.001 | 2.3224 | 296.8 | — | — | 0 | 41.8051 | 8.2198 | 8.1931 | 0 | 0 |
| api-degradation | 0.4491 | 0.5271 | 0.1225 | 10 | 2.9004 | 292.36 | 0.5 | 2 | 89.8276 | 18.7807 | 18.4425 | 81.3263 | 15.8051 |
| collector-down | 0 | 0 | 0 | 0.0786 | 0 | 0.475 | 0 | 2 | 0 | 16.7316 | 16.2113 | 0 | 12.7508 |
## Насыщение по экземплярам (максимум в окне отказа)
**baseline**
- sql_p99_by_job_s: messenger-api 0.0469, messenger-worker 0.035
- pool_pending_by_job: messenger-api 0, messenger-worker 0
- eventloop_p99_by_instance_s: api-2 messenger-api 0.0227, api-1 messenger-api 0.0247, worker-2 messenger-worker 0.0191, worker-1 messenger-worker 0.0192
- cpu_by_instance: api-2 messenger-api 0.0536, api-1 messenger-api 0.0612, worker-2 messenger-worker 0.0408, worker-1 messenger-worker 0.043
- api_p99_by_instance_s: api-2 0.2167, api-1 0.225
- медленные trace (>300 мс), медианы мс: {'total_ms': 435, 'pool_wait_ms': 1, 'sql_ms': 108, 's3_ms': 237, 'self_ms': 90}; по репликам: {'api-2': 1}
**spike**
- sql_p99_by_job_s: messenger-api 0.0342, messenger-worker 0.0359
- pool_pending_by_job: messenger-api 0, messenger-worker 0
- eventloop_p99_by_instance_s: api-2 messenger-api 0.0236, api-1 messenger-api 0.0264, worker-2 messenger-worker 0.0158, worker-1 messenger-worker 0.0182
- cpu_by_instance: api-2 messenger-api 0.054, api-1 messenger-api 0.0583, worker-2 messenger-worker 0.0409, worker-1 messenger-worker 0.0498
- api_p99_by_instance_s: api-2 10, api-1 10
- медленные trace (>300 мс), медианы мс: {'total_ms': 2004, 'pool_wait_ms': 2001, 'sql_ms': 0, 's3_ms': 0, 'self_ms': 2}; по репликам: {'api-2': 11, 'api-1': 9}
**handler-slow**
- sql_p99_by_job_s: messenger-api 0.4658
- pool_pending_by_job: messenger-api 7
- eventloop_p99_by_instance_s: api-2 messenger-api 0.0694, api-1 messenger-api 7.3065
- cpu_by_instance: api-2 messenger-api 0.0915, api-1 messenger-api 0.0894
- api_p99_by_instance_s: api-2 0.6508, api-1 4.975
- медленные trace (>300 мс), медианы мс: {'total_ms': 898, 'pool_wait_ms': 1, 'sql_ms': 600, 's3_ms': 0, 'self_ms': 4}; по репликам: {'api-1': 18, 'api-2': 1}
**api-degradation**
- sql_p99_by_job_s: messenger-api 0.9968, messenger-worker 0.372
- pool_pending_by_job: messenger-api 11, messenger-worker 0
- eventloop_p99_by_instance_s: api-2 messenger-api 0.0976, api-1 messenger-api 0.0863, worker-2 messenger-worker 0.0871, worker-1 messenger-worker 0.0891
- cpu_by_instance: api-2 messenger-api 0.0848, api-1 messenger-api 0.0906, worker-2 messenger-worker 0.1838, worker-1 messenger-worker 0.1913
- api_p99_by_instance_s: api-2 10, api-1 10
- медленные trace (>300 мс), медианы мс: {'total_ms': 2001, 'pool_wait_ms': 1999, 'sql_ms': 0, 's3_ms': 0, 'self_ms': 1}; по репликам: {'api-1': 11, 'api-2': 9}
## События ERROR/WARN в логах за фазу
- baseline: нет
- worker-stop: messenger-api http.dependency_unavailable 369, messenger-api http.request 354, messenger-api sweeper.error 70, messenger-api relay.db_unavailable 6, messenger-api s3.error 1
- spike: messenger-api http.dependency_unavailable 63, messenger-api http.request 62, messenger-api sweeper.error 24, messenger-api relay.db_unavailable 2
- telemetry-backends: messenger-api http.dependency_unavailable 112, messenger-api http.request 106, messenger-api sweeper.error 20, messenger-api relay.db_unavailable 1
- handler-slow: messenger-api http.dependency_unavailable 3, messenger-api http.request 3
- api-degradation: messenger-api http.dependency_unavailable 303, messenger-api http.request 289, messenger-api sweeper.error 46, messenger-api relay.db_unavailable 4, messenger-api s3.error 1
- collector-down: messenger-api http.request 2, messenger-api http.dependency_unavailable 1, messenger-worker job.requeued 1, messenger-api s3.error 1
## Недоступность telemetry
```json
{
"backends_down_s": 121,
"collector_dropped": {
"__name__=otelcol_exporter_send_failed_log_records_total exporter=otlp_http/loki": 174,
"__name__=otelcol_exporter_send_failed_spans_total exporter=otlp_grpc/tempo": 1102
},
"collector_refused_memory_limiter": {
"__name__=otelcol_receiver_refused_metric_points_total": 0,
"__name__=otelcol_receiver_refused_log_records_total": 0,
"__name__=otelcol_receiver_refused_spans_total": 0
},
"collector_queue_max": {
"otlp_grpc/tempo": {
"max": 19368.0,
"mean": 3405.4651
},
"otlp_http/loki": {
"max": 2325.0,
"mean": 362.7674
},
"otlp_http/prometheus": {
"max": 0.0,
"mean": 0.0
}
},
"collector_rss_mib": {
"all": {
"max": 121.4258,
"mean": 103.1724
}
},
"lb_responses_during_phase": {
"1xx": 0,
"2xx": 7349,
"3xx": 0,
"4xx": 0,
"5xx": 1087,
"other": 0
}
}
```
## Недоступность telemetry
```json
{
"collector_down_s": 62,
"sdk_spans_started_during_phase": {
"job=messenger-api": 19095,
"job=messenger-worker": 2932
},
"tempo_api_traces_found_while_collector_down": 117,
"api_rss_mib": {
"api-2": {
"max": 100.25,
"mean": 95.7406
},
"api-1": {
"max": 97.8281,
"mean": 95.6253
}
},
"lb_responses_during_phase": {
"1xx": 0,
"2xx": 1155,
"3xx": 0,
"4xx": 0,
"5xx": 0,
"other": 0
}
}
```
## k6
```json
[{"offered_rps": 20, "write_share": 0.3, "upload_share": 0.05, "duration": "60m", "requests": 26590, "failed": 3837, "failed_by_op": {"read": 2463, "write": 1166, "upload": 208}, "error_ratio": 0.144302, "dropped_iterations": 0, "latency_ms": {"avg": 80.18475536630328, "p50": 4.6814564999999995, "p95": 94.78351894999982, "p99": 2006.9032155, "max": 10403.959261}, "read_ms": {"avg": 71.39350546413576, "p50": 3.77024, "p95": 60.99043939999983, "p99": 2006.3473886000002, "max": 10084.566864}, "write_ms": {"avg": 90.3292678894906, "p50": 5.861717, "p95": 117.37453039999987, "p99": 2008.46800368, "max": 10103.985914}, "upload_ms": {"avg": 136.07883343711194, "p50": 23.393403499999998, "p95": 345.18651789999916, "p99": 2006.78961351, "max": 10403.959261}, "max_vus": 100}]
```
+34
View File
@@ -0,0 +1,34 @@
<svg xmlns="http://www.w3.org/2000/svg" width="1300" height="430" font-family="sans-serif" font-size="11">
<rect width="1300" height="430" fill="white"/>
<rect x="300.9" y="20" width="52.9" height="260" fill="#eeeeee"/><text x="303.9" y="32" fill="#555">spike</text>
<rect x="510.3" y="20" width="104.9" height="260" fill="#eeeeee"/><text x="513.3" y="44" fill="#555">handler-slow</text>
<rect x="667.3" y="20" width="261.8" height="260" fill="#eeeeee"/><text x="670.3" y="56" fill="#555">api-degradation</text>
<rect x="1173.4" y="20" width="54.2" height="260" fill="#eeeeee"/><text x="1176.4" y="68" fill="#555">collector-down</text>
<line x1="170" x2="1280" y1="280.0" y2="280.0" stroke="#ddd"/><text x="164" y="284.0" text-anchor="end">0%</text>
<line x1="170" x2="1280" y1="215.0" y2="215.0" stroke="#ddd"/><text x="164" y="219.0" text-anchor="end">25%</text>
<line x1="170" x2="1280" y1="150.0" y2="150.0" stroke="#ddd"/><text x="164" y="154.0" text-anchor="end">50%</text>
<line x1="170" x2="1280" y1="85.0" y2="85.0" stroke="#ddd"/><text x="164" y="89.0" text-anchor="end">75%</text>
<line x1="170" x2="1280" y1="20.0" y2="20.0" stroke="#ddd"/><text x="164" y="24.0" text-anchor="end">100%</text>
<polyline fill="none" stroke="#d62728" stroke-width="1.5" points="170.0,280.0 196.2,280.0 222.4,280.0 248.5,280.0 274.7,280.0 300.9,280.0 327.1,140.3 353.2,20.0 379.4,165.3 405.6,280.0 431.8,280.0 458.0,280.0 484.1,280.0 510.3,280.0 536.5,280.0 562.7,280.0 588.8,280.0 615.0,278.9 641.2,278.4 667.4,280.0 693.6,143.5 719.7,190.7 745.9,143.0 772.1,185.0 798.3,145.6 824.4,180.3 850.6,144.3 876.8,177.9 903.0,145.8 929.2,176.8 955.3,280.0 981.5,280.0 1007.7,280.0 1033.9,280.0 1060.0,280.0 1086.2,280.0 1112.4,280.0 1138.6,280.0 1164.8,280.0 1190.9,280.0"/>
<polyline fill="none" stroke="#d62728" stroke-width="1.5" points="1243.3,280.0 1269.5,280.0"/>
<rect x="170" y="400" width="12" height="3" fill="#d62728"/><text x="186" y="405">5xx у клиентов (HAProxy), 1m</text>
<polyline fill="none" stroke="#ff9896" stroke-width="1.5" points="170.0,280.0 196.2,280.0 222.4,280.0 248.5,280.0 274.7,280.0 300.9,280.0 327.1,251.3 353.2,41.5 379.4,280.0 405.6,280.0 431.8,280.0 458.0,280.0 484.1,280.0 510.3,280.0 536.5,280.0 562.7,280.0 588.8,280.0 615.0,279.7 641.2,279.2 667.4,280.0 693.6,255.0 719.7,279.6 745.9,254.8 772.1,280.0 798.3,253.6 824.4,275.8 850.6,249.4 876.8,273.4 903.0,252.5 929.2,272.6 955.3,280.0 981.5,280.0 1007.7,280.0 1033.9,280.0 1060.0,280.0 1086.2,280.0 1112.4,280.0 1138.6,280.0 1164.8,280.0 1190.9,280.0"/>
<polyline fill="none" stroke="#ff9896" stroke-width="1.5" points="1243.3,280.0 1269.5,280.0"/>
<rect x="430" y="400" width="12" height="3" fill="#ff9896"/><text x="446" y="405">5xx в метриках API, 1m</text>
<polyline fill="none" stroke="#1f77b4" stroke-width="1.5" points="170.0,278.1 196.2,278.2 222.4,278.2 248.5,278.3 274.7,278.3 300.9,278.3 327.1,275.1 353.2,270.1 379.4,268.3 405.6,268.5 431.8,268.7 458.0,268.9 484.1,269.1 510.3,269.3 536.5,269.5 562.7,269.7 588.8,269.8 615.0,270.0 641.2,270.1 667.4,270.2 693.6,267.7 719.7,266.9 745.9,264.7 772.1,263.9 798.3,262.0 824.4,261.1 850.6,259.3 876.8,258.4 903.0,256.7 929.2,255.7 955.3,255.9 981.5,256.2 1007.7,256.4 1033.9,256.7 1060.0,257.0 1086.2,257.3 1112.4,257.6 1138.6,257.9 1164.8,258.2 1190.9,258.3 1217.1,258.3 1243.3,258.9 1269.5,259.2"/>
<rect x="690" y="400" width="12" height="3" fill="#1f77b4"/><text x="706" y="405">SLI 1h (fast: > 7.2 %)</text>
<polyline fill="none" stroke="#2ca02c" stroke-width="1.5" points="170.0,278.2 196.2,278.2 222.4,278.2 248.5,278.3 274.7,278.3 300.9,278.3 327.1,275.1 353.2,270.1 379.4,268.3 405.6,268.6 431.8,268.8 458.0,269.0 484.1,269.2 510.3,269.3 536.5,269.5 562.7,269.7 588.8,269.9 615.0,270.0 641.2,270.2 667.4,270.3 693.6,267.9 719.7,267.1 745.9,264.9 772.1,264.1 798.3,262.2 824.4,261.4 850.6,259.6 876.8,258.7 903.0,257.1 929.2,256.2 955.3,256.6 981.5,256.9 1007.7,257.2 1033.9,257.5 1060.0,257.8 1086.2,258.0 1112.4,258.3 1138.6,258.6 1164.8,258.8 1190.9,259.0 1217.1,259.0 1243.3,259.6 1269.5,259.8"/>
<rect x="950" y="400" width="12" height="3" fill="#2ca02c"/><text x="966" y="405">SLI 6h (slow: > 3 %)</text>
<text x="164" y="311" text-anchor="end">ApiHighErrorRate</text>
<rect x="431.8" y="302" width="174.5" height="10" fill="#ff7f0e"/>
<rect x="798.3" y="302" width="357.8" height="10" fill="#ff7f0e"/>
<text x="164" y="325" text-anchor="end">ApiAvailabilityFastBurn</text>
<rect x="815.7" y="316" width="340.3" height="10" fill="#ff7f0e"/>
<text x="164" y="339" text-anchor="end">ApiAvailabilitySlowBurn</text>
<rect x="353.2" y="330" width="933.7" height="10" fill="#ff7f0e"/>
<text x="170.0" y="14" text-anchor="middle" fill="#555">0 мин</text>
<text x="431.8" y="14" text-anchor="middle" fill="#555">5 мин</text>
<text x="693.6" y="14" text-anchor="middle" fill="#555">10 мин</text>
<text x="955.3" y="14" text-anchor="middle" fill="#555">15 мин</text>
<text x="1217.1" y="14" text-anchor="middle" fill="#555">20 мин</text>
</svg>

After

Width:  |  Height:  |  Size: 4.9 KiB

+28
View File
@@ -0,0 +1,28 @@
<svg xmlns="http://www.w3.org/2000/svg" width="1300" height="430" font-family="sans-serif" font-size="11">
<rect width="1300" height="430" fill="white"/>
<rect x="300.8" y="20" width="317.3" height="260" fill="#eeeeee"/><text x="303.8" y="32" fill="#555">worker-stop</text>
<rect x="1173.4" y="20" width="54.2" height="260" fill="#eeeeee"/><text x="1176.4" y="44" fill="#555">collector-down</text>
<line x1="170" x2="1280" y1="280.0" y2="280.0" stroke="#ddd"/><text x="164" y="284.0" text-anchor="end">0%</text>
<line x1="170" x2="1280" y1="215.0" y2="215.0" stroke="#ddd"/><text x="164" y="219.0" text-anchor="end">25%</text>
<line x1="170" x2="1280" y1="150.0" y2="150.0" stroke="#ddd"/><text x="164" y="154.0" text-anchor="end">50%</text>
<line x1="170" x2="1280" y1="85.0" y2="85.0" stroke="#ddd"/><text x="164" y="89.0" text-anchor="end">75%</text>
<line x1="170" x2="1280" y1="20.0" y2="20.0" stroke="#ddd"/><text x="164" y="24.0" text-anchor="end">100%</text>
<polyline fill="none" stroke="#d62728" stroke-width="1.5" points="170.0,280.0 196.2,280.0 222.4,280.0 248.5,280.0 274.7,280.0 300.9,280.0 327.1,280.0 353.2,280.0 379.4,280.0 405.6,280.0 431.8,280.0 458.0,280.0 484.1,280.0 510.3,280.0 536.5,280.0"/>
<polyline fill="none" stroke="#d62728" stroke-width="1.5" points="641.2,20.0 667.4,68.6 693.6,72.3 719.7,87.1 745.9,89.3 772.1,99.1 798.3,107.1 824.4,116.0 850.6,120.5 876.8,129.4 903.0,280.0 929.2,280.0 955.3,280.0 981.5,280.0 1007.7,280.0 1033.9,280.0 1060.0,280.0 1086.2,280.0 1112.4,280.0 1138.6,280.0 1164.8,280.0 1190.9,280.0 1217.1,280.0 1243.3,280.0 1269.5,280.0"/>
<rect x="170" y="400" width="12" height="3" fill="#d62728"/><text x="186" y="405">плохие вложения, 5m</text>
<polyline fill="none" stroke="#1f77b4" stroke-width="1.5" points="170.0,279.8 196.2,279.8 222.4,279.8 248.5,280.0 274.7,280.0 300.9,280.0 327.1,280.0 353.2,280.0 379.4,280.0 405.6,280.0 431.8,280.0 458.0,280.0 484.1,280.0 510.3,280.0 536.5,280.0 562.7,280.0 588.8,280.0 615.0,280.0 641.2,241.6 667.4,238.9 693.6,239.0 719.7,239.6 745.9,239.7 772.1,240.1 798.3,240.5 824.4,240.9 850.6,241.2 876.8,241.8 903.0,241.9 929.2,242.3 955.3,242.9 981.5,243.4 1007.7,244.0 1033.9,244.6 1060.0,245.2 1086.2,245.7 1112.4,246.2 1138.6,246.6 1164.8,246.8 1190.9,246.9 1217.1,246.9 1243.3,247.9 1269.5,248.3"/>
<rect x="430" y="400" width="12" height="3" fill="#1f77b4"/><text x="446" y="405">SLI 1h (fast: > 14.4 %)</text>
<polyline fill="none" stroke="#2ca02c" stroke-width="1.5" points="170.0,279.8 196.2,279.8 222.4,279.8 248.5,279.8 274.7,279.8 300.9,279.8 327.1,279.8 353.2,279.8 379.4,279.8 405.6,279.8 431.8,279.8 458.0,279.8 484.1,279.8 510.3,279.8 536.5,279.8 562.7,279.8 588.8,279.8 615.0,279.8 641.2,241.7 667.4,239.5 693.6,239.7 719.7,240.3 745.9,240.3 772.1,240.7 798.3,241.1 824.4,241.6 850.6,241.9 876.8,242.4 903.0,242.5 929.2,242.9 955.3,243.5 981.5,244.0 1007.7,244.5 1033.9,245.1 1060.0,245.7 1086.2,246.2 1112.4,246.7 1138.6,247.1 1164.8,247.3 1190.9,247.3 1217.1,247.3 1243.3,248.3 1269.5,248.7"/>
<rect x="690" y="400" width="12" height="3" fill="#2ca02c"/><text x="706" y="405">SLI 6h (slow: > 6 %)</text>
<text x="164" y="311" text-anchor="end">JobQueueLagGrowing</text>
<rect x="466.7" y="302" width="183.2" height="10" fill="#ff7f0e"/>
<text x="164" y="325" text-anchor="end">ReadyLatencyFastBurn</text>
<rect x="649.9" y="316" width="261.8" height="10" fill="#ff7f0e"/>
<text x="164" y="339" text-anchor="end">ReadyLatencySlowBurn</text>
<rect x="649.9" y="330" width="637.0" height="10" fill="#ff7f0e"/>
<text x="170.0" y="14" text-anchor="middle" fill="#555">0 мин</text>
<text x="431.8" y="14" text-anchor="middle" fill="#555">5 мин</text>
<text x="693.6" y="14" text-anchor="middle" fill="#555">10 мин</text>
<text x="955.3" y="14" text-anchor="middle" fill="#555">15 мин</text>
<text x="1217.1" y="14" text-anchor="middle" fill="#555">20 мин</text>
</svg>

After

Width:  |  Height:  |  Size: 3.8 KiB

+210
View File
@@ -0,0 +1,210 @@
#!/usr/bin/env python3
"""Генератор infra/grafana/dashboards/messenger.json (импортируется provisioning-ом).
JSON в Git — результат этого скрипта; правьте скрипт и пересоберите: python3 infra/grafana/build_dashboard.py
Каждая панель: запрос PromQL/LogQL/TraceQL и единица измерения (fieldConfig.unit). Квантили — histogram_quantile
по сумме buckets всех реплик (sum by le), не среднее и не усреднение p99 реплик."""
import json
from pathlib import Path
PROM = {'type': 'prometheus', 'uid': 'prometheus'}
LOKI = {'type': 'loki', 'uid': 'loki'}
TEMPO = {'type': 'tempo', 'uid': 'tempo'}
RATE = '$__rate_interval'
panels, y = [], 0
def row(title):
global y
panels.append({'type': 'row', 'title': title, 'collapsed': False, 'panels': [],
'gridPos': {'x': 0, 'y': y, 'w': 24, 'h': 1}, 'id': len(panels) + 1})
y += 1
def place(items, h=8):
"""Панели одной строки делят ширину 24 поровну."""
global y
w = 24 // len(items)
for i, p in enumerate(items):
p['gridPos'] = {'x': i * w, 'y': y, 'w': w, 'h': h}
p['id'] = len(panels) + 1
panels.append(p)
y += h
def ts(title, unit, targets, desc='', thresholds=None, stack=False, minimum=None):
defaults = {'unit': unit, 'custom': {'lineWidth': 1, 'fillOpacity': 10, 'showPoints': 'never',
'stacking': {'mode': 'normal' if stack else 'none'}}}
if minimum is not None:
defaults['min'] = minimum
if thresholds:
defaults['thresholds'] = {'mode': 'absolute', 'steps': [{'color': 'green', 'value': None}] +
[{'color': 'red', 'value': thresholds}]}
defaults['custom']['thresholdsStyle'] = {'mode': 'line+area'}
return {'type': 'timeseries', 'title': title, 'description': desc, 'datasource': PROM,
'fieldConfig': {'defaults': defaults, 'overrides': []},
'options': {'legend': {'displayMode': 'list', 'placement': 'bottom'}, 'tooltip': {'mode': 'multi', 'sort': 'desc'}},
'targets': [{'refId': chr(65 + i), 'datasource': PROM, 'expr': e, 'legendFormat': l} for i, (e, l) in enumerate(targets)]}
def stat(title, unit, expr, desc='', red_below=None, red_above=None, decimals=None):
steps = [{'color': 'green', 'value': None}]
if red_below is not None:
steps = [{'color': 'red', 'value': None}, {'color': 'green', 'value': red_below}]
if red_above is not None:
steps.append({'color': 'red', 'value': red_above})
defaults = {'unit': unit, 'thresholds': {'mode': 'absolute', 'steps': steps}}
if decimals is not None:
defaults['decimals'] = decimals
return {'type': 'stat', 'title': title, 'description': desc, 'datasource': PROM,
'fieldConfig': {'defaults': defaults, 'overrides': []},
'options': {'reduceOptions': {'calcs': ['lastNotNull'], 'fields': '', 'values': False},
'colorMode': 'background', 'graphMode': 'area', 'textMode': 'value'},
'targets': [{'refId': 'A', 'datasource': PROM, 'expr': expr, 'instant': False}]}
def quantiles(metric, selector, by=''):
grp = f'le{", " + by if by else ""}'
return [(f'histogram_quantile({q}, sum by ({grp}) (rate({metric}_bucket{{{selector}}}[{RATE}])))',
f'p{int(q * 100)}{" {{" + by + "}}" if by else ""}') for q in (0.5, 0.95, 0.99)]
API = 'job="messenger-api"'
row('SLO и alerts (трек 2)')
place([
stat('Доступность API у клиентов, 1 ч', 'percentunit', '1 - slo:api_error_ratio:rate1h',
'SLI = 1 − 5xx/все ответы HAProxy (frontend public) за 1 ч: включает 503/504 самого LB, которых не видит API. '
'SLO 99.5 % за 30 дней.', red_below=0.995, decimals=2),
stat('Остаток бюджета API (30 д)', 'percentunit', '1 - slo:api_error_ratio:rate30d / 0.005',
'Доля неизрасходованного бюджета ошибок 0.5 % за 30 дней (на стенде — за доступную историю).', red_below=0, decimals=1),
stat('Ready ≤ 30 с, 1 ч', 'percentunit', '1 - slo:ready_bad_ratio:rate1h',
'SLI time-to-ready: доля вложений, ставших ready не позже 30 с от приёма. SLO 99 %.', red_below=0.99, decimals=2),
stat('Остаток бюджета time-to-ready (30 д)', 'percentunit', '1 - slo:ready_bad_ratio:rate30d / 0.01',
'Бюджет 1 % «медленных» или failed вложений за 30 дней.', red_below=0, decimals=1),
stat('Alerts firing', 'none', 'count(ALERTS{alertstate="firing"}) or vector(0)', 'Сейчас активных alerts.', red_above=1),
], h=5)
place([
ts('Burn rate API (×бюджет)', 'none', [
('slo:api_error_ratio:rate5m / 0.005', '5m'), ('slo:api_error_ratio:rate30m / 0.005', '30m'),
('slo:api_error_ratio:rate1h / 0.005', '1h'), ('slo:api_error_ratio:rate6h / 0.005', '6h')],
'Расход бюджета относительно равномерного. Fast burn: 1h и 5m > 14.4; slow burn: 6h и 30m > 6.', thresholds=6),
ts('Burn rate time-to-ready (×бюджет)', 'none', [
('slo:ready_bad_ratio:rate5m / 0.01', '5m'), ('slo:ready_bad_ratio:rate30m / 0.01', '30m'),
('slo:ready_bad_ratio:rate1h / 0.01', '1h'), ('slo:ready_bad_ratio:rate6h / 0.01', '6h')],
'Fast burn: 1h и 5m > 14.4; slow burn: 6h и 30m > 6.', thresholds=6),
{'type': 'state-timeline', 'title': 'Alerts (pending / firing)', 'datasource': PROM,
'description': 'Серия ALERTS: состояние правил Prometheus. Отсутствие полосы — alert неактивен (resolved).',
'fieldConfig': {'defaults': {'color': {'mode': 'thresholds'}, 'thresholds': {'mode': 'absolute', 'steps': [
{'color': 'transparent', 'value': None}, {'color': 'orange', 'value': 1}, {'color': 'red', 'value': 2}]}},
'overrides': []},
'options': {'showValue': 'never', 'mergeValues': True, 'rowHeight': 0.8, 'legend': {'showLegend': False}},
'targets': [{'refId': 'A', 'datasource': PROM, 'legendFormat': '{{alertname}}',
'expr': 'max by (alertname) ((ALERTS{alertstate="pending"} * 1) or (ALERTS{alertstate="firing"} * 2))'}]},
])
row('API: запросы, ошибки, задержка')
place([
ts('RPS по маршрутам', 'reqps', [(f'sum by (http_route, http_request_method) (rate(http_server_request_duration_seconds_count{{{API}}}[{RATE}]))',
'{{http_request_method}} {{http_route}}')],
'http.server.request.duration (_count) — счётчик запросов; label http_route — шаблон маршрута.', stack=True),
ts('RPS по классу статуса', 'reqps', [(
f'sum by (status_class) (label_replace(rate(http_server_request_duration_seconds_count{{{API}}}[{RATE}]), '
'"status_class", "${1}xx", "http_response_status_code", "([0-9]).."))', '{{status_class}}')], stack=True),
ts('Доля 5xx', 'percentunit', [
(f'(sum(rate(http_server_request_duration_seconds_count{{{API},http_response_status_code=~"5.."}}[{RATE}])) or vector(0))'
f' / sum(rate(http_server_request_duration_seconds_count{{{API}}}[{RATE}]))', 'в метриках API'),
('slo:api_error_ratio:rate5m', 'у клиентов (HAProxy), 5m — SLI, alert > 5 %')],
'5xx / все ответы; 4xx — не ошибка сервиса. Линия API ниже линии HAProxy, когда LB отвечает сам: 503 без готовых '
'реплик (БД недоступна → readiness), 504 по таймауту.', thresholds=0.05, minimum=0),
])
place([
ts('Задержка API p50/p95/p99', 's', quantiles('http_server_request_duration_seconds', API),
'Квантили из buckets histogram всех реплик (sum by le).'),
ts('p99 по маршрутам', 's', [(f'histogram_quantile(0.99, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{{{API}}}[{RATE}])))',
'{{http_route}}')]),
ts('p99 запросов к PostgreSQL', 's', [(f'histogram_quantile(0.99, sum by (le, job) (rate(db_client_operation_duration_seconds_bucket[{RATE}])))', '{{job}}')],
'db.client.operation.duration (instrumentation-pg). Медленная БД — растёт здесь; медленный handler — нет.'),
])
row('Worker и задания')
place([
ts('Jobs/с по исходу', 'ops', [(f'sum by (outcome) (rate(messenger_job_duration_seconds_count[{RATE}]))', '{{outcome}}')],
'done — ready; retry — временная ошибка, повтор; failed — терминально; noop/discarded — дубль/потерянная аренда.', stack=True),
ts('Длительность обработки job (done) p50/p95/p99', 's', quantiles('messenger_job_duration_seconds', 'outcome="done"')),
ts('Время до ready p50/p95/p99', 's', quantiles('messenger_attachment_time_to_ready_seconds', 'outcome="ready"'),
'От durable acceptance (COMMIT задания) до публикации ready. Порог SLO — 30 с.', thresholds=30),
])
place([
ts('Насыщение worker (busy / capacity)', 'percentunit', [
('sum(messenger_worker_busy) / sum(messenger_worker_capacity)', 'все worker'),
('messenger_worker_busy / messenger_worker_capacity', '{{instance}}')], minimum=0),
ts('Очередь: backlog', 'none', [
('max by (state) (messenger_jobs_backlog)', 'jobs {{state}} (БД)'),
('max(messenger_outbox_pending)', 'outbox без confirm'),
('sum(rabbitmq_detailed_queue_messages_ready{queue="attachments.process"})', 'RabbitMQ ready'),
('sum(rabbitmq_detailed_queue_messages_unacked{queue="attachments.process"})', 'RabbitMQ unacked')],
'Количество работы (backlog). БД — источник истины; одинаково видна со всех реплик API, берётся max.'),
ts('Возраст старейшего задания', 's', [('max by (queue) (messenger_jobs_oldest_age_seconds)', '{{queue}}'),
('sum(rabbitmq_detailed_queue_consumers{queue="attachments.process"})', 'consumers')],
'Секунды с приёма старейшего незавершённого задания (lag). Alert JobQueueLagGrowing — > 60 с в течение 1 мин.', thresholds=60),
])
row('Насыщение: пул БД, CPU, память, event loop')
place([
ts('Пул соединений PostgreSQL', 'none', [
('sum by (job, db_client_connection_state) (db_client_connection_count)', '{{job}} {{db_client_connection_state}}'),
('sum by (job) (db_client_connection_pending_requests)', '{{job}} ждут соединения'),
('sum by (job) (db_client_connection_max)', '{{job}} max')]),
ts('CPU процессов (доля ядра)', 'percentunit', [(f'sum by (job, instance) (rate(process_cpu_time_seconds_total[{RATE}]))', '{{job}} {{instance}}')],
'process.cpu.time; 100 % = одно ядро. Лимит контейнера api/worker — 1 CPU.'),
ts('Память процессов (RSS)', 'bytes', [('process_memory_usage_bytes', '{{job}} {{instance}}'),
('otelcol_process_memory_rss', 'collector')]),
ts('Event loop: задержка p99', 's', [('nodejs_eventloop_delay_p99_seconds', '{{job}} {{instance}}')],
'Блокировка event loop Node.js (CPU-bound handler) — растёт здесь, а не в p99 PostgreSQL.'),
])
row('Telemetry pipeline (OpenTelemetry Collector)')
place([
ts('Принято / отправлено (элементов/с)', 'ops', [
(f'sum(rate(otelcol_receiver_accepted_spans_total[{RATE}]))', 'spans принято'),
(f'sum(rate(otelcol_exporter_sent_spans_total[{RATE}]))', 'spans отправлено'),
(f'sum(rate(otelcol_receiver_accepted_log_records_total[{RATE}]))', 'logs принято'),
(f'sum(rate(otelcol_exporter_sent_log_records_total[{RATE}]))', 'logs отправлено'),
(f'sum(rate(otelcol_receiver_accepted_metric_points_total[{RATE}]))', 'metric points принято'),
(f'sum(rate(otelcol_exporter_sent_metric_points_total[{RATE}]))', 'metric points отправлено')]),
ts('Потери telemetry (элементов/с)', 'ops', [
(f'sum by (exporter) (rate(otelcol_exporter_send_failed_spans_total[{RATE}]))', 'send failed spans {{exporter}}'),
(f'sum by (exporter) (rate(otelcol_exporter_send_failed_log_records_total[{RATE}]))', 'send failed logs {{exporter}}'),
(f'sum by (exporter) (rate(otelcol_exporter_enqueue_failed_spans_total[{RATE}]))', 'очередь полна, spans {{exporter}}'),
(f'sum by (exporter) (rate(otelcol_exporter_enqueue_failed_log_records_total[{RATE}]))', 'очередь полна, logs {{exporter}}'),
(f'sum(rate(otelcol_receiver_refused_spans_total[{RATE}]))', 'отказ приёма spans (memory_limiter)')],
'Отброшенное Collector-ом: после 60 с повторов (send failed) или при полной очереди (enqueue failed).'),
ts('Очередь экспортёров', 'none', [('otelcol_exporter_queue_size', '{{exporter}}'),
('max(otelcol_exporter_queue_capacity)', 'ёмкость')],
'Ограниченная очередь в памяти: при недоступном backend растёт до ёмкости, не дальше.'),
])
row('Логи и трассы')
place([
{'type': 'logs', 'title': 'Ошибки и предупреждения (Loki)', 'datasource': LOKI,
'description': 'Структурные логи api и worker; поле trace_id ведёт в Tempo.',
'options': {'showTime': True, 'wrapLogMessage': True, 'sortOrder': 'Descending', 'enableLogDetails': True},
'targets': [{'refId': 'A', 'datasource': LOKI,
'expr': '{service_name=~"messenger-.+"} | severity_text=~"ERROR|WARN"'}]},
{'type': 'table', 'title': 'Трассы с ошибками (Tempo)', 'datasource': TEMPO,
'description': 'TraceQL { status = error }: ошибки HTTP 5xx, повторы и отказы обработки заданий.',
'targets': [{'refId': 'A', 'datasource': TEMPO, 'queryType': 'traceql', 'query': '{ status = error }',
'limit': 20, 'tableType': 'traces'}]},
], h=10)
dashboard = {
'uid': 'messenger-lab6', 'title': 'Messenger lab6', 'tags': ['messenger', 'lab6', 'slo'],
'description': 'API, worker, очередь, насыщение, SLO/burn rate, telemetry pipeline. Морару С. С., БПИ2303.',
'timezone': 'browser', 'refresh': '10s', 'schemaVersion': 41, 'version': 1, 'editable': False,
'time': {'from': 'now-1h', 'to': 'now'}, 'templating': {'list': []}, 'annotations': {'list': []},
'panels': panels,
}
out = Path(__file__).with_name('dashboards') / 'messenger.json'
out.write_text(json.dumps(dashboard, ensure_ascii=False, indent=2) + '\n')
print(f'{out}: {sum(p["type"] != "row" for p in panels)} panels')
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,12 @@
# Dashboards из Git (infra/grafana/dashboards/*.json) — импортируются без ручного набора, правка в UI не сохраняется.
apiVersion: 1
providers:
- name: messenger
folder: Messenger
type: file
disableDeletion: true
allowUiUpdates: false
updateIntervalSeconds: 30
options:
path: /var/lib/grafana/dashboards
@@ -0,0 +1,63 @@
# Источники данных Grafana (импортируются при старте, правка в UI запрещена). Grafana сама ничего не хранит:
# метрики — Prometheus, логи — Loki, трассы — Tempo. Связи: trace → логи этого trace (Tempo → Loki по trace_id),
# лог → trace (derived field trace_id из structured metadata Loki), alerts — правила Prometheus.
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: http://prometheus:9090
isDefault: true
editable: false
jsonData:
timeInterval: 10s
httpMethod: POST
manageAlerts: true # правила Prometheus видны в Grafana Alerting (только чтение)
- name: Loki
uid: loki
type: loki
access: proxy
url: http://loki:3100
editable: false
jsonData:
maxLines: 1000
derivedFields:
- name: trace_id
matcherType: label
matcherRegex: trace_id
datasourceUid: tempo
url: '$${__value.raw}'
urlDisplayLabel: Открыть trace
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: http://tempo:3200
editable: false
jsonData:
nodeGraph:
enabled: true
search:
hide: false
lokiSearch:
datasourceUid: loki
tracesToLogsV2:
datasourceUid: loki
spanStartTimeShift: -5m
spanEndTimeShift: 5m
customQuery: true
query: '{service_name=~"messenger-.+"} | trace_id="$${__trace.traceId}"'
tracesToMetrics:
datasourceUid: prometheus
spanStartTimeShift: -5m
spanEndTimeShift: 5m
tags:
- key: service.name
value: job
queries:
- name: p99 HTTP API
query: histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{$$__tags}[5m])))
+56
View File
@@ -0,0 +1,56 @@
# Единственная публичная точка входа. Реплики находятся через Docker DNS (имя сервиса "api"),
# поэтому `docker compose up --scale api=N` не требует правки конфига (до 8 реплик).
global
log stdout format raw local0 info
maxconn 4096
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 2
timeout resolve 1s
timeout retry 500ms
hold valid 1s
hold other 1s
hold refused 1s
hold nx 1s
hold timeout 1s
hold obsolete 1s
defaults
mode http
log global
option httplog
option dontlog-normal # логируем только ошибки и смену состояния реплик
timeout connect 1s
timeout client 30s
timeout server 10s
timeout http-request 10s
timeout http-keep-alive 10s
timeout check 1s
# Повторяется только запрос, не дошедший до реплики (отказ или таймаут соединения), последняя попытка —
# на другой реплике. Уже отправленные запросы НЕ повторяются: POST /users и /chats не идемпотентны.
retries 2
retry-on conn-failure
option redispatch 1
frontend public
bind :8080
default_backend api
backend api
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
# Активная проверка раз в 1 с (0.5 с при смене состояния): 2 неудачи → DOWN, 2 успеха → UP.
# Отказ соединения на живом трафике сразу помечает реплику DOWN (observe layer4).
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 observe layer4 error-limit 1 on-error mark-down resolvers docker init-addr none
server-template api 8 api:8080
# Для оператора (compose публикует только на 127.0.0.1): /stats и Prometheus /metrics.
frontend stats
bind :8404
http-request use-service prometheus-exporter if { path /metrics }
stats enable
stats uri /stats
stats refresh 2s
+59
View File
@@ -0,0 +1,59 @@
# Loki 3.7.9 — хранилище логов (монолит, файловая система в volume loki-data, WAL переживает перезапуск).
# Логи приходят от Collector по OTLP (/otlp/v1/logs). Index labels — только ресурсные атрибуты низкой
# кардинальности (service_name, service_instance_id, deployment_environment_name); event, request_id, trace_id,
# span_id, severity и прочие атрибуты записи — structured metadata, по ним фильтруют: | trace_id="…".
auth_enabled: false
server:
http_listen_port: 3100
grpc_listen_port: 9095
log_level: warn
common:
instance_addr: 127.0.0.1
path_prefix: /loki
replication_factor: 1
ring:
kvstore:
store: inmemory
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
schema_config:
configs:
- from: "2026-01-01"
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
ingester:
wal:
dir: /loki/wal
limits_config:
retention_period: 168h # 7 дней истории логов
allow_structured_metadata: true
volume_enabled: true
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
query_range:
results_cache:
cache:
embedded_cache:
enabled: true
max_size_mb: 32 # контейнер 384m
pattern_ingester:
enabled: false
analytics:
reporting_enabled: false
+110
View File
@@ -0,0 +1,110 @@
# OpenTelemetry Collector (contrib 0.163.2) — получатель, обработчик и экспортёр, не хранилище.
# receivers: otlp (HTTP :4318) от api и worker; prometheus — скрейп метрик RabbitMQ (очередь), HAProxy и самого
# Collector (otelcol_*: принятые/отправленные/потерянные данные, очередь экспортёров, RSS).
# processors: memory_limiter (первым: при 200 MiB отказывает в приёме, а не растёт до OOM), redaction
# (страховка: маскирует значения, похожие на секреты), batch.
# exporters: traces → Tempo (OTLP gRPC), logs → Loki (OTLP HTTP /otlp), metrics → Prometheus (OTLP receiver).
# Недоступный backend: данные ждут в ограниченной очереди в памяти (20 000 элементов на экспортёр), повтор с
# backoff до 60 с, затем отбрасываются и считаются (otelcol_exporter_send_failed_*, otelcol_exporter_enqueue_failed_*).
# Приложение от Collector не зависит: SDK отбрасывает данные при недоступности, запросы не ждут.
extensions:
health_check:
endpoint: 0.0.0.0:13133
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318 # сети backend и telemetry (internal), на хост не публикуется
prometheus:
config:
global:
scrape_interval: 10s
scrape_timeout: 5s
scrape_configs:
# Очередь attachments.process: messages_ready/unacked и число consumers (per-object метрики vhost messenger).
- job_name: rabbitmq
metrics_path: /metrics/detailed
params:
family: [queue_coarse_metrics, queue_consumer_count]
vhost: [messenger]
static_configs:
- targets: [rabbitmq:15692]
- job_name: haproxy
static_configs:
- targets: [lb:8404]
- job_name: otelcol
static_configs:
- targets: [127.0.0.1:8888]
processors:
memory_limiter:
check_interval: 1s
limit_mib: 200 # контейнер 256m, GOMEMLIMIT 180MiB
spike_limit_mib: 40
redaction:
allow_all_keys: true
blocked_key_patterns: ['(?i).*(authorization|password|passwd|secret|token|cookie).*']
blocked_values:
- '(?i)bearer\s+[a-z0-9._~+/=-]{8,}'
- '(?i)basic\s+[a-z0-9+/=]{8,}'
summary: silent
batch:
send_batch_size: 1024
send_batch_max_size: 2048
timeout: 2s
exporters:
otlp_grpc/tempo:
endpoint: tempo:4317
tls:
insecure: true # внутренняя сеть telemetry; TLS/mTLS — lab7
sending_queue: &queue
enabled: true
sizer: items
queue_size: 20000
num_consumers: 2
retry_on_failure: &retry
enabled: true
initial_interval: 1s
max_interval: 10s
max_elapsed_time: 60s
otlp_http/loki:
endpoint: http://loki:3100/otlp
sending_queue: *queue
retry_on_failure: *retry
otlp_http/prometheus:
endpoint: http://prometheus:9090/api/v1/otlp
sending_queue: *queue
retry_on_failure: *retry
service:
extensions: [health_check]
telemetry:
# Постоянные job/instance для otelcol_* (по умолчанию instance — новый UUID при каждом старте).
resource:
service.name: otel-collector
service.instance.id: otel-collector
logs:
level: info
metrics:
level: normal
readers:
- pull:
exporter:
prometheus:
host: 127.0.0.1 # только для собственного скрейпа (job otelcol выше)
port: 8888
pipelines:
traces:
receivers: [otlp]
processors: [memory_limiter, redaction, batch]
exporters: [otlp_grpc/tempo]
logs:
receivers: [otlp]
processors: [memory_limiter, redaction, batch]
exporters: [otlp_http/loki]
metrics:
receivers: [otlp, prometheus]
processors: [memory_limiter, batch]
exporters: [otlp_http/prometheus]
+30
View File
@@ -0,0 +1,30 @@
# Prometheus v3.15.1 — хранилище метрик (TSDB в volume prometheus-data) и вычисление правил/alerts.
# Метрики api, worker, RabbitMQ, HAProxy и Collector приходят от Collector по OTLP (--web.enable-otlp-receiver,
# /api/v1/otlp/v1/metrics); сам Prometheus скрейпит только соседей по сети telemetry.
# Имена OTLP → Prometheus: точки → «_», суффикс единицы и _total (http.server.request.duration →
# http_server_request_duration_seconds_bucket); service.name → job, service.instance.id → instance.
global:
scrape_interval: 10s
evaluation_interval: 10s
rule_files:
- /etc/prometheus/rules/*.yml
otlp:
translation_strategy: UnderscoreEscapingWithSuffixes
storage:
tsdb:
# Пакеты OTLP от разных реплик приходят с задержкой Collector (batch 2 с, повтор до 60 с).
out_of_order_time_window: 10m
scrape_configs:
- job_name: prometheus
static_configs:
- targets: [127.0.0.1:9090]
- job_name: loki
static_configs:
- targets: [loki:3100]
- job_name: tempo
static_configs:
- targets: [tempo:3200]
+60
View File
@@ -0,0 +1,60 @@
# Alerts уровня 4 (contracts/observability.md): высокий error rate, растущий queue lag, насыщение пула БД,
# сбой экспорта telemetry. Доставка наружу не настроена: состояние pending/firing и снятие видны в Prometheus
# (/alerts, серия ALERTS) и на dashboard «Messenger lab6». Runbook: infra/runbooks.md.
groups:
- name: messenger-alerts
rules:
# Простой порог по 5-минутному окну того же SLI (5xx у клиентов, HAProxy). Ловит и короткий всплеск, который
# почти не тратит месячный бюджет, — поэтому severity warning; страницу дают burn-rate alerts из slo.yml
# (сравнение — трек 2 в REPORT.md).
- alert: ApiHighErrorRate
expr: slo:api_error_ratio:rate5m > 0.05
for: 2m
labels:
severity: warning
annotations:
summary: "Более 5 % ответов API — 5xx (окно 5 минут, держится 2 минуты)"
description: "Доля 5xx в ответах клиентам (HAProxy): {{ $value | humanizePercentage }}."
runbook_url: "infra/runbooks.md#api-high-error-rate"
# Возраст старейшего незавершённого задания (от durable acceptance). В норме — секунды; при остановленном
# или перегруженном worker растёт линейно со временем. Backlog (количество) — отдельная панель.
- alert: JobQueueLagGrowing
expr: max by (queue) (messenger_jobs_oldest_age_seconds) > 60
for: 1m
labels:
severity: page
annotations:
summary: "Задания очереди {{ $labels.queue }} ждут дольше минуты"
description: "Старейшее незавершённое задание принято {{ $value | humanizeDuration }} назад."
runbook_url: "infra/runbooks.md#job-queue-lag"
# Пул соединений PostgreSQL исчерпан: запросы ждут соединения (затем 503 через 2 с). Признак медленной или
# недоступной БД — в отличие от медленного обработчика HTTP, при котором ожидающих соединений нет.
- alert: DbPoolSaturated
expr: max by (job, instance) (db_client_connection_pending_requests) > 0
for: 1m
labels:
severity: warning
annotations:
summary: "{{ $labels.job }} {{ $labels.instance }}: запросы ждут соединения с PostgreSQL"
description: "В очереди пула {{ $value }} запросов дольше минуты."
runbook_url: "infra/runbooks.md#db-pool-saturated"
# Collector не может отдать данные в Tempo/Loki/Prometheus: очередь экспортёра растёт, после 60 с повторов
# данные отбрасываются. Сообщения при этом работают — теряется только telemetry.
- alert: TelemetryExportFailing
expr: |
(
sum by (exporter) (rate(otelcol_exporter_send_failed_spans_total[5m]))
or sum by (exporter) (rate(otelcol_exporter_send_failed_log_records_total[5m]))
or sum by (exporter) (rate(otelcol_exporter_send_failed_metric_points_total[5m]))
) > 0
or max by (exporter) (otelcol_exporter_queue_size) > 1000
for: 1m
labels:
severity: warning
annotations:
summary: "Collector не экспортирует telemetry через {{ $labels.exporter }}"
description: "Отбрасывается или копится в очереди {{ $value }} (элементов/с или элементов в очереди)."
runbook_url: "infra/runbooks.md#telemetry-export-failing"
+131
View File
@@ -0,0 +1,131 @@
# SLO и multiwindow multi-burn-rate alerts (трек 2). Обоснование и runbook — REPORT.md, infra/runbooks.md.
#
# SLO-1 «доступность API»: 99.5 % запросов клиентов за 30 дней без 5xx. SLI = 1 − 5xx / все ответы, измеренные на
# HAProxy (frontend public) — там, где их получает клиент. Метрики самого API (http.server.request.duration) этого
# не видят: при недоступной БД реплики выходят из ротации по readiness, и HAProxy отвечает 503 «нет готовых реплик»
# сам, а при зависании отвечает 504 по timeout server — запрос до API не доходит или его исход API пишет позже.
# Проверено: PostgreSQL на 0.05 CPU — 101 ответ 5xx в метриках API против 190 у клиентов. Проверки здоровья HAProxy
# идут напрямую к репликам и в трафик frontend не входят; 4xx — ошибка клиента, не сервиса.
# Бюджет ошибок 0.5 % = 216 минут полного отказа за 30 дней.
# SLO-2 «время до ready»: 99 % принятых вложений публикуются ready не позже 30 с от durable acceptance (30 дней).
# Плохое событие — ready позже 30 с или терминальный failed по вине системы (retry_exhausted, source_*,
# processing_timeout); invalid_image/unsupported_pipeline — свойство входного файла, в SLI не входят.
# Новые серии OTLP-счётчиков (первое событие после старта worker) начинаются с нулевой точки
# (--enable-feature=created-timestamp-zero-ingestion) — первое событие не теряется в rate().
#
# Burn rate = доля ошибок / бюджет. Окна и пороги — SRE Workbook, гл. 5: alert, если за длинное окно израсходовано
# столько бюджета, а короткое окно (1/12 длинного) подтверждает, что расход продолжается (быстрый resolve):
# fast: 1h и 5m, burn > 14.4 → 2 % месячного бюджета за час (page);
# slow: 6h и 30m, burn > 6 → 5 % месячного бюджета за 6 часов (ticket).
groups:
- name: slo-api-availability
rules:
- record: slo:api_requests:rate5m
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[5m]))
- record: slo:api_errors:rate5m
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[5m]))
- record: slo:api_error_ratio:rate5m
expr: slo:api_errors:rate5m / slo:api_requests:rate5m
- record: slo:api_requests:rate30m
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[30m]))
- record: slo:api_errors:rate30m
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[30m]))
- record: slo:api_error_ratio:rate30m
expr: slo:api_errors:rate30m / slo:api_requests:rate30m
- record: slo:api_requests:rate1h
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[1h]))
- record: slo:api_errors:rate1h
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[1h]))
- record: slo:api_error_ratio:rate1h
expr: slo:api_errors:rate1h / slo:api_requests:rate1h
- record: slo:api_requests:rate6h
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[6h]))
- record: slo:api_errors:rate6h
expr: sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[6h]))
- record: slo:api_error_ratio:rate6h
expr: slo:api_errors:rate6h / slo:api_requests:rate6h
- name: slo-ready-latency
rules:
- record: slo:ready_events:rate5m
expr: sum(rate(messenger_attachment_time_to_ready_seconds_count{error_type!~"invalid_image|unsupported_pipeline"}[5m]))
- record: slo:ready_good:rate5m
expr: sum(rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready",le="30"}[5m])) or vector(0)
- record: slo:ready_bad_ratio:rate5m
expr: 1 - slo:ready_good:rate5m / slo:ready_events:rate5m
- record: slo:ready_events:rate30m
expr: sum(rate(messenger_attachment_time_to_ready_seconds_count{error_type!~"invalid_image|unsupported_pipeline"}[30m]))
- record: slo:ready_good:rate30m
expr: sum(rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready",le="30"}[30m])) or vector(0)
- record: slo:ready_bad_ratio:rate30m
expr: 1 - slo:ready_good:rate30m / slo:ready_events:rate30m
- record: slo:ready_events:rate1h
expr: sum(rate(messenger_attachment_time_to_ready_seconds_count{error_type!~"invalid_image|unsupported_pipeline"}[1h]))
- record: slo:ready_good:rate1h
expr: sum(rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready",le="30"}[1h])) or vector(0)
- record: slo:ready_bad_ratio:rate1h
expr: 1 - slo:ready_good:rate1h / slo:ready_events:rate1h
- record: slo:ready_events:rate6h
expr: sum(rate(messenger_attachment_time_to_ready_seconds_count{error_type!~"invalid_image|unsupported_pipeline"}[6h]))
- record: slo:ready_good:rate6h
expr: sum(rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready",le="30"}[6h])) or vector(0)
- record: slo:ready_bad_ratio:rate6h
expr: 1 - slo:ready_good:rate6h / slo:ready_events:rate6h
# Остаток бюджета за 30 дней для dashboard (на стенде — за всю доступную историю). Тяжёлое окно — раз в 5 минут.
- name: slo-budget
interval: 5m
rules:
- record: slo:api_error_ratio:rate30d
expr: |
sum(increase(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[30d]))
/ sum(increase(haproxy_frontend_http_responses_total{proxy="public"}[30d]))
- record: slo:ready_bad_ratio:rate30d
expr: |
1 - (sum(increase(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready",le="30"}[30d])) or vector(0))
/ sum(increase(messenger_attachment_time_to_ready_seconds_count{error_type!~"invalid_image|unsupported_pipeline"}[30d]))
- name: slo-burn-rate-alerts
rules:
- alert: ApiAvailabilityFastBurn
expr: slo:api_error_ratio:rate1h > (14.4 * 0.005) and slo:api_error_ratio:rate5m > (14.4 * 0.005)
labels:
severity: page
slo: api-availability
annotations:
summary: "API быстро сжигает бюджет ошибок (burn rate > 14.4 за 1h и 5m)"
description: "Доля 5xx у клиентов (HAProxy) за 1 ч {{ $value | humanizePercentage }} при SLO 99.5 %: 2 % месячного бюджета уходит за час."
runbook_url: "infra/runbooks.md#api-availability-burn"
- alert: ApiAvailabilitySlowBurn
expr: slo:api_error_ratio:rate6h > (6 * 0.005) and slo:api_error_ratio:rate30m > (6 * 0.005)
labels:
severity: ticket
slo: api-availability
annotations:
summary: "API медленно сжигает бюджет ошибок (burn rate > 6 за 6h и 30m)"
description: "Доля 5xx за 6 ч {{ $value | humanizePercentage }}: 5 % месячного бюджета за 6 часов."
runbook_url: "infra/runbooks.md#api-availability-burn"
- alert: ReadyLatencyFastBurn
expr: slo:ready_bad_ratio:rate1h > (14.4 * 0.01) and slo:ready_bad_ratio:rate5m > (14.4 * 0.01)
labels:
severity: page
slo: ready-latency
annotations:
summary: "Вложения не успевают стать ready за 30 с (burn rate > 14.4 за 1h и 5m)"
description: "Доля вложений позже 30 с или failed за 1 ч {{ $value | humanizePercentage }} при SLO 99 %."
runbook_url: "infra/runbooks.md#ready-latency-burn"
- alert: ReadyLatencySlowBurn
expr: slo:ready_bad_ratio:rate6h > (6 * 0.01) and slo:ready_bad_ratio:rate30m > (6 * 0.01)
labels:
severity: ticket
slo: ready-latency
annotations:
summary: "Медленный расход бюджета SLO time-to-ready (burn rate > 6 за 6h и 30m)"
description: "Доля вложений позже 30 с или failed за 6 ч {{ $value | humanizePercentage }}."
runbook_url: "infra/runbooks.md#ready-latency-burn"
+143
View File
@@ -0,0 +1,143 @@
# Unit-тесты правил (трек 2): синтетические счётчики → когда alert переходит в firing и когда снимается.
# Запуск: docker run --rm -v "$PWD/infra/prometheus:/etc/prometheus:ro" --entrypoint promtool \
# prom/prometheus:v3.15.1 test rules /etc/prometheus/tests/alerts.test.yml
# Трафик API (ответы HAProxy frontend public) 10 запросов/с (600 в минуту). Перед каждым инцидентом 6 часов нормальной истории (t = 0…360 мин), чтобы
# 6-часовое окно slow burn видело реальный знаменатель. Ожидаемые моменты посчитаны в комментариях.
rule_files:
- ../rules/slo.yml
- ../rules/messenger.yml
evaluation_interval: 1m
tests:
# 1. Краткий всплеск: 1 минута 100 % 5xx (≈ 0.03 % месячного бюджета). Простой порог даёт срабатывание,
# burn-rate alerts молчат: за час доля 5xx 600/36000 = 1.7 % < 7.2 % (14.4 × 0.5 %).
- name: short spike — only the naive threshold fires
interval: 1m
input_series:
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="2xx"}'
values: '0+600x360 216000 216600+600x60'
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="5xx"}'
values: '0x360 600x62'
promql_expr_test:
- expr: ALERTS{alertname="ApiHighErrorRate",alertstate="firing"}
eval_time: 364m # pending с 361, firing с 363 (for 2m)
exp_samples:
- labels: 'ALERTS{alertname="ApiHighErrorRate",alertstate="firing",severity="warning"}'
value: 1
- expr: ALERTS{alertname=~"ApiAvailability.*",alertstate="firing"}
eval_time: 364m
exp_samples: []
- expr: ALERTS{alertstate="firing"}
eval_time: 370m # всплеск вышел из 5-минутного окна — снято
exp_samples: []
# 2. Длительная деградация: 30 % 5xx в течение часа (t = 360…420).
# fast: доля за 1h = (t−360)/200 > 0.072 → firing на 15-й минуте (t = 375); снимается, когда 5m-окно < 7.2 % (t = 424).
# slow: доля за 6h = (t−360)/1200 > 0.03 → firing на 37-й минуте (t = 397); снимается по 30m-окну (t = 448).
- name: long degradation — fast then slow burn, short windows resolve them
interval: 1m
input_series:
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="2xx"}'
values: '0+600x360 216420+420x59 241800+600x119'
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="5xx"}'
values: '0x360 180+180x59 10800x120'
promql_expr_test:
- expr: ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing"}
eval_time: 374m
exp_samples: []
- expr: ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing"}
eval_time: 376m
exp_samples:
- labels: 'ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing",severity="page",slo="api-availability"}'
value: 1
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 395m
exp_samples: []
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 398m
exp_samples:
- labels: 'ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing",severity="ticket",slo="api-availability"}'
value: 1
- expr: ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing"}
eval_time: 422m # ошибки кончились в 420, но 5m-окно ещё выше порога
exp_samples:
- labels: 'ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing",severity="page",slo="api-availability"}'
value: 1
- expr: ALERTS{alertname="ApiAvailabilityFastBurn",alertstate="firing"}
eval_time: 426m # доля за 1h ещё 27 %, но короткое окно сняло alert
exp_samples: []
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 446m
exp_samples:
- labels: 'ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing",severity="ticket",slo="api-availability"}'
value: 1
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 449m
exp_samples: []
# 3. Медленное тление: 5 % 5xx шесть часов. Быстрый alert не срабатывает никогда (5 % < 7.2 %),
# медленный — когда доля за 6h превысит 3 %: 30(t−360)/216000 > 0.03 → t = 577 (через 3 ч 37 мин).
- name: slow burn only
interval: 1m
input_series:
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="2xx"}'
values: '0+600x360 216570+570x359'
- series: 'haproxy_frontend_http_responses_total{job="haproxy",instance="lb:8404",proxy="public",code="5xx"}'
values: '0x360 30+30x359'
promql_expr_test:
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 575m
exp_samples: []
- expr: ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing"}
eval_time: 578m
exp_samples:
- labels: 'ALERTS{alertname="ApiAvailabilitySlowBurn",alertstate="firing",severity="ticket",slo="api-availability"}'
value: 1
- expr: ALERTS{alertname="ApiAvailabilityFastBurn"}
eval_time: 600m
exp_samples: []
# 4. SLO time-to-ready: 60 загрузок в минуту; 30 минут половина вложений готова позже 30 с.
# fast: доля плохих за 1h = (t−360)/120 > 0.144 → t = 378; slow: за 6h максимум 30/720 = 4.2 % < 6 % — нет.
- name: ready latency fast burn
interval: 1m
input_series:
- series: 'messenger_attachment_time_to_ready_seconds_count{job="messenger-worker",instance="w",job_type="attachment.process.v1",outcome="ready"}'
values: '0+60x450'
- series: 'messenger_attachment_time_to_ready_seconds_bucket{job="messenger-worker",instance="w",job_type="attachment.process.v1",outcome="ready",le="30"}'
values: '0+60x360 21630+30x29 22560+60x60'
promql_expr_test:
- expr: ALERTS{alertname="ReadyLatencyFastBurn",alertstate="firing"}
eval_time: 376m
exp_samples: []
- expr: ALERTS{alertname="ReadyLatencyFastBurn",alertstate="firing"}
eval_time: 379m
exp_samples:
- labels: 'ALERTS{alertname="ReadyLatencyFastBurn",alertstate="firing",severity="page",slo="ready-latency"}'
value: 1
- expr: ALERTS{alertname="ReadyLatencySlowBurn"}
eval_time: 390m
exp_samples: []
# 5. Worker остановлен на 10 минут: возраст старейшего задания растёт на 60 с в минуту.
# > 60 с с t = 12 (pending), firing с t = 13 (for 1m); после запуска worker (t = 22) — снято.
- name: queue lag
interval: 1m
input_series:
- series: 'messenger_jobs_oldest_age_seconds{job="messenger-api",instance="a",queue="attachments.process"}'
values: '1x10 60+60x10 1x10'
- series: 'messenger_jobs_oldest_age_seconds{job="messenger-api",instance="b",queue="attachments.process"}'
values: '1x10 60+60x10 1x10'
promql_expr_test:
- expr: ALERTS{alertname="JobQueueLagGrowing",alertstate="firing"}
eval_time: 12m
exp_samples: []
- expr: ALERTS{alertname="JobQueueLagGrowing",alertstate="firing"}
eval_time: 13m
exp_samples:
- labels: 'ALERTS{alertname="JobQueueLagGrowing",alertstate="firing",queue="attachments.process",severity="page"}'
value: 1
- expr: ALERTS{alertname="JobQueueLagGrowing"}
eval_time: 23m
exp_samples: []
+12
View File
@@ -0,0 +1,12 @@
# Монтируется в /etc/rabbitmq/conf.d/90-messenger.conf: файлы conf.d читаются по алфавиту, этот — последним.
# Пользователи, vhost messenger, exchange, quorum-очередь и binding — из definitions (scripts/init-secrets.sh),
# импорт при каждом старте узла. При импорте definitions пользователь guest не создаётся.
load_definitions = /run/secrets/rabbitmq_definitions
# Образ разрешает guest из сети (10-defaults.conf); возвращаем безопасное значение на случай его появления.
loopback_users.guest = true
# Сообщение без ack дольше 5 минут: брокер закрывает канал consumer и отдаёт сообщение снова.
# Это страховка брокера; зависшую попытку раньше (JOB_TIMEOUT_SECONDS + 15 с) обнаруживает аренда в БД.
consumer_timeout = 300000
# При нехватке диска брокер блокирует публикацию — API продолжает принимать файлы, задания ждут в outbox.
disk_free_limit.absolute = 256MB
log.console.level = info
+173
View File
@@ -0,0 +1,173 @@
# Runbooks lab6
Локальные runbook для alert rules из `infra/prometheus/rules/` (ссылка — аннотация `runbook_url` каждого alert).
Заголовки разделов — якоря этих ссылок. Автор: Морару С. С., БПИ2303.
## Как начать
- Grafana: `http://127.0.0.1:${GRAFANA_PORT}` (в `.env` стенда — 3096), пользователь `admin`, пароль — файл
`secrets/grafana_admin_password` (не копируйте его в чат/отчёт). Prometheus, Loki и Tempo на хост не опубликованы:
запросы — через Grafana → Explore.
- Dashboard «Messenger lab6» (папка Messenger). Состояние alerts: панель «Alerts (pending / firing)» и
Grafana → Alerting → Alert rules (правила источника Prometheus); серия `ALERTS` в Explore.
- Все команды — из корня репозитория; они касаются только проекта `messenger-lab6`.
Общий путь от симптома к причине: **метрика** говорит «что и насколько» (какой маршрут, какой статус, какая очередь),
**trace** — «где тратится время или возникает ошибка» (какая зависимость), **лог** — «что именно случилось»
(событие, `error.type`, `request_id`). Переход: лог → trace по `trace_id` (кнопка Tempo у строки лога),
trace → логи по кнопке «Logs for this span», ответ клиента → лог по `X-Request-Id` (`| request_id="…"`).
Где тратится время в trace запроса API:
| Что длинное или с ошибкой | Причина | Дальше |
| --- | --- | --- |
| `pg-pool.connect` | нет свободного соединения в пуле: БД медленная/недоступна или пул мал | сначала «Event loop: задержка p99» этой реплики (см. ниже), затем [db-pool-saturated](#db-pool-saturated) |
| `pg.query:*` | сам запрос в PostgreSQL: блокировка, нагрузка на CPU БД, недоступность | так же |
| `S3.*` | SeaweedFS (s3 gateway) завис или недоступен | `docker compose ps s3 seaweedfs` |
| SERVER span длинный, дочерние короткие, между ними «дыры» | синхронная работа в обработчике (event loop занят) | панели «Event loop: задержка p99», «CPU процессов» |
| span без дочерних, статус 5xx | ошибка в коде (`http.internal_error`) | событие `exception` в span, лог по `trace_id` |
**Ловушка (проверено в кампании трека 2, фаза handler-slow).** Если процессу API не хватает CPU, длинными выглядят
именно `pg-pool.connect` и `pg.query:*`: время span — до вызова callback, а callback ждёт свободный event loop. Trace
такого запроса неотличим от медленной БД (медиана 19 медленных trace: 898 мс, из них SQL 600 мс, «своё» время 4 мс). Поэтому до
вывода «виновата БД» сравните реплику из trace (`service.instance.id`) с остальными: задержка event loop в секундах
и CPU у лимита контейнера у одной реплики — это процесс, а не БД.
## api-availability-burn
**Alerts:** `ApiAvailabilityFastBurn` (severity page), `ApiAvailabilitySlowBurn` (severity ticket).
SLO: 99.5 % запросов клиентов без 5xx за 30 дней; бюджет — 0.5 % ответов. SLI считается на HAProxy (frontend
`public`, метрика `haproxy_frontend_http_responses_total`): так в него попадают и ответы самого LB — 503, когда
ни одна реплика не готова (readiness зависит от PostgreSQL), и 504 по таймауту. Burn rate — во сколько раз доля
5xx выше бюджета. Fast: за 1 ч **и** за 5 мин доля 5xx > 14.4 × 0.5 % = 7.2 % — за час
сгорает 2 % месячного бюджета, при таком темпе весь бюджет кончится за 2 дня. Slow: за 6 ч **и** за 30 мин
доля > 6 × 0.5 % = 3 % (5 % бюджета за 6 ч). Короткое окно снимает alert вскоре после восстановления.
1. Dashboard, ряд «API»: панели «Доля 5xx» и «RPS по классу статуса». Если линия «у клиентов (HAProxy)» заметно выше
линии «в метриках API» — отвечает сам LB: реплики вне ротации (readiness → БД, см. db-pool-saturated) или
зависают дольше 10 с (504). Проверка: `docker compose ps api lb`, страница HAProxy `/stats`
(`http://127.0.0.1:${LB_STATS_PORT}/stats`) — состояние UP/DOWN реплик.
2. Какой маршрут и какой код (Explore → Prometheus):
`sum by (http_route, http_response_status_code) (rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[5m]))`.
503 — недоступна зависимость, 500 — ошибка кода.
3. Логи (Explore → Loki): `{service_name="messenger-api"} | severity_text="ERROR"`. Событие
`http.dependency_unavailable` (503) — поле `error.type` (код PostgreSQL/Node, например `57014` — statement
timeout, `ECONNREFUSED`, `Error` — таймаут ожидания пула); `http.internal_error` (500) — баг.
4. Из строки лога — trace (`trace_id`) и таблица выше: какая зависимость. Поиск таких trace сразу в Tempo:
`{ resource.service.name = "messenger-api" && kind = server && status = error }`.
5. Ветки: PostgreSQL → [db-pool-saturated](#db-pool-saturated); S3 — `docker compose ps s3 seaweedfs`,
`docker compose logs --tail 50 s3`; баг — стек в событии `exception` span.
Восстановление: после устранения причины доля 5xx за 5 мин падает ниже 7.2 % — fast снимается через ~5 мин;
slow — когда доля за 30 мин < 3 %. Остаток бюджета — панель «Остаток бюджета API (30 д)».
## ready-latency-burn
**Alerts:** `ReadyLatencyFastBurn` (page), `ReadyLatencySlowBurn` (ticket).
SLO: 99 % вложений становятся `ready` не позже 30 с после durable acceptance (коммит upload в БД). SLI —
гистограмма `messenger_attachment_time_to_ready_seconds` (хорошие — `outcome="ready"`, `le="30"`; плохие — ready
позже 30 с и `failed` из-за временных сбоев; постоянные `invalid_image`/`unsupported_pipeline` — свойство файла,
в SLI не входят). Пороги: fast — 1 ч и 5 мин > 14.4 %, slow — 6 ч и 30 мин > 6 % плохих.
1. Ряд «Worker и задания»: «Возраст старейшего задания» (линия «consumers» — подписчики очереди) и «Очередь: backlog».
Consumers = 0 или возраст растёт линейно → [job-queue-lag](#job-queue-lag).
2. «Насыщение worker (busy / capacity)» около 100 % и растущий backlog → не хватает мощности: «Длительность
обработки job (done)» p95, «CPU процессов» worker. Обработка медленнее поступления — масштабировать
`WORKER_REPLICAS` (`docker compose up -d --scale worker=3`).
3. «Jobs/с по исходу»: доля `retry`/`failed`. Логи: `{service_name="messenger-worker"} | event=~"job.retry|job.failed"` —
`error.type` (`storage_unavailable` — S3, `database_unavailable` — PostgreSQL). Каждый retry добавляет backoff
2–4–8… с к времени до ready.
4. Линия «outbox без confirm» на панели «Очередь: backlog» растёт при пустой очереди RabbitMQ → задания не публикуются: брокер недоступен (`docker compose ps rabbitmq`,
логи API `| event=~"relay.*"`).
5. Конкретное медленное вложение: в Tempo `{ resource.service.name = "messenger-worker" && kind = consumer && duration > 10s }`
или `{ span.messenger.attachment.id = "<uuid>" }` — в одном trace видны upload, все публикации и попытки.
Восстановление — как в [api-availability-burn](#api-availability-burn): короткое окно (5 мин / 30 мин) снимает alert.
## api-high-error-rate
**Alert:** `ApiHighErrorRate` (warning): доля 5xx за 5 мин > 5 % держится 2 мин.
Простой порог без учёта бюджета: срабатывает и на короткий всплеск, который почти не тратит месячный бюджет
(сравнение с burn-rate — REPORT.md, трек 2). Если одновременно горит `ApiAvailabilityFastBurn` — действуйте по
[api-availability-burn](#api-availability-burn). Если горит только он — короткий инцидент: найдите причину теми же
шагами 1–4 (окно 15 мин вокруг всплеска) и проверьте, что он закончился (доля 5xx вернулась к нулю).
## job-queue-lag
**Alert:** `JobQueueLagGrowing` (page): старейшее незавершённое задание принято больше 60 с назад, держится 1 мин.
Метрика `messenger_jobs_oldest_age_seconds` (из таблицы `jobs`, считает API) растёт на 1 с за секунду, если задания
не обрабатываются.
1. Подписчики очереди — линия «consumers» на панели «Возраст старейшего задания»
(`sum(rabbitmq_detailed_queue_consumers{queue="attachments.process"})`).
`0` → worker не работает: `docker compose ps -a worker`; причина остановки —
`docker compose logs --tail 50 worker`, `docker inspect -f '{{.State.OOMKilled}} {{.State.ExitCode}}' messenger-lab6-worker-1`.
2. Consumers > 0, «Насыщение worker» ≈ 100 % → перегрузка (см. ready-latency-burn, шаг 2).
3. Consumers > 0, насыщение низкое, `messages_ready` ≈ 0, а возраст растёт → задания не доходят до очереди:
линия «outbox без confirm» и логи `relay.*` в API (брокер), либо задания зависли в `processing` — sweeper вернёт их после
истечения аренды (лог `sweeper.recovered`).
4. Проверка по БД:
`docker compose exec -T postgres psql -U messenger -d messenger -c "SELECT state, count(*), round(extract(epoch FROM max(clock_timestamp() - created_at))) AS oldest_s FROM jobs WHERE state IN ('queued','processing') GROUP BY state"`.
Восстановление: `docker compose up -d --no-deps worker` (или устранить причину); backlog уходит, возраст падает
ниже 60 с — alert снимается на следующей оценке правил (интервал 10 с).
## db-pool-saturated
**Alert:** `DbPoolSaturated` (warning): у реплики (`job`, `instance`) запросы ждут соединения из пула дольше 1 мин
(`db_client_connection_pending_requests > 0`). Пул — 8 соединений на процесс; ожидание дольше 2 с → 503.
Как отличить медленную БД от медленного обработчика HTTP:
Значения в скобках — из кампании трека 2 (REPORT.md): PostgreSQL заморожен (`docker compose pause`) и api-1 на 0.1 CPU.
| Сигнал | Медленная/недоступная БД | Медленный handler (CPU API) |
| --- | --- | --- |
| «Event loop: задержка p99» API | норма у всех реплик (0.02–0.03 с) | секунды у одной реплики (api-1 7.3 с, api-2 0.07 с) — **главный признак** |
| «CPU процессов» API | норма (0.05) | у лимита контейнера (0.09 при лимите 0.1) |
| Ответы клиентам | 5xx: 503 API после 2 с ожидания пула, но в основном 503/504 самого HAProxy — реплики выходят из ротации по readiness (1113 из 1177) | медленные 2xx (p99 api-1 5 с), 5xx < 0.5 % |
| «Пул соединений PostgreSQL» | при замороженной БД pending ≈ 0: запросы до API не доходят; при медленной — used = max, pending > 0 у всех реплик | pending до 7 и used = 8 из 8 у одной реплики |
| «p99 запросов к PostgreSQL» | у замороженных запросов нет завершения — histogram молчит до восстановления | растёт у медленной реплики (0.6 с) — это ожидание event loop |
| Trace запроса | `pg-pool.connect` ≈ 2 с и статус 503 | тоже длинные `pg-pool.connect`/`pg.query:*` (ловушка выше) |
| Логи | `http.dependency_unavailable`, `error.type=Error` (таймаут пула), `sweeper.error`, `relay.db_unavailable` | почти пусто |
| Затронуты | все реплики, API и worker | одна реплика (18 из 19 медленных trace) |
`DbPoolSaturated` не помогает отличить: при замороженной БД он молчит (нет нагрузки на пул), при нехватке CPU
pending у реплики скачет и может дойти до firing.
1. Процесс или БД: «Event loop: задержка p99» и «CPU процессов» по репликам. Выброс у одной реплики → её CPU:
`docker stats --no-stream messenger-lab6-api-1 messenger-lab6-api-2`, лимит —
`docker inspect -f '{{.HostConfig.NanoCpus}}' messenger-lab6-api-1` (1e9 = 1 CPU); дальше профиль/нагрузка
этой реплики, БД ни при чём. У всех реплик норма → шаг 2.
2. Состояние PostgreSQL: `docker compose ps postgres` (paused/restarting?), `docker stats --no-stream messenger-lab6-postgres-1`.
3. Что делают соединения:
`docker compose exec -T postgres psql -U messenger -d messenger -c "SELECT pid, wait_event_type, state, round(extract(epoch FROM now() - query_start)) AS s, left(query, 60) FROM pg_stat_activity WHERE datname = 'messenger' AND state <> 'idle' ORDER BY s DESC"`
— долгие транзакции и блокировки (`wait_event_type = Lock`).
4. Логи `{service_name=~"messenger-.+"} | event=~"http.dependency_unavailable|relay.db_unavailable|job.retry"`.
Восстановление: снять блокировку/нагрузку или вернуть БД; pending падает до 0, p99 SQL возвращается к норме.
## telemetry-export-failing
**Alert:** `TelemetryExportFailing` (warning): Collector не отправляет данные в backend (`send_failed` > 0 за 5 мин)
или очередь экспортёра > 1000 элементов, держится 1 мин.
Сообщения и загрузки при этом работают: SDK и Collector отправляют асинхронно. Теряется только telemetry:
очередь экспортёра — 20 000 элементов в памяти, повтор с backoff до 60 с, затем данные отбрасываются и считаются
(`otelcol_exporter_send_failed_*`, при полной очереди — `otelcol_exporter_enqueue_failed_*`).
1. Панели «Потери telemetry» и «Очередь экспортёров»: какой экспортёр (`otlp_grpc/tempo`, `otlp_http/loki`,
`otlp_http/prometheus`).
2. `docker compose ps tempo loki prometheus otel-collector`; ошибки экспорта — `docker compose logs --tail 30 otel-collector`.
3. Память Collector: панель «Память процессов (RSS)», линия collector; отказ приёма memory_limiter —
`otelcol_receiver_refused_*` (контейнер ограничен 256 MiB, лимит memory_limiter 200 MiB).
Ограничение: правило вычисляет Prometheus. Если недоступен сам Prometheus, alert не сработает — это видно по ошибке
источника на dashboard и в `docker compose ps`. Если остановлен Collector, SDK приложений отбрасывают данные
после заполнения своих буферов (2048 spans / log records); работа API не зависит от этого.
Восстановление: запустить backend (`docker compose start tempo`) — очередь опустеет, `send_failed` перестанет
расти, alert снимется, когда 5-минутное окно rate станет нулевым.
+33
View File
@@ -0,0 +1,33 @@
# Tempo 2.10.10 — хранилище трасс (монолит, локальный диск в volume tempo-data; WAL переживает перезапуск).
# Spans приходят от Collector по OTLP gRPC :4317 (сеть telemetry); Grafana читает через HTTP :3200 (TraceQL).
stream_over_http_enabled: true
server:
http_listen_port: 3200
grpc_listen_port: 9095
log_level: warn
distributor:
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
ingester:
max_block_duration: 5m
compactor:
compaction:
block_retention: 168h # 7 дней истории трасс
storage:
trace:
backend: local
wal:
path: /var/tempo/wal
local:
path: /var/tempo/blocks
usage_report:
reporting_enabled: false
+2638
View File
File diff suppressed because it is too large Load Diff
+33
View File
@@ -0,0 +1,33 @@
{
"name": "messenger-lab6",
"private": true,
"version": "6.0.0",
"type": "module",
"engines": {
"node": ">=24"
},
"scripts": {
"start": "node src/main.ts",
"migrate": "node src/main.ts migrate",
"typecheck": "tsc"
},
"dependencies": {
"@aws-sdk/client-s3": "3.1152.0",
"@opentelemetry/api": "1.9.1",
"@opentelemetry/api-logs": "0.223.0",
"@opentelemetry/core": "2.12.0",
"@opentelemetry/instrumentation-aws-sdk": "0.78.0",
"@opentelemetry/instrumentation-http": "0.223.0",
"@opentelemetry/instrumentation-pg": "0.76.0",
"@opentelemetry/instrumentation-runtime-node": "0.36.1",
"@opentelemetry/sdk-node": "0.223.0",
"amqplib": "2.2.0",
"pg": "8.23.1",
"sharp": "0.35.5"
},
"devDependencies": {
"@types/node": "24.19.2",
"@types/pg": "8.23.1",
"typescript": "7.0.2"
}
}
+380
View File
@@ -0,0 +1,380 @@
#!/usr/bin/env python3
"""Трек 2 и инциденты уровня 4: непрерывная нагрузка k6 и ограниченные отказы стенда lab6 по расписанию.
run — нагрузка (scripts/load.sh) + отказы по расписанию PLAN (параллельные дорожки, ~21 мин); журнал — phases.json.
analyze — только по сохранённым наблюдениям (Prometheus, Loki, Tempo через Grafana): когда alerts перешли в
pending/firing/resolved, метрики в окне отказа, разложение медленных trace, события логов, потери
telemetry → summary.json и summary.md.
Отказы трогают только контейнеры проекта messenger-lab6 и снимаются в finally (unpause, start, прежний --cpus).
Запуск: python3 research/campaign.py run --out evidence/track2
python3 research/campaign.py analyze --out evidence/track2"""
import argparse
import json
import os
from pathlib import Path
import signal
import statistics
import subprocess
import sys
import threading
import time
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'student-tests'))
from telemetry_check import Grafana # noqa: E402 (сам добавляет tests/ в sys.path)
C = 'messenger-lab6-' # префикс контейнеров стенда
def sh(*cmd):
r = subprocess.run(cmd, cwd=ROOT, text=True, capture_output=True)
if r.returncode:
raise RuntimeError(f'{" ".join(cmd)}: {r.stderr.strip()[-300:]}')
return r.stdout.strip()
class Phase(dict):
def act(self, what, *cmd):
self['actions'].append([round(time.time(), 1), what])
print(time.strftime('%H:%M:%S'), self['name'], what, flush=True)
sh(*cmd)
# --- Отказы: каждый возвращает управление только после восстановления. ---
def pause(ph, service, seconds):
try:
ph.act(f'pause {service}', 'docker', 'compose', 'pause', service)
time.sleep(seconds)
finally:
ph.act(f'unpause {service}', 'docker', 'compose', 'unpause', service)
def stop_worker(ph, seconds):
try:
ph.act('stop worker', 'docker', 'compose', 'stop', 'worker')
time.sleep(seconds)
finally:
ph.act('start worker', 'docker', 'compose', 'up', '-d', '--no-deps', 'worker')
def cpus(ph, container, value, seconds):
before = int(sh('docker', 'inspect', '-f', '{{.HostConfig.NanoCpus}}', container)) / 1e9
try:
ph.act(f'{container} --cpus {value}', 'docker', 'update', '--cpus', str(value), container)
time.sleep(seconds)
finally:
ph.act(f'{container} --cpus {before:g}', 'docker', 'update', '--cpus', f'{before:g}', container)
def stop_containers(ph, label, names, seconds):
try:
ph.act(f'stop {label}', 'docker', 'stop', *names)
time.sleep(seconds)
finally:
ph.act(f'start {label}', 'docker', 'start', *names)
def duty(ph, fault, down, up, total):
"""fault(ph, down) каждые down + up секунд, пока не пройдёт total секунд."""
end = time.time() + total
while time.time() + down <= end:
fault(ph, down)
time.sleep(min(up, max(0, end - time.time())))
API = ['ApiHighErrorRate', 'ApiAvailabilityFastBurn', 'ApiAvailabilitySlowBurn', 'DbPoolSaturated']
READY = ['JobQueueLagGrowing', 'ReadyLatencyFastBurn', 'ReadyLatencySlowBurn']
# Короткое расписание (~21 мин после прогрева): фазы — параллельные дорожки со смещением от начала (с).
# Отказы, влияющие на SLI доступности (всплеск, деградация), идут по очереди; worker, backend telemetry и медленный
# обработчик не меняют этот SLI и накладываются на них. Остановка Collector (разрыв всех метрик) — последней.
# (имя, смещение, отказ, наблюдение после отказа, alerts фазы)
PLAN = [
('baseline', 0, lambda ph: time.sleep(150), 0, API + READY + ['TelemetryExportFailing']),
('spike', 150, lambda ph: pause(ph, 'postgres', 60), 270, API),
('worker-stop', 150, lambda ph: stop_worker(ph, 360), 330, READY),
('telemetry-backends', 240, lambda ph: stop_containers(ph, 'tempo loki', [C + 'tempo-1', C + 'loki-1'], 120), 300,
['TelemetryExportFailing']),
('handler-slow', 390, lambda ph: cpus(ph, C + 'api-1', 0.1, 120), 60, API),
('api-degradation', 570, lambda ph: duty(ph, lambda p, s: pause(p, 'postgres', s), 25, 35, 300), 270, API),
('collector-down', 1150, lambda ph: stop_containers(ph, 'otel-collector', [C + 'otel-collector-1'], 60), 60,
['TelemetryExportFailing']),
]
def run(a, g):
out = Path(a.out)
out.mkdir(parents=True, exist_ok=True)
phases, lock = [], threading.Lock()
env = {**os.environ, 'RATE': str(a.rate), 'DURATION': '60m', 'WRITE_SHARE': '0.3', 'UPLOAD_SHARE': '0.05',
'VUS': '100', 'MAX_VUS': '600'}
with open(out / 'k6.json', 'w') as k6out:
k6 = subprocess.Popen([str(ROOT / 'scripts/load.sh')], cwd=ROOT, env=env, stdout=k6out, stderr=subprocess.DEVNULL)
try:
time.sleep(60) # setup k6 и заполнение 1-минутных окон rate
t0 = time.time()
def track(name, offset, fault, observe, watch):
time.sleep(max(0, t0 + offset - time.time()))
ph = Phase(name=name, actions=[], watch=watch, fault_start=time.time())
try:
fault(ph)
except Exception as e: # отказ уже снят в finally; фиксируем
ph['error'] = str(e)
ph['fault_end'] = time.time()
time.sleep(observe)
ph['end'] = time.time()
with lock:
phases.append(dict(ph))
phases.sort(key=lambda p: p['fault_start'])
(out / 'phases.json').write_text(json.dumps(phases, indent=1, ensure_ascii=False))
threads = [threading.Thread(target=track, args=row) for row in PLAN]
for t in threads:
t.start()
for t in threads:
t.join()
finally:
k6.send_signal(signal.SIGINT) # k6 завершается штатно и печатает итог в k6.json
try:
k6.wait(timeout=120)
except subprocess.TimeoutExpired:
k6.kill()
# --- Анализ сохранённых наблюдений. ---
def merge(ts, gap=20):
out = []
for t in sorted(ts):
if out and t - out[-1][1] <= gap:
out[-1][1] = t
else:
out.append([t, t])
return out
def transitions(iv, ph):
"""Когда alert стал pending/firing после начала отказа и когда снят после его конца (шаг правил 10 с)."""
fs, fe, pe = ph['fault_start'], ph['fault_end'], ph['end']
rows = []
for name in sorted({n for n, _ in iv}):
pend = [x for x in iv.get((name, 'pending'), []) if x[1] >= fs and x[0] <= pe]
fire = [x for x in iv.get((name, 'firing'), []) if x[1] >= fs and x[0] <= pe]
if not pend and not fire:
continue
p0 = [x[0] for x in pend if x[0] >= fs]
f0 = [x[0] for x in fire if x[0] >= fs]
row = {'alert': name, 'carried_over': bool(fire and fire[0][0] < fs),
'pending_after_start_s': round(p0[0] - fs) if p0 else None,
'firing_after_start_s': round(f0[0] - fs) if f0 else None,
'firing_intervals': len(fire),
'firing_total_s': round(sum(min(b, pe) - max(a, fs) + 10 for a, b in fire))}
if fire:
last = fire[-1][1]
row['resolved_after_end_s'] = None if last >= pe - 15 else round(last + 10 - fe)
rows.append(row)
return rows
METRICS = {
'sli_5xx_clients_5m': 'slo:api_error_ratio:rate5m',
'5xx_clients_1m': 'sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[1m])) / sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[1m]))',
'5xx_api_metrics_1m': '(sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[1m])) or vector(0)) / sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m]))',
'api_p99_s': 'histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[1m])))',
'api_p99_by_instance_s': 'histogram_quantile(0.99, sum by (le, instance) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[1m])))',
'sql_p99_by_job_s': 'histogram_quantile(0.99, sum by (le, job) (rate(db_client_operation_duration_seconds_bucket[1m])))',
'pool_pending_by_job': 'sum by (job) (db_client_connection_pending_requests)',
'eventloop_p99_by_instance_s': 'max by (job, instance) (nodejs_eventloop_delay_p99_seconds)',
'cpu_by_instance': 'sum by (job, instance) (rate(process_cpu_time_seconds_total[1m]))',
'oldest_job_age_s': 'max(messenger_jobs_oldest_age_seconds)',
'backlog_queued': 'max(messenger_jobs_backlog{state="queued"})',
'queue_consumers': 'sum(rabbitmq_detailed_queue_consumers{queue="attachments.process"})',
'worker_saturation': 'sum(messenger_worker_busy) / sum(messenger_worker_capacity)',
'ready_p95_s': 'histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket{outcome="ready"}[1m])))',
**{f'api_burn_{w}': f'slo:api_error_ratio:rate{w} / 0.005' for w in ('5m', '30m', '1h', '6h')},
**{f'ready_burn_{w}': f'slo:ready_bad_ratio:rate{w} / 0.01' for w in ('5m', '30m', '1h', '6h')},
'collector_queue_by_exporter': 'max by (exporter) (otelcol_exporter_queue_size)',
'collector_rss_mib': 'max(otelcol_process_memory_rss) / 1048576',
'api_rss_by_instance_mib': 'max by (instance) (process_memory_usage_bytes{job="messenger-api"}) / 1048576',
}
def names():
"""hostname контейнера (= service.instance.id = label instance) → имя контейнера."""
rows = sh('docker', 'ps', '-a', '--filter', 'label=com.docker.compose.project=messenger-lab6', '--format', '{{.ID}} {{.Names}}')
return {line.split()[0][:12]: line.split()[1].removeprefix(C) for line in rows.splitlines()}
def window_stats(g, query, t0, t1, alias):
res = g.prom('query_range', query=query, start=t0, end=t1, step=10)['result']
stats = {}
for s in res:
vals = [float(v) for _, v in s['values'] if v not in ('NaN', '+Inf', '-Inf')]
if vals:
key = ' '.join(alias.get(v, v) for k, v in sorted(s['metric'].items()) if k != '__name__') or 'all'
stats[key] = {'max': round(max(vals), 4), 'mean': round(statistics.fmean(vals), 4)}
return stats
def at(g, query, t):
return {' '.join(f'{k}={v}' for k, v in sorted(r['metric'].items())): float(r['value'][1])
for r in g.prom('query', query=query, time=t)['result']}
def span_breakdown(g, t0, t1, alias, query='{ resource.service.name = "messenger-api" && kind = server && duration > 300ms }'):
"""Где тратится время в медленных запросах API: ожидание пула, SQL, S3, «своё» время обработчика."""
found = json.loads(g.get('/api/datasources/proxy/uid/tempo/api/search', q=query, start=int(t0), end=int(t1) + 1, limit=20))
rows, skipped = [], 0
for t in found.get('traces', []):
try:
_, spans = g.trace(t['traceID'])
except OSError: # 502/таймаут Tempo на одном trace не должен ронять весь разбор; число — в итоге
skipped += 1
continue
# Tempo отдаёт trace, пересекающие окно; берём запросы, начатые в окне (без последних 2 с: в этот момент
# начинается следующий отказ), и только части дочерних spans внутри server span (SQL после ответа — не в счёт).
for srv in (s for s in spans if s['kind'] == 'SERVER' and s['resource'].get('service.name') == 'messenger-api'
and t0 * 1e9 <= s['start'] < (t1 - 2) * 1e9):
kids = sorted((max(k['start'], srv['start']), min(k['end'], srv['end']), k['name'])
for k in spans if k['parent'] == srv['id'] and k['end'] > srv['start'] and k['start'] < srv['end'])
covered, edge = 0, srv['start']
for a, b, _ in kids: # объединение интервалов дочерних spans
covered += max(0, b - max(a, edge))
edge = max(edge, b)
part = lambda pred: sum(b - a for a, b, n in kids if pred(n)) / 1e6
rows.append({'route': srv['attrs'].get('http.route'), 'status': srv['attrs'].get('http.response.status_code'),
'instance': alias.get(srv['resource'].get('service.instance.id'), '?'),
'total_ms': (srv['end'] - srv['start']) / 1e6,
'pool_wait_ms': part(lambda n: n == 'pg-pool.connect'),
'sql_ms': part(lambda n: n.startswith(('pg.query', 'pg.connect'))),
's3_ms': part(lambda n: n.startswith('S3.')),
'self_ms': (srv['end'] - srv['start'] - covered) / 1e6})
if not rows:
return {'traces': 0, 'skipped': skipped}
med = {k: round(statistics.median(r[k] for r in rows)) for k in ('total_ms', 'pool_wait_ms', 'sql_ms', 's3_ms', 'self_ms')}
by_instance = {}
for r in rows:
by_instance[r['instance']] = by_instance.get(r['instance'], 0) + 1
return {'traces': len(rows), 'skipped': skipped, 'median': med, 'by_instance': by_instance, 'examples': rows[:3]}
def log_events(g, t0, t1):
q = f'sum by (service_name, event) (count_over_time({{service_name=~"messenger-.+"}} | severity_text=~"ERROR|WARN" [{int(t1 - t0)}s]))'
res = json.loads(g.get('/api/datasources/proxy/uid/loki/loki/api/v1/query', query=q, time=str(int(t1 * 1e9))))['data']['result']
return {f"{r['metric'].get('service_name')} {r['metric'].get('event')}": int(float(r['value'][1])) for r in res}
def telemetry_losses(g, ph):
t = {what: ts for ts, what in ph['actions']}
res = {}
if 'stop tempo loki' in t: # backend недоступен: очередь Collector, повторы, отброшенное
a, d = t['stop tempo loki'], t['start tempo loki']
lost = 'sum by (__name__, exporter) ({__name__=~"otelcol_exporter_(send|enqueue)_failed_(spans|log_records|metric_points)_total"})'
refused = 'sum by (__name__) ({__name__=~"otelcol_receiver_refused_(spans|log_records|metric_points)_total"})'
before, after = at(g, lost, a - 5), at(g, lost, ph['end'])
r0, r1 = at(g, refused, a - 5), at(g, refused, ph['end'])
res.update({'backends_down_s': round(d - a),
'collector_dropped': {k: round(v - before.get(k, 0)) for k, v in after.items()},
'collector_refused_memory_limiter': {k: round(v - r0.get(k, 0)) for k, v in r1.items()},
'collector_queue_max': window_stats(g, 'max by (exporter) (otelcol_exporter_queue_size)', a, ph['end'], {}),
'collector_rss_mib': window_stats(g, 'max(otelcol_process_memory_rss) / 1048576', a, ph['end'], {})})
if 'stop otel-collector' in t: # недоступен сам Collector: SDK отбрасывает пачки
b, c = t['stop otel-collector'], t['start otel-collector']
sdk = 'sum by (job) (otel_sdk_span_started_total)'
s0, s1 = at(g, sdk, b - 5), at(g, sdk, ph['end'])
found = json.loads(g.get('/api/datasources/proxy/uid/tempo/api/search', q='{ resource.service.name = "messenger-api" && kind = server }',
start=int(b) + 5, end=int(c) - 5, limit=5000)).get('traces', []) if c - b > 20 else []
res.update({'collector_down_s': round(c - b),
'sdk_spans_started_during_phase': {k: round(v - s0.get(k, 0)) for k, v in s1.items()},
'tempo_api_traces_found_while_collector_down': len(found),
'api_rss_mib': window_stats(g, 'max by (instance) (process_memory_usage_bytes{job="messenger-api"}) / 1048576', b, ph['end'], names())})
lb = 'sum by (code) (increase(haproxy_frontend_http_responses_total{proxy="public"}[%ds]))' % int(ph['end'] - ph['fault_start'])
res['lb_responses_during_phase'] = {k.removeprefix('code='): round(v) for k, v in at(g, lb, ph['end']).items()}
return res
def analyze(a, g):
out = Path(a.out)
phases = json.loads((out / 'phases.json').read_text())
t0, t1 = phases[0]['fault_start'] - 120, max(ph['end'] for ph in phases) + 60
res = g.prom('query_range', query='ALERTS', start=t0, end=t1, step=10)['result']
pts = {}
for s in res:
pts.setdefault((s['metric']['alertname'], s['metric']['alertstate']), set()).update(float(t) for t, _ in s['values'])
iv = {k: merge(v) for k, v in pts.items()}
alias = names()
summary = {'k6': [json.loads(x) for x in (out / 'k6.json').read_text().splitlines() if x.startswith('{')], 'phases': [],
# интервалы firing за весь прогон, с от начала baseline: снятие может прийтись на чужую фазу
'firing': {n: [[round(a - phases[0]['fault_start']), round(b + 10 - phases[0]['fault_start'])] for a, b in v]
for (n, st), v in sorted(iv.items()) if st == 'firing'}}
for ph in phases:
fs, fe, pe = ph['fault_start'], ph['fault_end'], ph['end']
item = {'name': ph['name'], 'fault_s': round(fe - fs), 'observed_after_s': round(pe - fe),
'start_utc': time.strftime('%H:%M:%S', time.gmtime(fs)), 'actions': len(ph['actions']),
'alerts': [r for r in transitions(iv, ph) if r['alert'] in ph.get('watch', [r['alert']])],
'metrics': {k: window_stats(g, q, fs, max(fe, fs + 60), alias) for k, q in METRICS.items()},
'log_events': log_events(g, fs, pe)}
if ph['name'] in ('baseline', 'spike', 'handler-slow', 'api-degradation'):
item['slow_traces'] = span_breakdown(g, fs, fe, alias)
if ph['name'] in ('telemetry-backends', 'collector-down'):
item['telemetry'] = telemetry_losses(g, ph)
if 'error' in ph:
item['error'] = ph['error']
summary['phases'].append(item)
print(f'analyzed {ph["name"]}', flush=True)
(out / 'summary.json').write_text(json.dumps(summary, indent=1, ensure_ascii=False))
(out / 'summary.md').write_text(markdown(summary))
print(markdown(summary))
def markdown(s):
fmt = lambda v: '—' if v is None else (('−' if v < 0 else '') + f'{abs(v) // 60}:{abs(v) % 60:02d}' if isinstance(v, int) else str(v))
lines = ['## Alerts по фазам (мин:с от начала отказа; снятие — от конца отказа)', '',
'| Фаза | Отказ | Alert | pending | firing | снят после конца | firing всего | интервалов |', '|---|---|---|---|---|---|---|---|']
for p in s['phases']:
for r in p['alerts'] or [{'alert': 'нет'}]:
lines.append(f"| {p['name']} | {fmt(p['fault_s'])} | {r['alert']}{' (горел до отказа)' if r.get('carried_over') else ''} | "
f"{fmt(r.get('pending_after_start_s'))} | {fmt(r.get('firing_after_start_s'))} | "
f"{fmt(r.get('resolved_after_end_s')) if 'resolved_after_end_s' in r else '—'} | "
f"{fmt(r.get('firing_total_s'))} | {r.get('firing_intervals', '—')} |")
lines += ['', '## Firing за весь прогон (мин:с от начала baseline)', '']
lines += [f"- {n}: " + ', '.join(f'{fmt(a)}–{fmt(b)}' for a, b in v) for n, v in s.get('firing', {}).items()]
lines += ['', '## Метрики в окне отказа (максимум)', '']
keys = ['sli_5xx_clients_5m', '5xx_clients_1m', '5xx_api_metrics_1m', 'api_p99_s', 'oldest_job_age_s', 'ready_p95_s',
'worker_saturation', 'queue_consumers', 'api_burn_5m', 'api_burn_1h', 'api_burn_6h', 'ready_burn_5m', 'ready_burn_1h']
lines += ['| Фаза | ' + ' | '.join(keys) + ' |', '|---' * (len(keys) + 1) + '|']
for p in s['phases']:
cell = lambda k: ', '.join(f"{v['max']:g}" for v in p['metrics'].get(k, {}).values()) or '—'
lines.append(f"| {p['name']} | " + ' | '.join(cell(k) for k in keys) + ' |')
lines += ['', '## Насыщение по экземплярам (максимум в окне отказа)', '']
for p in s['phases']:
if p['name'] in ('baseline', 'handler-slow', 'spike', 'api-degradation'):
lines.append(f"**{p['name']}**")
for k in ('sql_p99_by_job_s', 'pool_pending_by_job', 'eventloop_p99_by_instance_s', 'cpu_by_instance', 'api_p99_by_instance_s'):
lines.append(f"- {k}: " + ', '.join(f"{n} {v['max']:g}" for n, v in p['metrics'].get(k, {}).items()))
st = p.get('slow_traces', {})
if st.get('traces'):
lines.append(f"- медленные trace (>300 мс), медианы мс: {st['median']}; по репликам: {st['by_instance']}")
lines.append('')
lines += ['## События ERROR/WARN в логах за фазу', '']
for p in s['phases']:
top = sorted(p['log_events'].items(), key=lambda kv: -kv[1])[:6]
lines.append(f"- {p['name']}: " + (', '.join(f'{k} {v}' for k, v in top) or 'нет'))
for p in s['phases']:
if 'telemetry' in p:
lines += ['', '## Недоступность telemetry', '', '```json', json.dumps(p['telemetry'], indent=1, ensure_ascii=False), '```']
lines += ['', '## k6', '', '```json', json.dumps(s['k6'], ensure_ascii=False), '```', '']
return '\n'.join(lines)
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument('command', choices=['run', 'analyze'])
p.add_argument('--out', default='evidence/track2')
p.add_argument('--grafana', default=f"http://localhost:{os.environ.get('GRAFANA_PORT', '3096')}")
p.add_argument('--rate', type=int, default=20)
a = p.parse_args()
signal.signal(signal.SIGTERM, lambda *_: sys.exit(1)) # остановка снаружи тоже снимает отказ (finally)
(run if a.command == 'run' else analyze)(a, Grafana(a.grafana))
if __name__ == '__main__':
main()
+111
View File
@@ -0,0 +1,111 @@
// Нагрузка lab6, open model (constant-arrival-rate, без coordinated omission): каждая итерация — одна операция.
// UPLOAD_SHARE — загрузка PNG (202, дальше pipeline worker-а), WRITE_SHARE — сообщение с новым Idempotency-Key,
// остальное — чтение страницы истории (limit 20). Запуск: scripts/load.sh (k6 в docker внутри сети frontend стенда).
// Основа — research/k6/messenger.js из lab3 (+ загрузки, разбивка ответов по статусу).
import http from 'k6/http';
import encoding from 'k6/encoding';
import { Counter } from 'k6/metrics';
const BASE = __ENV.BASE_URL || 'http://lb:8080';
const RATE = Number(__ENV.RATE || 20);
const WRITE_SHARE = Number(__ENV.WRITE_SHARE || 0.3);
const UPLOAD_SHARE = Number(__ENV.UPLOAD_SHARE || 0.05);
const PAIRS = Number(__ENV.PAIRS || 5);
const DURATION = __ENV.DURATION || '60s';
const PNG = open('/fixtures/sample.png', 'b');
const failed = new Counter('failed_requests'); // ответ не тот, что ожидался для операции (включая таймауты)
export const options = {
scenarios: {
load: {
executor: 'constant-arrival-rate',
rate: RATE,
timeUnit: '1s',
duration: DURATION,
preAllocatedVUs: Number(__ENV.VUS || Math.max(20, RATE)),
maxVUs: Number(__ENV.MAX_VUS || 500),
gracefulStop: '15s',
},
},
setupTimeout: '120s',
// Пороги нужны только для подметрик: трафик setup() не попадает в итоговые числа.
thresholds: {
'http_reqs{scenario:load}': ['count>=0'],
'http_req_duration{scenario:load}': ['max>=0'],
'http_req_duration{op:read}': ['max>=0'],
'http_req_duration{op:write}': ['max>=0'],
'http_req_duration{op:upload}': ['max>=0'],
'failed_requests{op:read}': ['count>=0'],
'failed_requests{op:write}': ['count>=0'],
'failed_requests{op:upload}': ['count>=0'],
},
summaryTrendStats: ['avg', 'p(50)', 'p(95)', 'p(99)', 'max'],
};
const json = { 'Content-Type': 'application/json' };
function user(tag) {
const username = `k6_${tag}_${Math.random().toString(36).slice(2, 12)}`;
const password = 'Load-' + Math.random().toString(36).slice(2) + 'xx';
const created = http.post(`${BASE}/api/v1/users`, JSON.stringify({ username, display_name: 'load ' + tag, password }), { headers: json });
if (created.status !== 201) throw new Error('register ' + created.status);
const s = http.post(`${BASE}/api/v1/auth/sessions`, null,
{ headers: { Authorization: 'Basic ' + encoding.b64encode(`${username}:${password}`) } });
if (s.status !== 201) throw new Error('login ' + s.status);
return { id: created.json('id'), token: s.json('token') };
}
export function setup() {
const actors = [];
for (let i = 0; i < PAIRS; i++) {
const a = user(`a${i}`);
const b = user(`b${i}`);
const chat = http.post(`${BASE}/api/v1/chats`, JSON.stringify({ title: 'load ' + i, member_ids: [a.id, b.id] }),
{ headers: { ...json, Authorization: 'Bearer ' + a.token } });
if (chat.status !== 201) throw new Error('chat ' + chat.status);
actors.push({ token: a.token, chatId: chat.json('id') }, { token: b.token, chatId: chat.json('id') });
}
return { actors };
}
export default function (data) {
const actor = data.actors[Math.floor(Math.random() * data.actors.length)];
const auth = { Authorization: 'Bearer ' + actor.token };
const chat = `${BASE}/api/v1/chats/${actor.chatId}`;
const r = Math.random();
let op, res, expected;
if (r < UPLOAD_SHARE) {
[op, expected] = ['upload', 202];
res = http.post(`${chat}/attachments?filename=load.png`, PNG,
{ headers: { ...auth, 'Content-Type': 'image/png' }, timeout: '15s', tags: { op } });
} else if (r < UPLOAD_SHARE + WRITE_SHARE) {
[op, expected] = ['write', 201];
res = http.post(`${chat}/messages`, JSON.stringify({ text: `load ${__VU}-${__ITER}` }),
{ headers: { ...json, ...auth, 'Idempotency-Key': `k6-${__VU}-${__ITER}-${Date.now()}` }, timeout: '15s', tags: { op } });
} else {
[op, expected] = ['read', 200];
res = http.get(`${chat}/messages?limit=20`, { headers: auth, timeout: '15s', tags: { op } });
}
if (res.status !== expected) failed.add(1, { op, status: String(res.status) });
}
export function handleSummary(data) {
const m = data.metrics;
const pick = (name) => {
const v = m[name] && m[name].values;
return v ? { avg: v.avg, p50: v['p(50)'], p95: v['p(95)'], p99: v['p(99)'], max: v.max } : null;
};
const count = (name) => (m[name] ? m[name].values.count : 0);
const reqs = count('http_reqs{scenario:load}');
const fails = { read: count('failed_requests{op:read}'), write: count('failed_requests{op:write}'), upload: count('failed_requests{op:upload}') };
const total = fails.read + fails.write + fails.upload;
const summary = {
offered_rps: RATE, write_share: WRITE_SHARE, upload_share: UPLOAD_SHARE, duration: DURATION,
requests: reqs, failed: total, failed_by_op: fails, error_ratio: reqs ? Number((total / reqs).toFixed(6)) : null,
dropped_iterations: m.dropped_iterations ? m.dropped_iterations.values.count : 0,
latency_ms: pick('http_req_duration{scenario:load}'),
read_ms: pick('http_req_duration{op:read}'), write_ms: pick('http_req_duration{op:write}'), upload_ms: pick('http_req_duration{op:upload}'),
max_vus: m.vus_max ? m.vus_max.values.max : null,
};
return { stdout: JSON.stringify(summary) + '\n' };
}
+77
View File
@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""SVG-график кампании по сохранённым наблюдениям: доля 5xx у клиентов и в метриках API, burn rate 5m/1h/6h,
полосы отказов (phases.json) и firing alerts (серия ALERTS). Только стандартная библиотека.
Запуск: python3 research/timeline.py --out evidence/track2 [--metric api|ready]"""
import argparse
import json
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).resolve().parent))
from campaign import ROOT, Grafana, merge # noqa: E402
SERIES = {
'api': [('5xx у клиентов (HAProxy), 1m', 'sum(rate(haproxy_frontend_http_responses_total{proxy="public",code="5xx"}[1m])) / sum(rate(haproxy_frontend_http_responses_total{proxy="public"}[1m]))', '#d62728'),
('5xx в метриках API, 1m', '(sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[1m])) or vector(0)) / sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m]))', '#ff9896'),
('SLI 1h (fast: > 7.2 %)', 'slo:api_error_ratio:rate1h', '#1f77b4'),
('SLI 6h (slow: > 3 %)', 'slo:api_error_ratio:rate6h', '#2ca02c')],
'ready': [('плохие вложения, 5m', 'slo:ready_bad_ratio:rate5m', '#d62728'),
('SLI 1h (fast: > 14.4 %)', 'slo:ready_bad_ratio:rate1h', '#1f77b4'),
('SLI 6h (slow: > 6 %)', 'slo:ready_bad_ratio:rate6h', '#2ca02c')],
}
ALERTS = {'api': ['ApiHighErrorRate', 'ApiAvailabilityFastBurn', 'ApiAvailabilitySlowBurn'],
'ready': ['JobQueueLagGrowing', 'ReadyLatencyFastBurn', 'ReadyLatencySlowBurn']}
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--out', default='evidence/track2')
p.add_argument('--grafana', default='http://localhost:3096')
p.add_argument('--metric', choices=SERIES, default='api')
a = p.parse_args()
g = Grafana(a.grafana)
out = ROOT / a.out
phases = json.loads((out / 'phases.json').read_text())
t0, t1 = phases[0]['fault_start'], max(ph['end'] for ph in phases)
W, H, L, top, plot_h = 1300, 430, 170, 20, 260
x = lambda t: L + (t - t0) / (t1 - t0) * (W - L - 20)
y = lambda v: top + plot_h * (1 - min(v, 1.0)) # доля 0…1, выше 100 % обрезается
svg = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}" height="{H}" font-family="sans-serif" font-size="11">',
f'<rect width="{W}" height="{H}" fill="white"/>']
# Полосы отказов, влияющих на эти alerts, и остановки Collector (разрыв всех метрик); подписи — лесенкой.
shown = [ph for ph in phases if ph['name'] != 'baseline' and (set(ALERTS[a.metric]) & set(ph.get('watch', ())) or ph['name'] == 'collector-down')]
for i, ph in enumerate(shown):
svg.append(f'<rect x="{x(ph["fault_start"]):.1f}" y="{top}" width="{max(1, x(ph["fault_end"]) - x(ph["fault_start"])):.1f}" '
f'height="{plot_h}" fill="#eeeeee"/><text x="{x(ph["fault_start"]) + 3:.1f}" y="{top + 12 + i * 12}" fill="#555">{ph["name"]}</text>')
for v in (0, 0.25, 0.5, 0.75, 1):
svg.append(f'<line x1="{L}" x2="{W - 20}" y1="{y(v):.1f}" y2="{y(v):.1f}" stroke="#ddd"/><text x="{L - 6}" y="{y(v) + 4:.1f}" text-anchor="end">{v:.0%}</text>')
for i, (label, q, color) in enumerate(SERIES[a.metric]):
res = g.prom('query_range', query=q, start=t0, end=t1, step=30)['result']
pts = [(float(t), float(v)) for r in res for t, v in r['values'] if v not in ('NaN', '+Inf', '-Inf')]
segs = [[]]
for t, v in pts: # нет данных (0/0 без завершений, Collector остановлен) — разрыв линии, а не наклон
if segs[-1] and t - segs[-1][-1][0] > 45:
segs.append([])
segs[-1].append((t, v))
for seg in filter(None, segs):
svg.append(f'<polyline fill="none" stroke="{color}" stroke-width="1.5" points="' +
' '.join(f'{x(t):.1f},{y(v):.1f}' for t, v in seg) + '"/>')
svg.append(f'<rect x="{L + i * 260}" y="{H - 30}" width="12" height="3" fill="{color}"/><text x="{L + 16 + i * 260}" y="{H - 25}">{label}</text>')
res = g.prom('query_range', query='ALERTS{alertstate="firing"}', start=t0, end=t1, step=10)['result']
for i, name in enumerate(ALERTS[a.metric]):
yy = top + plot_h + 22 + i * 14
svg.append(f'<text x="{L - 6}" y="{yy + 9}" text-anchor="end">{name}</text>')
ts = {float(t) for r in res if r['metric']['alertname'] == name for t, _ in r['values']}
for s, e in merge(ts):
svg.append(f'<rect x="{x(s):.1f}" y="{yy}" width="{max(2, x(e + 10) - x(s)):.1f}" height="10" fill="#ff7f0e"/>')
minutes = int((t1 - t0) // 60)
for m in range(0, minutes + 1, 5):
svg.append(f'<text x="{x(t0 + m * 60):.1f}" y="{top - 6}" text-anchor="middle" fill="#555">{m} мин</text>')
svg.append('</svg>')
path = out / f'timeline-{a.metric}.svg'
path.write_text('\n'.join(svg))
print(path)
if __name__ == '__main__':
main()
+134
View File
@@ -0,0 +1,134 @@
#!/usr/bin/env python3
"""Пик памяти API при N одновременных загрузках ~9.9 MiB (уровень 4).
Гипотеза: загрузка идёт потоком с обратным давлением, поэтому рост памяти реплики ≪ N × размер файла.
Перед каждым уровнем реплики перезапускаются (новая cgroup), затем прогрев и выборка memory.current каждые 50 мс
во всех api и s3 контейнерах. Запуск: python3 research/upload_memory.py --base-url http://localhost:8080"""
import json
import os
from pathlib import Path
import statistics
import struct
import subprocess
import sys
import threading
import time
import zlib
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
MiB = 1024 * 1024
def noise_png(side):
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
raw = b''.join(b'\0' + os.urandom(side * 3) for _ in range(side))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', side, side, 8, 2, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(raw, 1)) + chunk(b'IEND', b''))
def containers(service):
out = subprocess.run(['docker', 'compose', 'ps', '-q', service], cwd=ROOT, capture_output=True, text=True, check=True).stdout
return out.split()
def cgroup(cid, name):
return int(subprocess.run(['docker', 'exec', cid, 'cat', '/sys/fs/cgroup/' + name], capture_output=True, text=True, check=True).stdout)
class Sampler(threading.Thread):
"""Максимум memory.current контейнера, опрос каждые 50 мс одним долгим docker exec."""
def __init__(self, cid):
super().__init__(daemon=True)
self.max = 0
self.proc = subprocess.Popen(['docker', 'exec', cid, 'sh', '-c', 'while :; do cat /sys/fs/cgroup/memory.current; sleep 0.05; done'],
stdout=subprocess.PIPE, text=True)
def run(self):
for line in self.proc.stdout:
self.max = max(self.max, int(line))
def stop(self):
self.proc.terminate()
return self.max
def restart_api(c):
subprocess.run(['docker', 'compose', 'restart', 'api'], cwd=ROOT, check=True, capture_output=True)
seen, deadline = set(), time.monotonic() + 60
while len(seen) < 2:
check(time.monotonic() < deadline, 'replicas not ready')
try:
r = c.call('GET', '/health/ready', [200, 503])
if r['status'] == 200:
seen.add(r['headers']['X-Instance-Id'])
except AssertionError:
pass
time.sleep(0.2)
def main():
args = arguments('Concurrent upload memory experiment', lambda p: p.add_argument('--levels', default='1,10,20,40'))
c = Client(args.base_url, args.ca_file, timeout=120)
data = noise_png(1860)
small = (ROOT / 'tests/fixtures/sample.png').read_bytes()
results = []
for n in [int(x) for x in args.levels.split(',')]:
restart_api(c)
alice, _, _, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=load.png'
for _ in range(4): # прогрев: модули SDK, пул соединений, JIT
c.call('POST', path, 201, actor=alice, raw=small, headers={'Content-Type': 'image/png'})
api = containers('api')
watched = {('api', cid): None for cid in api} | {('s3', cid): None for cid in containers('s3')}
base = {k: cgroup(k[1], 'memory.current') for k in watched}
samplers = {k: Sampler(k[1]) for k in watched}
for s in samplers.values():
s.start()
time.sleep(0.5)
barrier = threading.Barrier(n)
done = []
def upload():
local = Client(args.base_url, args.ca_file, timeout=120)
barrier.wait()
r = local.call('POST', path, [201, 503], actor=alice, raw=data, headers={'Content-Type': 'image/png'})
done.append((r['status'], r['elapsed'], r['headers'].get('X-Instance-Id')))
start = time.monotonic()
threads = [threading.Thread(target=upload) for _ in range(n)]
for t in threads:
t.start()
for t in threads:
t.join()
wall = time.monotonic() - start
time.sleep(0.5)
peak = {k: s.stop() for k, s in samplers.items()}
lat = sorted(e for _, e, _ in done)
row = {
'concurrency': n, 'file_mib': round(len(data) / MiB, 2), 'ok': sum(s == 201 for s, _, _ in done), 'errors': sum(s != 201 for s, _, _ in done),
'wall_s': round(wall, 2), 'throughput_mib_s': round(n * len(data) / MiB / wall, 1),
'latency_p50_s': round(statistics.median(lat), 2), 'latency_max_s': round(lat[-1], 2),
'per_replica': sorted(sum(1 for *_, i in done if i == cid[:12]) for cid in api),
'api_baseline_mib': [round(base[('api', cid)] / MiB, 1) for cid in api],
'api_peak_mib': [round(peak[('api', cid)] / MiB, 1) for cid in api],
'api_cgroup_peak_mib': [round(cgroup(cid, 'memory.peak') / MiB, 1) for cid in api],
's3_baseline_mib': [round(base[k] / MiB, 1) for k in watched if k[0] == 's3'],
's3_peak_mib': [round(peak[k] / MiB, 1) for k in watched if k[0] == 's3'],
}
row['api_max_growth_mib'] = round(max(p - b for p, b in zip(row['api_peak_mib'], row['api_baseline_mib'])), 1)
results.append(row)
print(json.dumps(row, ensure_ascii=False))
print('\n| N | OK/ошибки | время, с | MiB/s | p50 / max, с | загрузок на реплику | API до → пик, MiB | рост max, MiB | S3-шлюз до → пик, MiB |')
print('| --- | --- | --- | --- | --- | --- | --- | --- | --- |')
for r in results:
print('| %d | %d/%d | %.2f | %.1f | %.2f / %.2f | %s | %s → %s | %.1f | %s → %s |' % (
r['concurrency'], r['ok'], r['errors'], r['wall_s'], r['throughput_mib_s'], r['latency_p50_s'], r['latency_max_s'],
r['per_replica'], r['api_baseline_mib'], r['api_peak_mib'], r['api_max_growth_mib'], r['s3_baseline_mib'], r['s3_peak_mib']))
check(all(r['errors'] == 0 for r in results), 'some uploads failed')
if __name__ == '__main__':
run(main)
+77
View File
@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""Уровень 4: ресурсы worker на худших допустимых входах (не больше MAX_UPLOAD_BYTES и MAX_IMAGE_PIXELS).
Методика: перед каждым файлом worker перезапускается (сбрасывается memory.peak cgroup v2 контейнера), файл грузится
через API, измеряются время от 202 до ready и пик памяти контейнеров worker. Затем тот же render внутри контейнера
worker с timeout 1 с (как при JOB_TIMEOUT_SECONDS=1) должен закончиться постоянной ошибкой processing_timeout.
Запуск: python3 research/worker_limits.py --base-url http://localhost:8080"""
from pathlib import Path
import struct
import subprocess
import sys
import time
import zlib
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'student-tests'))
from attachments import chunk, gray1, noise_png # noqa: E402
from failures import ROOT, compose # noqa: E402
from client import Client, arguments, check, run # noqa: E402
MiB = 1024 * 1024
RENDER = """
import { render } from './src/jobs/render.ts';
const chunks = []; for await (const c of process.stdin) chunks.push(c);
const t = performance.now();
try { await render(Buffer.concat(chunks), 1, 40000000, Number(process.argv[1])); console.log('ok', Math.round(performance.now() - t)); }
catch (e) { console.log(e.code, Math.round(performance.now() - t)); }
"""
def rgba16(width, height):
"""RGBA 16 бит: 8 байт на пиксель, 40 Мп = 320 МБ распакованных данных; повторяющиеся строки сжимаются до ~1 МБ."""
row = b'\0' + bytes(range(256)) * (width * 8 // 256)
z = zlib.compressobj(9)
data = b''.join(z.compress(row) for _ in range(height)) + z.flush()
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', width, height, 16, 6, 0, 0, 0))
+ chunk(b'IDAT', data) + chunk(b'IEND', b''))
def workers():
return compose('ps', '-q', 'worker', capture=True).split()
def cgroup(container, name):
r = subprocess.run(['docker', 'exec', container, 'cat', '/sys/fs/cgroup/' + name], capture_output=True, text=True)
check(r.returncode == 0, 'cgroup v2 %s unavailable' % name)
return int(r.stdout) / MiB
def main():
args = arguments('Worker resource limits on worst-case accepted images')
c = Client(args.base_url, args.ca_file, timeout=60)
alice, bob, _, chat = c.bootstrap()
limit = compose('exec', '-T', 'worker', 'sh', '-c', 'cat /sys/fs/cgroup/memory.max', capture=True).strip()
print('worker: лимит памяти контейнера %d MiB, WORKER_CONCURRENCY=2, libvips concurrency 1, cache off' % (int(limit) / MiB))
print('%-34s %9s %8s %10s %13s %13s' % ('вход', 'файл', 'пикс.', 'до ready', 'пик worker', 'timeout 1 с'))
for label, data, pixels in (('PNG RGB-шум 1860×1860 (макс. байт)', noise_png(1860), 1860 * 1860),
('PNG 1 бит 6400×6250', gray1(6400, 6250), 40_000_000),
('PNG RGBA 16 бит 6400×6250', rgba16(6400, 6250), 40_000_000)):
check(len(data) <= 10 * MiB, 'input over upload limit')
compose('restart', 'worker')
time.sleep(3)
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=limits.png' % chat['id'], 202, actor=alice, raw=data,
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
start = time.monotonic()
ready = c.wait_ready(bob, att, 120)
took = time.monotonic() - start
check(len(ready['variants']) == 3, 'variants')
peak = max(cgroup(w, 'memory.peak') for w in workers())
r = subprocess.run(['docker', 'compose', 'exec', '-T', 'worker', 'node', '--input-type=module', '-e', RENDER, '1'],
cwd=ROOT, input=data, capture_output=True)
code, ms = r.stdout.decode().split()
print('%-34s %7.2f MB %6.0f M %8.1f с %9.0f MiB %13s' % (label, len(data) / 1e6, pixels / 1e6, took, peak,
'%s (%s мс)' % (code, ms)))
print('PASS: worst-case accepted images processed within worker limits')
if __name__ == '__main__':
run(main)
+51
View File
@@ -0,0 +1,51 @@
#!/bin/sh
# Проверка приватности bucket и минимальных прав вне API (уровень 4). Ничего не меняет, кроме
# временного объекта probe/* (создаётся и сразу удаляется ключом api) — и повторного запуска s3-init.
set -eu
cd "$(dirname "$0")/.."
fail=0
expect() { # описание, ожидаемое, фактическое
if [ "$2" = "$3" ]; then echo "PASS $1: $3"; else echo "FAIL $1: ожидалось $2, получено $3"; fail=1; fi
}
key=$(docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT object_key FROM attachments WHERE state = 'ready' LIMIT 1")
[ -n "$key" ] || { echo "нужно хотя бы одно вложение: сначала make test"; exit 2; }
bucket=$(docker compose exec -T api printenv S3_BUCKET)
# 1. Анонимный доступ напрямую к S3-шлюзу из сети backend (минуя API): без подписи — 403.
anon() { docker compose exec -T api node -e 'fetch(process.argv[1], { method: process.argv[2], body: process.argv[2] === "PUT" ? "x" : undefined }).then((r) => console.log(r.status), () => console.log("error"))' "$@"; }
expect "анонимный GET объекта" 403 "$(anon "http://s3:9000/$bucket/$key" GET)"
expect "анонимный LIST bucket" 403 "$(anon "http://s3:9000/$bucket?list-type=2" GET)"
expect "анонимный PUT объекта" 403 "$(anon "http://s3:9000/$bucket/originals/anonymous" PUT)"
# 2. Ключи api и reconciler: только свой bucket и только нужные действия.
for svc in api reconciler; do
docker compose exec -T "$svc" node --input-type=module - "$key" < student-tests/s3_probe.mjs | while read -r line; do echo " $svc $line"; done
done
probe() { docker compose exec -T "$1" node --input-type=module - "$key" < student-tests/s3_probe.mjs | awk -v op="$2: " 'index($0, op) == 1 {split(substr($0, length(op) + 1), w, " "); print w[1]}'; }
expect "api GetObject" allowed "$(probe api 'GetObject own bucket')"
expect "api ListObjectsV2 (не нужен API)" denied "$(probe api 'ListObjectsV2 own bucket')"
expect "api CreateBucket" denied "$(probe api 'CreateBucket other')"
expect "api PutObject в чужой bucket" denied "$(probe api 'PutObject other bucket')"
expect "reconciler ListObjectsV2" allowed "$(probe reconciler 'ListObjectsV2 own bucket')"
expect "reconciler CreateBucket" denied "$(probe reconciler 'CreateBucket other')"
# 3. Внутренние интерфейсы SeaweedFS (filer/master/volume без подписи S3) недоступны из API: другая сеть.
for port in 8888 9333 8080; do
if docker compose exec -T api wget -T 2 -q -O /dev/null "http://seaweedfs:$port/" 2>/dev/null; then r=reachable; else r=unreachable; fi
expect "seaweedfs:$port из контейнера api" unreachable "$r"
done
# Не только DNS: и по IP в сети storage маршрута из backend нет.
ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$(docker compose ps -q seaweedfs)")
if docker compose exec -T api wget -T 2 -q -O /dev/null "http://$ip:8888/" 2>/dev/null; then r=reachable; else r=unreachable; fi
expect "filer по IP $ip:8888 из контейнера api" unreachable "$r"
# 4. На хост опубликованы только LB (API и статистика HAProxy) и Grafana (lab6), все на 127.0.0.1; S3 и консоли — нет.
published=$(for id in $(docker compose ps -q); do
[ -n "$(docker port "$id")" ] && docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}}' "$id"
done | sort -u | tr '\n' ' ')
expect "сервисы с опубликованными портами" "grafana lb " "$published"
# 5. Bootstrap идемпотентен: повторный s3-init не создаёт и не ломает bucket.
expect "повторный s3-init" "bucket $bucket: exists" "$(docker compose run --rm -T s3-init 2>/dev/null | tail -1)"
[ "$fail" = 0 ] && echo "PASS: bucket приватен, права минимальны, внутренние порты закрыты" || exit 1
+79
View File
@@ -0,0 +1,79 @@
#!/bin/sh
# Создаёт локальные учебные секреты и .env (вне Git). Существующие ключи не перезаписывает: они уже записаны
# в volume pgdata и используются SeaweedFS. Повторный запуск только добавляет недостающее.
set -eu
cd "$(dirname "$0")/.."
[ -f .env ] || cp .env.example .env
mkdir -p secrets
chmod 700 secrets
put() {
[ -f "secrets/$1" ] && return 0
printf '%s' "$2" > "secrets/$1"
chmod 644 "secrets/$1" # читают пользователи контейнеров; сам каталог остаётся 700
echo "created secrets/$1"
}
if [ ! -f secrets/postgres_password ]; then
password=$(openssl rand -hex 24)
put postgres_password "$password"
put database_url "postgres://messenger:$password@postgres:5432/messenger"
fi
# Отдельные S3-ключи: admin — только bootstrap bucket (s3-init), api и worker — объекты, reconciler — объекты + листинг.
for who in admin api worker reconciler; do
put "s3_${who}_access_key_id" "$who$(openssl rand -hex 8)"
put "s3_${who}_secret_access_key" "$(openssl rand -hex 24)"
done
# Lab6: пароль администратора Grafana. Применяется при первом старте (база Grafana в volume grafana-data).
put grafana_admin_password "$(openssl rand -hex 16)"
# Identities SeaweedFS выводятся из ключей и bucket, поэтому файл пересобирается при каждом запуске.
# Действие с суффиксом :bucket разрешено только в этом bucket; Admin (создание/удаление bucket) — только у admin.
# Анонимной identity нет: запрос без подписи получает 403.
bucket=$(sed -n 's/^S3_BUCKET=//p' .env)
bucket=${bucket:-messenger-attachments}
identity() {
printf '{"name":"%s","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":[%s]}' \
"$1" "$(cat "secrets/s3_$1_access_key_id")" "$(cat "secrets/s3_$1_secret_access_key")" "$2"
}
umask 022
printf '{"identities":[%s,%s,%s,%s]}\n' \
"$(identity admin '"Admin","Read","List","Write"')" \
"$(identity api "\"Read:$bucket\",\"Write:$bucket\"")" \
"$(identity worker "\"Read:$bucket\",\"Write:$bucket\"")" \
"$(identity reconciler "\"Read:$bucket\",\"Write:$bucket\",\"List:$bucket\"")" > secrets/s3_identities.json
# RabbitMQ: отдельные пользователи api (только публикация в exchange attachments) и worker (только чтение
# очереди attachments.process), configure ни у кого — топология объявлена здесь и импортируется при старте узла.
# В definitions лежат только солёные хеши SHA-256 (формат rabbit_password_hashing_sha256), пароли — в broker_url_*.
for who in api worker; do
put "rabbitmq_${who}_password" "$(openssl rand -hex 24)"
put "broker_url_$who" "amqp://$who:$(cat "secrets/rabbitmq_${who}_password")@rabbitmq:5672/messenger?heartbeat=10"
done
python3 - > secrets/rabbitmq_definitions.json <<'PY'
import base64, hashlib, json, os
def user(name):
salt = os.urandom(4)
with open(f'secrets/rabbitmq_{name}_password', 'rb') as f:
digest = hashlib.sha256(salt + f.read()).digest()
return {'name': name, 'password_hash': base64.b64encode(salt + digest).decode(),
'hashing_algorithm': 'rabbit_password_hashing_sha256', 'tags': []}
vh = 'messenger'
print(json.dumps({
'users': [user('api'), user('worker')],
'vhosts': [{'name': vh}],
'permissions': [
{'user': 'api', 'vhost': vh, 'configure': '^$', 'write': '^attachments$', 'read': '^$'},
{'user': 'worker', 'vhost': vh, 'configure': '^$', 'write': '^$', 'read': '^attachments\\.process$'},
],
'exchanges': [{'name': 'attachments', 'vhost': vh, 'type': 'direct', 'durable': True, 'auto_delete': False,
'internal': False, 'arguments': {}}],
# Quorum-очередь: сообщение подтверждается publisher confirm после записи на диск (Raft-лог).
# delivery-limit: сообщение, которое worker 20 раз вернул без ack, отбрасывается; задание при этом остаётся в БД
# и будет опубликовано снова sweeper-ом (relay.ts) — источник истины о работе PostgreSQL, а не очередь.
'queues': [{'name': 'attachments.process', 'vhost': vh, 'durable': True, 'auto_delete': False,
'arguments': {'x-queue-type': 'quorum', 'x-delivery-limit': 20}}],
'bindings': [{'source': 'attachments', 'vhost': vh, 'destination': 'attachments.process',
'destination_type': 'queue', 'routing_key': 'process', 'arguments': {}}],
}, indent=2))
PY
echo "secrets/ and .env are ready (bucket $bucket)"
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
# Нагрузка k6 на стенд lab6 изнутри сети frontend (через HAProxy lb:8080), итог — одна строка JSON в stdout.
# Параметры окружения: RATE (итераций/с), DURATION, WRITE_SHARE, UPLOAD_SHARE, PAIRS, VUS, MAX_VUS — см. research/k6/messenger.js.
# Пример: RATE=20 DURATION=10m scripts/load.sh > evidence/load/baseline.json
set -eu
cd "$(dirname "$0")/.."
exec docker run --rm --cpus 2 --network "${COMPOSE_PROJECT_NAME:-messenger-lab6}_frontend" \
-v "$PWD/research/k6:/k6:ro" -v "$PWD/tests/fixtures:/fixtures:ro" \
-e BASE_URL=http://lb:8080 -e RATE -e DURATION -e WRITE_SHARE -e UPLOAD_SHARE -e PAIRS -e VUS -e MAX_VUS \
grafana/k6:1.8.2@sha256:00fdcebafbc86cb0137d429529b1caa401a02e09025f02fc74866fa6e2b004d8 run -q /k6/messenger.js
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Перезапускает LB, все API-реплики, worker, reconciler, PostgreSQL, RabbitMQ и SeaweedFS (хранилище + S3-шлюз),
# а также Collector и хранилища telemetry (Prometheus, Loki, Tempo) и Grafana (lab6).
# Все volumes сохраняются: pgdata, s3data, rabbitmq-data, prometheus-data, loki-data, tempo-data, grafana-data;
# migrate и s3-init ничего не меняют. Telemetry не теряется: приложение остановлено раньше хранилищ.
set -eu
cd "$(dirname "$0")/.."
docker compose stop lb api worker reconciler # штатный SIGTERM, реплики сначала завершают запросы и сбрасывают telemetry
docker compose stop s3
docker compose restart postgres seaweedfs rabbitmq otel-collector prometheus loki tempo grafana # те же контейнеры и volumes
docker compose start s3
docker compose start api worker reconciler lb
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
# Останавливает ровно ту API-реплику, чей X-Instance-Id передан в TARGET_INSTANCE_ID, и оставляет её остановленной.
# X-Instance-Id = hostname контейнера = первые 12 hex-символов ID контейнера.
# Восстановление после теста: docker compose start api
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
cd "$(dirname "$0")/.."
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]* | "") echo "unexpected instance id" >&2; exit 2 ;;
esac
ids=$(docker compose ps -q api | grep "^$TARGET_INSTANCE_ID" || true)
[ "$(printf '%s\n' "$ids" | grep -c .)" -eq 1 ] || { echo "no single running api container for $TARGET_INSTANCE_ID" >&2; exit 1; }
docker stop "$ids" >/dev/null # SIGTERM → readiness 503 → drain → выход (около 3 с)
echo "stopped $(docker inspect -f '{{.Name}}' "$ids") ($TARGET_INSTANCE_ID)"
+119
View File
@@ -0,0 +1,119 @@
// HTTP-приложение: таблица маршрутов, health-проверки и общая обработка каждого запроса.
// Наблюдаемость (lab6): server span создаёт instrumentation-http, здесь ему задаётся шаблон маршрута
// и X-Request-Id; после ответа пишется структурный access-лог с trace_id/span_id этого span.
import { randomUUID } from 'node:crypto';
import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { context, trace } from '@opentelemetry/api';
import type { Pool } from 'pg';
import type { Config } from './config.ts';
import type { Handler, Result } from './http/context.ts';
import { notFound, toHttpError, unavailable } from './http/errors.ts';
import { downloadAttachment, getAttachment, uploadAttachment } from './modules/attachments.ts';
import { createChat, getChat, listChats } from './modules/chats.ts';
import { listMessages, sendMessage } from './modules/messages.ts';
import { createSession, deleteSession } from './modules/sessions.ts';
import { createUser, me } from './modules/users.ts';
import { log, setRoute } from './otel.ts';
import type { Storage } from './storage/s3.ts';
function send(res: ServerResponse, status: number, body?: unknown, headers?: OutgoingHttpHeaders) {
if (body instanceof Readable) {
// Байты вложения потоком из S3. Обрыв с любой стороны закрывает соединение: клиент увидит
// несовпадение с Content-Length, а не «успешно» обрезанный файл.
res.writeHead(status, headers);
pipeline(body, res).catch((err) => log('warn', 'http.stream_aborted', `передача вложения прервана: ${err.message}`));
return;
}
if (body === undefined) {
res.writeHead(status).end();
return;
}
const data = JSON.stringify(body);
res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) }).end(data);
}
export function createApp(db: Pool, s3: Storage, config: Config, relay: { kick(): void }) {
// ready = false с момента SIGTERM: балансировщик по readiness выводит реплику из ротации.
const state = { ready: true };
// Готовность: процесс не завершается и PostgreSQL отвечает. Это единственная критичная зависимость:
// при недоступном S3 реплика остаётся в ротации, текстовые сообщения работают, вложения отвечают 503;
// при недоступном брокере загрузки принимаются (задания ждут в outbox), worker не нужен для приёма.
const readiness: Handler = async () => {
if (!state.ready) throw unavailable('Реплика завершает работу');
try {
await db.query('SELECT 1');
} catch {
throw unavailable('База данных недоступна');
}
return [200, { status: 'ok' }];
};
// Шаблон маршрута — и правило сопоставления, и label http.route метрик/имя span (без реальных UUID).
const routes = ([
['GET', '/health/live', async () => [200, { status: 'ok' }]],
['GET', '/health/ready', readiness],
['POST', '/api/v1/users', createUser],
['GET', '/api/v1/users/me', me],
['POST', '/api/v1/auth/sessions', createSession],
['DELETE', '/api/v1/auth/sessions/current', deleteSession],
['POST', '/api/v1/chats', createChat],
['GET', '/api/v1/chats', listChats],
['GET', '/api/v1/chats/{chat_id}', getChat],
['POST', '/api/v1/chats/{chat_id}/messages', sendMessage],
['GET', '/api/v1/chats/{chat_id}/messages', listMessages],
['POST', '/api/v1/chats/{chat_id}/attachments', uploadAttachment],
['GET', '/api/v1/attachments/{attachment_id}', getAttachment],
['GET', '/api/v1/attachments/{attachment_id}/content', downloadAttachment],
] as [string, string, Handler][]).map(([method, template, handler]) =>
({ method, template, handler, pattern: new RegExp(`^${template.replace(/\{\w+\}/g, '([^/]+)')}$`) }));
async function dispatch(req: IncomingMessage, matched: { route?: string }): Promise<Result> {
const url = new URL(req.url ?? '/', 'http://api');
for (const { method, template, handler, pattern } of routes) {
const m = pattern.exec(url.pathname);
if (m && req.method === method) {
matched.route = template;
setRoute(template);
return handler({ req, url, params: m.slice(1), db, s3, config, relay });
}
}
throw notFound(); // неизвестный путь или метод — тоже JSON-ошибка контракта
}
// Каждый ответ, включая ошибки и health, несёт X-Request-Id и X-Instance-Id.
function handle(req: IncomingMessage, res: ServerResponse) {
const requestId = randomUUID();
const started = performance.now();
const ctx = context.active(); // контекст server span этого запроса
trace.getSpan(ctx)?.setAttribute('messenger.request_id', requestId);
res.setHeader('X-Request-Id', requestId);
res.setHeader('X-Instance-Id', config.instanceId);
if (!state.ready) res.setHeader('Connection', 'close'); // при остановке LB не переиспользует соединение
const matched: { route?: string } = {};
// Access-лог одного запроса; health (проверки LB и Docker каждую секунду) не логируется.
// 'close' приходит и после полного ответа, и при обрыве соединения клиентом.
res.on('close', () => {
if (matched.route?.startsWith('/health/')) return;
const status = res.statusCode;
context.with(ctx, () => log(status >= 500 ? 'error' : 'info', 'http.request', `${req.method} ${matched.route ?? 'unmatched'} → ${status}`, {
request_id: requestId, 'http.request.method': req.method ?? '', 'http.route': matched.route ?? 'unmatched',
'http.response.status_code': status, duration_ms: Math.round((performance.now() - started) * 10) / 10,
...(!res.writableFinished && { aborted: true }),
}));
});
dispatch(req, matched).then(([status, body, headers]) => send(res, status, body, headers), (err) => {
const e = toHttpError(err, requestId);
if (e.status >= 500) trace.getSpan(ctx)?.recordException(err as Error);
if (e.status === 401) {
// Basic только на входе, на остальных эндпоинтах — Bearer.
res.setHeader('WWW-Authenticate', req.url === '/api/v1/auth/sessions' ? 'Basic realm="messenger", charset="UTF-8"' : 'Bearer realm="messenger"');
}
send(res, e.status, { error: { code: e.code, message: e.message, request_id: requestId } });
});
}
return { state, handle };
}
+93
View File
@@ -0,0 +1,93 @@
// Конфигурация процесса из переменных окружения. Читается один раз при старте.
import { readFileSync } from 'node:fs';
import { hostname } from 'node:os';
export type S3Config = {
endpoint: string;
region: string;
bucket: string;
accessKeyId: string;
secretAccessKey: string;
};
export type Config = {
host: string;
port: number;
databaseUrl: string;
dbPoolMax: number;
sessionTtlSeconds: number;
shutdownDrainMs: number;
instanceId: string;
s3: S3Config;
maxUploadBytes: number;
maxImagePixels: number;
brokerUrl: string;
jobs: JobsConfig;
};
// Общие параметры заданий для API (relay, sweeper) и worker.
export type JobsConfig = {
pipelineVersion: number; // версия pipeline для новых загрузок
maxAttempts: number; // попыток на job, затем failed retry_exhausted
timeoutSeconds: number; // предел одной попытки; аренда = timeout + 15 с
retryBaseMs: number; // backoff повтора: base × 2^(n−1), cap 60 с, jitter 50–100 %
republishSeconds: number; // queued без живого сообщения дольше этого — опубликовать заново
};
function env(name: string, def: string): string {
return process.env[name] || def;
}
export function envInt(name: string, def: number): number {
const n = Number(env(name, String(def)));
if (!Number.isInteger(n) || n <= 0) throw new Error(`${name} должен быть положительным целым`);
return n;
}
// Секрет берётся из файла NAME_FILE (Docker secret), иначе из NAME. Значение никогда не логируется.
export function secret(name: string): string {
const file = process.env[name + '_FILE'];
const value = file ? readFileSync(file, 'utf8').trim() : process.env[name];
if (!value) throw new Error(`нужна переменная ${name} или ${name}_FILE`);
return value;
}
// Ключи у каждого сервиса свои (api, reconciler, s3-init), compose монтирует их под одинаковыми именами.
export function s3Config(): S3Config {
return {
endpoint: env('S3_ENDPOINT', 'http://s3:9000'),
region: env('S3_REGION', 'us-east-1'),
bucket: env('S3_BUCKET', 'messenger-attachments'),
accessKeyId: secret('S3_ACCESS_KEY_ID'),
secretAccessKey: secret('S3_SECRET_ACCESS_KEY'),
};
}
export function jobsConfig(): JobsConfig {
return {
pipelineVersion: envInt('PIPELINE_VERSION', 1),
maxAttempts: envInt('JOB_MAX_ATTEMPTS', 5),
timeoutSeconds: envInt('JOB_TIMEOUT_SECONDS', 60),
retryBaseMs: envInt('JOB_RETRY_BASE_MS', 2000),
republishSeconds: envInt('JOB_REPUBLISH_SECONDS', 600),
};
}
export function loadConfig(): Config {
return {
host: env('APP_HOST', '0.0.0.0'),
port: envInt('APP_PORT', 8080),
databaseUrl: secret('DATABASE_URL'),
dbPoolMax: envInt('DB_POOL_MAX', 8),
sessionTtlSeconds: envInt('SESSION_TTL_SECONDS', 3600),
// Пауза между отказом readiness и закрытием сервера: должна быть больше времени обнаружения LB (fall × inter).
shutdownDrainMs: envInt('SHUTDOWN_DRAIN_MS', 2500),
// X-Instance-Id = hostname контейнера (12 символов ID), по нему scripts/stop-one.sh находит реплику.
instanceId: env('INSTANCE_ID', hostname()),
s3: s3Config(),
maxUploadBytes: envInt('MAX_UPLOAD_BYTES', 10485760),
maxImagePixels: envInt('MAX_IMAGE_PIXELS', 40000000),
brokerUrl: secret('BROKER_URL'),
jobs: jobsConfig(),
};
}
+50
View File
@@ -0,0 +1,50 @@
// Доступ к PostgreSQL: пул соединений для API и однократный прогон миграций.
import { readFileSync, readdirSync } from 'node:fs';
import { context, ROOT_CONTEXT } from '@opentelemetry/api';
import pg from 'pg';
import { log } from './otel.ts';
export function createPool(databaseUrl: string, max: number): pg.Pool {
const { hostname, port, pathname } = new URL(databaseUrl);
const pool = new pg.Pool({
connectionString: databaseUrl,
// Только для имени пула в метриках db.client.connection.* (postgres:5432/messenger); пароль туда не попадает.
host: hostname, port: Number(port || 5432), database: pathname.slice(1),
max,
connectionTimeoutMillis: 2000, // пул исчерпан или БД недоступна → 503, а не зависший запрос
statement_timeout: 5000,
});
// Ошибка простаивающего соединения (например, рестарт PostgreSQL) не должна ронять процесс.
// ROOT_CONTEXT: иначе лог унаследовал бы trace_id запроса, который когда-то открыл это соединение.
pool.on('error', context.bind(ROOT_CONTEXT, (err: Error) => log('error', 'db.connection_error', `ошибка соединения с БД: ${err.message}`)));
return pool;
}
// Применяет src/migrations/*.sql по порядку, каждую в своей транзакции и ровно один раз.
// Advisory lock не даёт двум запускам выполнить DDL одновременно.
export async function migrate(databaseUrl: string): Promise<void> {
const client = new pg.Client({ connectionString: databaseUrl });
await client.connect();
try {
await client.query('SELECT pg_advisory_lock(3003)');
await client.query('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())');
const dir = new URL('./migrations/', import.meta.url);
for (const file of readdirSync(dir).filter((f) => f.endsWith('.sql')).sort()) {
const done = await client.query('SELECT 1 FROM schema_migrations WHERE version = $1', [file]);
if (done.rowCount) continue;
await client.query('BEGIN');
try {
await client.query(readFileSync(new URL(file, dir), 'utf8'));
await client.query('INSERT INTO schema_migrations (version) VALUES ($1)', [file]);
await client.query('COMMIT');
} catch (err) {
await client.query('ROLLBACK');
throw err;
}
log('info', 'db.migration_applied', `применена миграция ${file}`, { migration: file });
}
log('info', 'db.schema_ready', 'схема актуальна');
} finally {
await client.end();
}
}
+28
View File
@@ -0,0 +1,28 @@
// Точки внедрения отказов для тестов (трек 2 и уровень 4). Выключены, пока FAILPOINTS не равно 1.
// Срабатывает только для вложения с именем файла failpoint-<точка>[-<N>s].png и ровно один раз на вложение
// (отметка в failpoint_hits), поэтому перезапущенный процесс доделывает работу, а не падает по кругу.
// failpoint-<точка>.png — немедленный выход с кодом 137: ни finally, ни ack, ни ROLLBACK — соединения с БД
// и брокером рвёт ядро, как при реальном падении. Не SIGKILL себе: node в контейнере —
// PID 1, а сигналы без обработчика, посланные init изнутри его namespace, ядро игнорирует;
// failpoint-<точка>-<N>s.png — пауза N секунд: процесс жив, но «завис» (проверка аренды и fencing).
// Точки: api_after_staging, api_after_commit, relay_after_publish, worker_after_claim, worker_after_side_effect,
// worker_after_commit.
import { setTimeout as sleep } from 'node:timers/promises';
import type { Pool } from 'pg';
import { log } from './otel.ts';
const enabled = process.env.FAILPOINTS === '1';
export async function failpoint(db: Pool, name: string, attachmentId: string, filename: string): Promise<void> {
const m = enabled ? /^failpoint-([a-z_]+)(?:-(\d+)s)?\.png$/.exec(filename) : null;
if (!m || m[1] !== name) return;
const hit = await db.query('INSERT INTO failpoint_hits (name, attachment_id) VALUES ($1, $2) ON CONFLICT DO NOTHING', [name, attachmentId]);
if (!hit.rowCount) return;
if (m[2]) {
log('warn', 'failpoint.pause', `failpoint ${name}: пауза ${m[2]} с`, { 'failpoint.name': name });
await sleep(Number(m[2]) * 1000);
return;
}
log('error', 'failpoint.kill', `failpoint ${name}: аварийное завершение процесса`, { 'failpoint.name': name });
process.exit(137); // как при падении: OTLP-буферы не сбрасываются, строка лога в stdout (pipe) пишется синхронно
}
+20
View File
@@ -0,0 +1,20 @@
// Общие типы обработчиков: контекст запроса и результат.
import type { IncomingMessage, OutgoingHttpHeaders } from 'node:http';
import type { Pool } from 'pg';
import type { Config } from '../config.ts';
import type { Storage } from '../storage/s3.ts';
export type Ctx = {
req: IncomingMessage;
url: URL;
params: string[]; // группы из шаблона маршрута, например chat_id
db: Pool;
s3: Storage;
config: Config;
relay: { kick(): void }; // разбудить публикацию outbox сразу после COMMIT
};
// [HTTP-статус, JSON-тело или поток байтов, заголовки потока]; без тела — ответ без содержимого (204).
export type Result = [status: number, body?: unknown, headers?: OutgoingHttpHeaders];
export type Handler = (c: Ctx) => Promise<Result>;
+34
View File
@@ -0,0 +1,34 @@
// Ошибки API в формате контракта: {"error":{"code","message","request_id"}}.
import { log } from '../otel.ts';
export class HttpError extends Error {
status: number;
code: string;
constructor(status: number, code: string, message: string) {
super(message);
this.status = status;
this.code = code;
}
}
export const badRequest = (message: string) => new HttpError(400, 'invalid_request', message);
export const unauthorized = () => new HttpError(401, 'unauthorized', 'Требуется действительная сессия');
// 404 и для отсутствующего, и для чужого объекта: не раскрываем факт существования.
export const notFound = () => new HttpError(404, 'not_found', 'Объект не найден');
export const conflict = (message: string) => new HttpError(409, 'conflict', message);
export const unavailable = (message: string) => new HttpError(503, 'unavailable', message);
export const tooLarge = (message: string) => new HttpError(413, 'payload_too_large', message);
export const unsupported = (message: string) => new HttpError(415, 'unsupported_media_type', message);
// Неизвестную ошибку переводим в ответ без внутренних деталей.
// Ошибка SQL — наш баг (500). Потеря соединения, таймаут пула, рестарт или отмена в PostgreSQL —
// временная недоступность зависимости (503): клиент может повторить запрос.
export function toHttpError(err: unknown, requestId: string): HttpError {
if (err instanceof HttpError) return err;
const { code = '', message = '' } = err as { code?: string; message?: string };
const transient = /^(08|53|57)/.test(code) || /^E[A-Z]+$/.test(code) || /connect|terminated|timeout/i.test(message);
// request_id в логе связывает ответ клиенту (X-Request-Id) с trace_id этого запроса.
log('error', transient ? 'http.dependency_unavailable' : 'http.internal_error', `запрос ${requestId}: ${code} ${message}`,
{ request_id: requestId, 'error.type': code || 'Error' });
return transient ? unavailable('Сервис временно недоступен') : new HttpError(500, 'internal_error', 'Внутренняя ошибка');
}
+44
View File
@@ -0,0 +1,44 @@
// Keyset-пагинация по (created_at, id) по возрастанию.
// Cursor непрозрачен для клиента: base64url("вид|область|created_at|id").
// Область привязывает cursor к конкретному чату (или пользователю для списка чатов): чужой cursor → 400.
import { badRequest } from './errors.ts';
import { UUID } from './request.ts';
const TIMESTAMP = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{6}Z$/;
type Keyed = { created_at: string; id: string };
export function limitOf(url: URL): number {
const q = url.searchParams.get('limit');
if (q === null) return 50;
const n = Number(q);
if (!/^\d+$/.test(q) || n < 1 || n > 100) throw badRequest('limit должен быть целым 1–100');
return n;
}
// Позиция, после которой продолжать чтение. Без cursor — начало истории.
export function afterCursor(url: URL, kind: string, scope: string): [createdAt: string, id: string] {
const raw = url.searchParams.get('cursor');
if (raw === null) return ['-infinity', '00000000-0000-0000-0000-000000000000'];
const [k, s, ts, id, ...rest] = Buffer.from(raw, 'base64url').toString().split('|');
if (k !== kind || s !== scope || !isTimestamp(ts) || !UUID.test(id ?? '') || rest.length) {
throw badRequest('Некорректный cursor');
}
return [ts, id];
}
// Форма RFC 3339 и реальная дата: 2026-13-01 или 2026-02-30 иначе дошли бы до PostgreSQL и дали 500.
// Проверка круговым преобразованием: JS-дата без микросекунд должна совпасть с исходной строкой.
function isTimestamp(ts: string | undefined): ts is string {
if (!ts || !TIMESTAMP.test(ts)) return false;
const ms = Date.parse(ts.slice(0, 23) + 'Z');
return !Number.isNaN(ms) && new Date(ms).toISOString().slice(0, 23) === ts.slice(0, 23);
}
// Запрос выбирает limit + 1 строк: лишняя строка означает, что следующая страница есть.
export function page<T extends Keyed>(rows: T[], limit: number, kind: string, scope: string) {
const items = rows.slice(0, limit);
const last = items[limit - 1];
const next = rows.length > limit ? Buffer.from([kind, scope, last.created_at, last.id].join('|')).toString('base64url') : null;
return { items, next_cursor: next };
}
+60
View File
@@ -0,0 +1,60 @@
// Разбор и проверка входных данных запроса.
import type { IncomingMessage } from 'node:http';
import { badRequest, tooLarge, unsupported } from './errors.ts';
const BODY_LIMIT = 1 << 20; // 1 MiB: с запасом для 4000 символов в худшем JSON-экранировании
export const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
// Тело запроса как JSON: только application/json, строгий UTF-8, ограничение размера.
export async function readJson(req: IncomingMessage): Promise<unknown> {
if (mediaType(req) !== 'application/json') throw unsupported('Ожидается application/json');
const chunks: Buffer[] = [];
let size = 0;
for await (const chunk of req) {
size += chunk.length;
if (size > BODY_LIMIT) throw tooLarge('Слишком большое тело запроса');
chunks.push(chunk);
}
try {
return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
} catch {
throw badRequest('Некорректный JSON');
}
}
// Тип тела без параметров (charset и т.п.), в нижнем регистре.
export function mediaType(req: IncomingMessage): string {
return (req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase();
}
// Для эндпоинтов без тела: любое непустое тело — 400, а не молча игнорируется.
export async function requireEmptyBody(req: IncomingMessage): Promise<void> {
let size = 0;
for await (const chunk of req) {
size += chunk.length;
if (size > BODY_LIMIT) break;
}
if (size > 0) throw badRequest('Тело запроса не допускается');
}
// JSON-объект только с разрешёнными ключами: лишние поля по контракту дают 400.
export function jsonObject(value: unknown, keys: string[]): Record<string, unknown> {
if (typeof value !== 'object' || value === null || Array.isArray(value) || Object.keys(value).some((k) => !keys.includes(k))) {
throw badRequest('Ожидается JSON-объект без лишних полей');
}
return value as Record<string, unknown>;
}
// Обязательная строка: не только пробелы, длина в Unicode code points (эмодзи = 1 символ).
export function isText(v: unknown, min: number, max: number): v is string {
if (typeof v !== 'string' || v.trim() === '') return false;
const n = [...v].length;
return n >= min && n <= max;
}
// UUID из пути в каноническом нижнем регистре.
export function uuidParam(c: { params: string[] }, name: string): string {
const value = c.params[0];
if (!UUID.test(value)) throw badRequest(`Некорректный ${name}`);
return value.toLowerCase();
}
+88
View File
@@ -0,0 +1,88 @@
// Операторские команды над заданиями (выполняются в контейнере api: docker compose exec api node src/main.ts …).
// failed — реестр failed (аналог DLQ): job, вложение, код ошибки, попытки
// replay <attachment_id> — failed → queued: новая попытка той же логической job с аудитом;
// для done/queued/processing — отказ (повтор не дублирует успешную работу)
// reprocess --version=N — поставить job версии N для ready-вложений с более старой версией (трек 5);
// вложения в работе не затрагиваются — после разбора очереди команду повторяют
// show <attachment_id> — вложение, его jobs, попытки в outbox (время следующей), replay-аудит, варианты
import type { Pool } from 'pg';
import { UUID } from '../http/request.ts';
export async function adminCommand(db: Pool, args: string[]): Promise<void> {
const [cmd, arg] = args;
if (cmd === 'failed') {
const r = await db.query(`SELECT j.job_id, j.attachment_id, j.pipeline_version, j.attempts, j.error_code, rfc3339(j.updated_at) AS failed_at
FROM jobs j WHERE j.state = 'failed' ORDER BY j.updated_at`);
for (const row of r.rows) console.log(JSON.stringify(row));
console.log(JSON.stringify({ failed: r.rowCount }));
} else if (cmd === 'replay') {
if (!UUID.test(arg ?? '')) throw new Error('replay <attachment_id>');
console.log(JSON.stringify(await replay(db, arg.toLowerCase())));
} else if (cmd === 'reprocess') {
const version = Number(args.find((a) => a.startsWith('--version='))?.split('=')[1]);
if (!Number.isInteger(version) || version < 1) throw new Error('reprocess --version=N');
const r = await db.query(`WITH j AS (
INSERT INTO jobs (job_id, attachment_id, pipeline_version)
SELECT gen_random_uuid(), a.id, $1 FROM attachments a WHERE a.state = 'ready' AND a.pipeline_version < $1
ON CONFLICT (attachment_id, pipeline_version) DO NOTHING RETURNING job_id)
INSERT INTO outbox (job_id, attempt) SELECT job_id, 1 FROM j`, [version]);
console.log(JSON.stringify({ reprocess_version: version, enqueued: r.rowCount }));
} else if (cmd === 'show') {
if (!UUID.test(arg ?? '')) throw new Error('show <attachment_id>');
const q = async (sql: string) => (await db.query(sql, [arg.toLowerCase()])).rows;
console.log(JSON.stringify({
attachment: (await q(`SELECT id, state, pipeline_version, error_code, staging_key IS NOT NULL AS has_staging
FROM attachments WHERE id = $1`))[0] ?? null,
jobs: await q(`SELECT job_id, pipeline_version, state, attempts, error_code, rfc3339(lease_until) AS lease_until
FROM jobs WHERE attachment_id = $1 ORDER BY pipeline_version`),
outbox: await q(`SELECT j.pipeline_version, o.attempt, rfc3339(o.available_at) AS available_at, rfc3339(o.published_at) AS published_at
FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE j.attachment_id = $1 ORDER BY o.id`),
replays: await q(`SELECT r.previous_error, r.previous_attempts, rfc3339(r.replayed_at) AS replayed_at
FROM job_replays r JOIN jobs j ON j.job_id = r.job_id WHERE j.attachment_id = $1 ORDER BY r.replayed_at`),
variants: await q(`SELECT pipeline_version, name, width, height, size_bytes, left(sha256, 12) AS sha256
FROM attachment_variants WHERE attachment_id = $1 ORDER BY pipeline_version, name`),
}));
} else {
throw new Error('jobs failed | replay <attachment_id> | reprocess --version=N | show <attachment_id>');
}
}
async function replay(db: Pool, attachmentId: string) {
const client = await db.connect();
try {
await client.query('BEGIN');
const j = (await client.query(`SELECT j.job_id, j.state, j.attempts, j.error_code, a.pipeline_version IS NULL AS initial
FROM jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.attachment_id = $1 ORDER BY j.pipeline_version DESC LIMIT 1 FOR UPDATE OF j`, [attachmentId])).rows[0];
if (!j) throw new Error('у вложения нет заданий');
if (j.state !== 'failed') {
await client.query('ROLLBACK');
return { replayed: false, reason: `job в состоянии ${j.state}: повтор не нужен` };
}
// Staging failed-вложения хранится STAGING_RETENTION_SECONDS; после очистки повторять нечего.
if (j.initial) {
const s = await client.query(`SELECT 1 FROM attachments WHERE id = $1 AND staging_key IS NOT NULL`, [attachmentId]);
if (!s.rowCount) throw new Error('исходник недоступен');
}
await client.query('INSERT INTO job_replays (job_id, previous_error, previous_attempts) VALUES ($1, $2, $3)', [j.job_id, j.error_code, j.attempts]);
// Новая серия попыток той же логической job: прежний эффект защищён ключом (attachment_id, version, name).
// created_at — момент повторного приёма: time-to-ready и возраст задания (lag alert) считаются от replay,
// а не от исходной загрузки, уже учтённой в SLO как failed.
await client.query(`UPDATE jobs SET state = 'queued', attempts = 0, error_code = NULL, created_at = clock_timestamp(),
updated_at = clock_timestamp() WHERE job_id = $1`, [j.job_id]);
// Trace context последней публикации: повтор оператора виден в том же trace, что и исходная загрузка.
await client.query(`INSERT INTO outbox (job_id, attempt, traceparent, tracestate)
SELECT $1, 1, l.traceparent, l.tracestate FROM (SELECT 1) one
LEFT JOIN LATERAL (SELECT traceparent, tracestate FROM outbox WHERE job_id = $1 ORDER BY id DESC LIMIT 1) l ON true`, [j.job_id]);
if (j.initial) {
await client.query(`UPDATE attachments SET state = 'queued', error_code = NULL, updated_at = clock_timestamp() WHERE id = $1 AND state = 'failed'`, [attachmentId]);
}
await client.query('COMMIT');
return { replayed: true, job_id: j.job_id, previous_error: j.error_code, previous_attempts: j.attempts };
} catch (err) {
await client.query('ROLLBACK').catch(() => {});
throw err;
} finally {
client.release();
}
}
+91
View File
@@ -0,0 +1,91 @@
// RabbitMQ: формат сообщения job (contracts/jobs.schema.json), публикация с publisher confirm.
// Топология (exchange attachments → quorum-очередь attachments.process) и пользователи создаются из
// definitions при старте брокера (scripts/init-secrets.sh); у API право только писать в exchange.
import amqp, { type ChannelModel, type ConfirmChannel } from 'amqplib';
import { UUID } from '../http/request.ts';
import { log } from '../otel.ts';
export const EXCHANGE = 'attachments';
export const ROUTING_KEY = 'process';
export const QUEUE = 'attachments.process';
// В сообщении только идентификаторы: ни байтов, ни ключей S3, ни credentials. Worker берёт данные из БД.
export type Job = {
schema_version: 1;
job_id: string;
type: 'attachment.process.v1';
attachment_id: string;
pipeline_version: number;
attempt: number;
created_at: string;
traceparent?: string; // W3C trace context PRODUCER span (lab6), см. src/jobs/relay.ts
tracestate?: string;
};
const TRACEPARENT = /^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/;
// Проверка входящего сообщения по jobs.schema.json; null — сообщение не по контракту.
export function parseJob(content: Buffer): Job | null {
let j: Record<string, unknown>;
try {
j = JSON.parse(content.toString('utf8'));
} catch {
return null;
}
const keys = ['schema_version', 'job_id', 'type', 'attachment_id', 'pipeline_version', 'attempt', 'created_at', 'traceparent', 'tracestate'];
const ok = typeof j === 'object' && j !== null && Object.keys(j).every((k) => keys.includes(k))
&& j.schema_version === 1 && j.type === 'attachment.process.v1'
&& typeof j.job_id === 'string' && UUID.test(j.job_id) && typeof j.attachment_id === 'string' && UUID.test(j.attachment_id)
&& Number.isInteger(j.pipeline_version) && (j.pipeline_version as number) >= 1
&& Number.isInteger(j.attempt) && (j.attempt as number) >= 1
&& typeof j.created_at === 'string' && !Number.isNaN(Date.parse(j.created_at))
&& (j.traceparent === undefined || (typeof j.traceparent === 'string' && TRACEPARENT.test(j.traceparent)))
&& (j.tracestate === undefined || (typeof j.tracestate === 'string' && j.tracestate.length <= 512));
return ok ? (j as unknown as Job) : null;
}
export type Publisher = { publish(jobs: Job[]): Promise<void> };
// Ленивое соединение: брокер может быть недоступен — тогда publish бросает ошибку, а задания остаются в outbox.
export function createPublisher(url: string): Publisher {
let channel: Promise<ConfirmChannel> | null = null;
let conn: ChannelModel | null = null;
const open = async () => {
conn = await amqp.connect(url, { timeout: 2000 });
const reset = () => { channel = null; };
conn.on('error', reset);
conn.on('close', reset);
const ch = await conn.createConfirmChannel();
ch.on('error', reset);
ch.on('close', reset);
// mandatory + return: сообщение без маршрута (сломана топология) не исчезает молча.
ch.on('return', (m) => log('error', 'broker.unroutable', `брокер вернул неотмаршрутизированное сообщение ${m.properties.messageId}`));
return ch;
};
return {
async publish(jobs) {
channel ??= open().catch((err) => { channel = null; throw err; });
const ch = await channel;
for (const job of jobs) {
ch.publish(EXCHANGE, ROUTING_KEY, Buffer.from(JSON.stringify(job)), {
persistent: true, mandatory: true, contentType: 'application/json', messageId: `${job.job_id}:${job.attempt}`,
});
}
// Publisher confirm: брокер записал сообщения в quorum-очередь (на диск). Только после этого outbox отмечается.
// Зависший брокер не держит транзакцию relay вечно: через 5 с соединение закрывается, строки остаются в outbox.
let timer: NodeJS.Timeout | undefined;
const timeout = new Promise<never>((_, reject) => {
timer = setTimeout(() => {
channel = null;
conn?.close().catch(() => {});
reject(new Error('нет publisher confirm за 5 с'));
}, 5000);
});
try {
await Promise.race([ch.waitForConfirms(), timeout]);
} finally {
clearTimeout(timer);
}
},
};
}
+22
View File
@@ -0,0 +1,22 @@
// Метрики заданий (contracts/observability.md), общие для API (relay, sweeper) и worker.
// Атрибуты только низкой кардинальности: тип job, исход, код ошибки; идентификаторы — в логах и spans.
import { meter } from '../otel.ts';
export const JOB_TYPE = 'attachment.process.v1';
// Длительность одной обработки сообщения worker-ом; _count по outcome — счётчик обработанных/ошибочных jobs.
// outcome: done | retry | failed | noop | discarded | error (сбой вне попытки, сообщение вернётся в очередь).
export const jobDuration = meter.createHistogram('messenger.job.duration', {
unit: 's',
description: 'Processing time of one job delivery by the worker',
advice: { explicitBucketBoundaries: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60] },
});
// От durable acceptance (COMMIT задания при загрузке) до публикации ready (outcome=ready) или до терминальной
// ошибки (outcome=failed, error.type = error_code). Время считает PostgreSQL одними часами для обеих точек.
// Граница 30 с совпадает с порогом SLO time-to-ready (infra/prometheus/rules/slo.yml).
export const timeToReady = meter.createHistogram('messenger.attachment.time_to_ready', {
unit: 's',
description: 'Time from durable upload acceptance to published ready (or terminal failure)',
advice: { explicitBucketBoundaries: [0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600] },
});
+184
View File
@@ -0,0 +1,184 @@
// Relay transactional outbox → RabbitMQ и восстановление зависшей работы. Работает в каждой реплике API.
// publishDue: строки outbox, у которых наступил available_at, блокируются FOR UPDATE SKIP LOCKED (две реплики
// не публикуют одну строку одновременно), публикуются с publisher confirm и только потом отмечаются.
// Падение после confirm, но до отметки → повторная публикация → дубль, который worker распознаёт по job.
// sweep: истёкшая аренда (worker умер/завис) → новая попытка или failed retry_exhausted; queued без живого
// сообщения (потеряно брокером, отброшено delivery-limit) → публикуется снова. Источник истины — БД.
// Lab6: каждое сообщение публикуется в PRODUCER span, дочернем к контексту строки outbox (запрос загрузки,
// попытка worker-а или, у sweeper, предыдущая публикация той же job), и несёт traceparent/tracestate этого span
// в теле (contracts/jobs.schema.json) — worker продолжает тот же trace. Здесь же метрики очереди по БД.
import { ROOT_CONTEXT, SpanKind, SpanStatusCode, context, trace, type Span } from '@opentelemetry/api';
import type { Pool, PoolClient, QueryConfig } from 'pg';
import type { JobsConfig } from '../config.ts';
import { failpoint } from '../failpoints.ts';
import { contextFrom, log, meter, traceCarrier, tracer } from '../otel.ts';
import { EXCHANGE, QUEUE, ROUTING_KEY, type Job, type Publisher } from './broker.ts';
import { JOB_TYPE, timeToReady } from './metrics.ts';
const BATCH = 100;
export function startRelay(db: Pool, publisher: Publisher, cfg: JobsConfig) {
let busy = false;
let again = false;
let failing = false; // лог ошибки брокера один раз на серию, а не каждые 500 мс
async function publishBatch(client: PoolClient): Promise<number> {
const r = await client.query(`SELECT o.id, o.attempt, o.traceparent, o.tracestate, rfc3339(o.created_at) AS created_at,
j.job_id, j.attachment_id, j.pipeline_version, a.filename
FROM outbox o JOIN jobs j ON j.job_id = o.job_id JOIN attachments a ON a.id = j.attachment_id
WHERE o.published_at IS NULL AND o.available_at <= clock_timestamp()
ORDER BY o.id LIMIT ${BATCH} FOR UPDATE OF o SKIP LOCKED`);
if (!r.rowCount) return 0;
const spans: Span[] = [];
const jobs: Job[] = r.rows.map((row) => {
const parent = contextFrom(row);
const span = tracer.startSpan(`publish ${EXCHANGE}`, {
kind: SpanKind.PRODUCER,
attributes: {
'messaging.system': 'rabbitmq', 'messaging.operation.type': 'send', 'messaging.operation.name': 'publish',
'messaging.destination.name': EXCHANGE, 'messaging.rabbitmq.destination.routing_key': ROUTING_KEY,
'messaging.message.id': `${row.job_id}:${row.attempt}`, 'messenger.job.id': row.job_id,
'messenger.job.attempt': row.attempt, 'messenger.attachment.id': row.attachment_id,
},
}, parent);
spans.push(span);
const { traceparent, tracestate } = traceCarrier(trace.setSpan(parent, span));
return {
schema_version: 1, job_id: row.job_id, type: JOB_TYPE, attachment_id: row.attachment_id,
pipeline_version: row.pipeline_version, attempt: row.attempt, created_at: row.created_at,
...(traceparent ? { traceparent } : {}), ...(tracestate ? { tracestate } : {}),
};
});
try {
await publisher.publish(jobs);
} catch (err) {
for (const span of spans) {
span.recordException(err as Error);
span.setStatus({ code: SpanStatusCode.ERROR, message: 'не опубликовано, строка остаётся в outbox' });
span.end();
}
throw err;
}
spans.forEach((span, i) => {
context.with(trace.setSpan(context.active(), span), () => log('info', 'job.published',
`job опубликована в ${EXCHANGE}, попытка ${jobs[i].attempt}`,
{ 'messenger.job.id': jobs[i].job_id, 'messenger.job.attempt': jobs[i].attempt, 'messenger.attachment.id': jobs[i].attachment_id }));
span.end();
});
for (const row of r.rows) await failpoint(db, 'relay_after_publish', row.attachment_id, row.filename);
await client.query('UPDATE outbox SET published_at = clock_timestamp() WHERE id = ANY($1::bigint[])', [r.rows.map((row) => row.id)]);
return r.rows.length;
}
async function publishDue(): Promise<void> {
if (busy) {
again = true;
return;
}
busy = true;
try {
do {
again = false;
const client = await db.connect();
try {
await client.query('BEGIN');
const n = await publishBatch(client);
await client.query('COMMIT');
if (failing) log('info', 'relay.publish_restored', 'relay: публикация восстановлена');
failing = false;
if (n === BATCH) again = true;
} catch (err) {
await client.query('ROLLBACK').catch(() => {});
if (!failing) log('warn', 'relay.publish_deferred', `relay: публикация отложена, задания ждут в outbox: ${(err as Error).message}`);
failing = true;
again = false;
} finally {
client.release();
}
} while (again);
} catch (err) {
if (!failing) log('error', 'relay.db_unavailable', `relay: нет соединения с БД: ${(err as Error).message}`);
failing = true;
} finally {
busy = false;
}
}
async function sweep(): Promise<void> {
let client: PoolClient | undefined;
let exhausted: { age: number }[] = [];
try {
client = await db.connect();
await client.query('BEGIN');
// Одна реплика за раз: остальные пропускают такт.
if ((await client.query('SELECT pg_try_advisory_xact_lock(5005) AS ok')).rows[0].ok) {
const r = await client.query(`WITH e AS (
UPDATE jobs SET state = CASE WHEN attempts >= $1 THEN 'failed' ELSE 'queued' END,
error_code = CASE WHEN attempts >= $1 THEN 'retry_exhausted' END,
lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
WHERE state = 'processing' AND lease_until < clock_timestamp()
RETURNING job_id, attachment_id, state, attempts, error_code, extract(epoch FROM clock_timestamp() - created_at)::float8 AS age),
s AS (UPDATE attachments a SET state = e.state, error_code = e.error_code, updated_at = clock_timestamp() FROM e
WHERE a.id = e.attachment_id AND a.pipeline_version IS NULL AND a.state IN ('queued', 'processing') RETURNING a.id),
o AS (INSERT INTO outbox (job_id, attempt, traceparent, tracestate)
SELECT e.job_id, e.attempts + 1, l.traceparent, l.tracestate FROM e
LEFT JOIN LATERAL (SELECT traceparent, tracestate FROM outbox WHERE job_id = e.job_id ORDER BY id DESC LIMIT 1) l ON true
WHERE e.state = 'queued')
SELECT e.state, e.age, s.id IS NOT NULL AS initial FROM e LEFT JOIN s ON s.id = e.attachment_id`, [cfg.maxAttempts]);
// Повторная публикация продолжает trace предыдущей: контекст копируется из последней строки outbox job.
const stale = await client.query(`INSERT INTO outbox (job_id, attempt, traceparent, tracestate)
SELECT j.job_id, j.attempts + 1, l.traceparent, l.tracestate FROM jobs j
LEFT JOIN LATERAL (SELECT traceparent, tracestate FROM outbox WHERE job_id = j.job_id ORDER BY id DESC LIMIT 1) l ON true
WHERE j.state = 'queued' AND NOT EXISTS (SELECT 1 FROM outbox o WHERE o.job_id = j.job_id
AND (o.published_at IS NULL OR o.published_at > clock_timestamp() - make_interval(secs => $1)))`, [cfg.republishSeconds]);
const requeued = r.rows.filter((row) => row.state === 'queued').length;
const failed = r.rows.filter((row) => row.state === 'failed');
exhausted = failed.filter((row) => row.initial);
if (requeued || failed.length || stale.rowCount) {
log('warn', 'sweeper.recovered', `sweeper: аренда истекла — повтор ${requeued}, failed ${failed.length}; переопубликовано queued ${stale.rowCount}`,
{ requeued, failed: failed.length, republished: stale.rowCount ?? 0 });
}
}
await client.query('COMMIT');
// Исчерпание попыток после смерти worker-ов — терминальная ошибка для SLO time-to-ready (после COMMIT).
for (const row of exhausted) timeToReady.record(row.age, { 'job.type': JOB_TYPE, outcome: 'failed', 'error.type': 'retry_exhausted' });
} catch (err) {
await client?.query('ROLLBACK').catch(() => {});
log('error', 'sweeper.error', `sweeper: ${(err as Error).message}`);
} finally {
client?.release();
}
if (!failing) void publishDue();
}
// Очередь по источнику истины (БД): видна и при остановленном worker (растёт возраст), и при недоступном брокере
// (копится outbox). Каждая реплика API сообщает одно и то же — в PromQL берётся max по репликам.
const attrs = { queue: QUEUE };
const backlog = meter.createObservableGauge('messenger.jobs.backlog', { unit: '{job}', description: 'Unfinished jobs by state' });
const oldest = meter.createObservableGauge('messenger.jobs.oldest_age', { unit: 's', description: 'Age of the oldest unfinished job since durable acceptance' });
const pending = meter.createObservableGauge('messenger.outbox.pending', { unit: '{message}', description: 'Outbox rows not yet confirmed by the broker' });
meter.addBatchObservableCallback(async (result) => {
try {
// query_timeout — на клиенте: statement_timeout сервера не сработает, если PostgreSQL заморожен; зависший сбор
// задержал бы экспорт всех метрик API и занял соединение пула. При ошибке пул закрывает это соединение.
const q = (await db.query({ query_timeout: 2000, text: `SELECT count(*) FILTER (WHERE state = 'queued')::int AS queued,
count(*) FILTER (WHERE state = 'processing')::int AS processing,
COALESCE(extract(epoch FROM clock_timestamp() - min(created_at)), 0)::float8 AS oldest,
(SELECT count(*)::int FROM outbox WHERE published_at IS NULL) AS pending
FROM jobs WHERE state IN ('queued', 'processing')` } as QueryConfig)).rows[0]; // query_timeout нет в @types/pg QueryConfig
result.observe(backlog, q.queued, { ...attrs, state: 'queued' });
result.observe(backlog, q.processing, { ...attrs, state: 'processing' });
result.observe(oldest, q.oldest, attrs);
result.observe(pending, q.pending, attrs);
} catch {
// БД недоступна: точек нет, на графике разрыв; причину покажут ошибки API и readiness.
}
}, [backlog, oldest, pending]);
const timers = [setInterval(publishDue, 500), setInterval(sweep, 5000)];
return {
// Вне контекста запроса: пакет может содержать задания разных загрузок, его SQL не относится к этому trace.
kick: () => context.with(ROOT_CONTEXT, () => void publishDue()),
stop: () => timers.forEach(clearInterval),
};
}
+84
View File
@@ -0,0 +1,84 @@
// Варианты изображения (libvips через sharp). Параметры зависят от версии pipeline; результат версии N
// всегда один и тот же набор: thumbnail, crop, optimized.
// thumbnail — JPEG, вписан в 256×256 без увеличения, EXIF orientation применяется, alpha на белом,
// размеры округляются вниз (не меньше 1 px): 320×200 → 256×160;
// crop — JPEG, центрированный квадрат 128×128 (маленький исходник увеличивается);
// optimized — WebP, вписан в 1280×1280 без увеличения; метаданные (EXIF/XMP/ICC) не копируются — sharp
// по умолчанию их отбрасывает, цвета приводятся к sRGB.
// Ограничения: пиксели проверяются по заголовку до декодирования (limitInputPixels), время — timeout libvips,
// память — один поток libvips на процесс, без кэша операций, и лимит памяти контейнера worker.
import { createHash } from 'node:crypto';
import sharp, { type Sharp } from 'sharp';
sharp.cache(false);
sharp.concurrency(1);
export class PermanentError extends Error {
code: string;
constructor(code: string, message: string) {
super(message);
this.code = code;
}
}
// Версия 2 (трек 5): другое качество и лёгкая резкость — заметно иной результат той же логической работы.
const PIPELINES: Record<number, { jpeg: number; webp: number; sharpen: boolean }> = {
1: { jpeg: 82, webp: 80, sharpen: false },
2: { jpeg: 90, webp: 85, sharpen: true },
};
export const SUPPORTED_VERSIONS = Object.keys(PIPELINES).map(Number);
export type Rendered = {
name: 'thumbnail' | 'crop' | 'optimized';
content_type: 'image/jpeg' | 'image/webp';
ext: string;
data: Buffer;
width: number;
height: number;
size_bytes: number;
sha256: string;
};
export async function render(source: Buffer, version: number, maxPixels: number, timeoutSeconds: number): Promise<Rendered[]> {
const p = PIPELINES[version];
if (!p) throw new PermanentError('unsupported_pipeline', `pipeline v${version} не поддерживается`);
const input = () => sharp(source, { limitInputPixels: maxPixels, sequentialRead: true }).timeout({ seconds: timeoutSeconds });
try {
const meta = await input().metadata();
if (!meta.width || !meta.height || !['png', 'jpeg'].includes(meta.format ?? '')) throw new PermanentError('invalid_image', 'не PNG/JPEG');
const turned = (meta.orientation ?? 1) >= 5; // EXIF 5–8: после поворота ширина и высота меняются местами
const width = turned ? meta.height : meta.width;
const height = turned ? meta.width : meta.height;
const inside = (box: number) => {
const k = Math.min(box / width, box / height, 1);
return [Math.max(1, Math.floor(width * k)), Math.max(1, Math.floor(height * k))];
};
const [tw, th] = inside(256);
const [ow, oh] = inside(1280);
const oriented = () => {
const img = input().autoOrient();
return p.sharpen ? img.sharpen() : img;
};
return [
await output('thumbnail', oriented().flatten({ background: '#ffffff' }).resize(tw, th, { fit: 'fill' }).jpeg({ quality: p.jpeg, mozjpeg: true })),
await output('crop', oriented().flatten({ background: '#ffffff' }).resize(128, 128, { fit: 'cover', position: 'centre' }).jpeg({ quality: p.jpeg, mozjpeg: true })),
await output('optimized', oriented().resize(ow, oh, { fit: 'fill' }).webp({ quality: p.webp, effort: 4 })),
];
} catch (err) {
if (err instanceof PermanentError) throw err;
const message = (err as Error).message ?? '';
// Ошибки libvips — свойство входного файла: повтор не поможет.
throw /timeout/i.test(message)
? new PermanentError('processing_timeout', 'обработка дольше лимита')
: new PermanentError('invalid_image', message.split('\n')[0].slice(0, 200));
}
}
async function output(name: Rendered['name'], img: Sharp): Promise<Rendered> {
const { data, info } = await img.toBuffer({ resolveWithObject: true });
const webp = info.format === 'webp';
return {
name, content_type: webp ? 'image/webp' : 'image/jpeg', ext: webp ? 'webp' : 'jpg', data,
width: info.width, height: info.height, size_bytes: data.length, sha256: createHash('sha256').update(data).digest('hex'),
};
}
+340
View File
@@ -0,0 +1,340 @@
// Worker: отдельный процесс, читает quorum-очередь attachments.process (at least once, ручной ack).
// Порядок одной попытки — каждое окно отказа безопасно:
// 1. захват: jobs queued → processing, attempts+1, аренда с fencing-токеном (одна транзакция);
// 2. исходник из S3 (ключ — из БД, не из сообщения), сверка размера и SHA-256 с метаданными;
// 3. рендер вариантов; запись объектов под ключами с токеном попытки; копия оригинала staging → originals;
// 4. фиксация (одна транзакция): job done только у владельца аренды, вложение ready только если более новая
// версия ещё не опубликована, строки вариантов по ключу эффекта (attachment_id, pipeline_version, name);
// 5. удаление staging, затем ack.
// Падение до 4 — аренда истечёт, sweeper (relay) вернёт работу в очередь; чужие объекты попытки уберёт
// reconciler. Падение после 4 — redelivery видит job done и подтверждает без повторной работы.
// Lab6: сообщение обрабатывается в CONSUMER span, дочернем к PRODUCER span из traceparent сообщения (тот же trace,
// что и загрузка); внутри — spans захвата, S3, рендера и фиксации. Повтор сохраняет контекст попытки в outbox,
// поэтому следующие публикация и обработка продолжают этот trace.
import { createHash, randomUUID } from 'node:crypto';
import { setTimeout as sleep } from 'node:timers/promises';
import { SpanKind, SpanStatusCode, context, trace } from '@opentelemetry/api';
import amqp, { type ConsumeMessage } from 'amqplib';
import type { Pool } from 'pg';
import { envInt, jobsConfig, s3Config, secret } from '../config.ts';
import { createPool } from '../db.ts';
import { failpoint } from '../failpoints.ts';
import { contextFrom, flushTelemetry, inSpan, log, meter, traceCarrier, tracer } from '../otel.ts';
import { createStorage, type Storage } from '../storage/s3.ts';
import { QUEUE, parseJob, type Job } from './broker.ts';
import { JOB_TYPE, jobDuration, timeToReady } from './metrics.ts';
import { PermanentError, render } from './render.ts';
type Claim = {
job: Job;
token: string;
attempts: number;
version: number;
initial: boolean; // первая обработка (вложение ещё не ready): публикуем оригинал, синхронизируем статус
a: { id: string; filename: string; staging_key: string; object_key: string; size_bytes: number; sha256: string };
};
// Исход обработки одного сообщения: атрибут span и метрики messenger.job.duration.
type Outcome = 'done' | 'retry' | 'failed' | 'noop' | 'discarded' | 'invalid' | 'error';
// Технические идентификаторы для логов/spans: нужны, чтобы найти конкретную загрузку (данные синтетические).
const ids = (c: Claim) => ({ 'messenger.job.id': c.job.job_id, 'messenger.job.attempt': c.attempts, 'messenger.attachment.id': c.a.id });
export async function runWorker(): Promise<void> {
const cfg = jobsConfig();
const concurrency = envInt('WORKER_CONCURRENCY', 2);
const maxPixels = envInt('MAX_IMAGE_PIXELS', 40000000);
const db = createPool(secret('DATABASE_URL'), concurrency + 2);
const s3 = createStorage(s3Config());
const conn = await connect(secret('BROKER_URL'));
let stopping = false;
// Потеря соединения или канала (в том числе consumer_timeout брокера) — выход; Docker перезапустит процесс,
// неподтверждённые сообщения брокер отдаст снова.
const lost = (what: string) => () => {
if (stopping) return;
log('error', 'worker.broker_lost', `${what} с брокером закрыт(о)`);
void flushTelemetry().finally(() => process.exit(1));
};
conn.on('close', lost('соединение'));
conn.on('error', (err) => log('error', 'worker.broker_error', `брокер: ${err.message}`));
const ch = await conn.createChannel();
ch.on('close', lost('канал'));
ch.on('error', (err) => log('error', 'worker.channel_error', `канал: ${err.message}`));
await ch.prefetch(concurrency); // не больше concurrency неподтверждённых сообщений на worker
const leaseSeconds = cfg.timeoutSeconds + 15;
let inflight = 0;
// Насыщение worker-а: занятые слоты и ёмкость (= prefetch) каждой реплики.
meter.createObservableGauge('messenger.worker.busy', { unit: '{job}', description: 'Jobs being processed now' })
.addCallback((r) => r.observe(inflight));
meter.createObservableGauge('messenger.worker.capacity', { unit: '{job}', description: 'Max concurrent jobs (prefetch)' })
.addCallback((r) => r.observe(concurrency));
const opts = { cfg, maxPixels, leaseSeconds };
const { consumerTag } = await ch.consume(QUEUE, (msg) => {
if (!msg) return; // очередь удалена или consumer отменён брокером
inflight++;
consume(db, s3, msg, opts)
.then(() => ch.ack(msg), async () => {
// Сюда попадают только сбои БД/брокера вне попытки (например, БД недоступна при захвате): вернуть позже.
await sleep(2000);
ch.nack(msg, false, true);
})
.finally(() => { inflight--; });
}, { noAck: false });
log('info', 'worker.started', `worker: очередь ${QUEUE}, prefetch ${concurrency}, попыток ${cfg.maxAttempts}, таймаут ${cfg.timeoutSeconds} с`);
const stop = async () => {
log('info', 'worker.stopping', 'SIGTERM: новые сообщения не принимаются, дожидаюсь текущих');
await ch.cancel(consumerTag).catch(() => {});
for (let i = 0; inflight && i < 100; i++) await sleep(100);
stopping = true;
await conn.close().catch(() => {});
await flushTelemetry();
process.exit(0);
};
process.on('SIGTERM', stop);
process.on('SIGINT', stop);
}
// Брокер недоступен при старте (рестарт брокера, worker поднят раньше) — ждать с backoff, а не падать в цикле.
async function connect(url: string) {
for (let delay = 1000; ; delay = Math.min(delay * 2, 15000)) {
try {
return await amqp.connect(url, { timeout: 5000 });
} catch (err) {
log('warn', 'worker.broker_unavailable', `брокер недоступен (${(err as Error).message}), повтор через ${delay} мс`);
await sleep(delay);
}
}
}
type Opts = { cfg: ReturnType<typeof jobsConfig>; maxPixels: number; leaseSeconds: number };
// Одно сообщение — один CONSUMER span. Исключение (сбой вне попытки) пробрасывается: сообщение вернётся в очередь.
async function consume(db: Pool, s3: Storage, msg: ConsumeMessage, o: Opts): Promise<void> {
const job = parseJob(msg.content);
const parent = contextFrom(job ?? {});
const span = tracer.startSpan(`process ${QUEUE}`, {
kind: SpanKind.CONSUMER,
attributes: {
'messaging.system': 'rabbitmq', 'messaging.operation.type': 'process', 'messaging.destination.name': QUEUE,
'messaging.message.id': msg.properties.messageId ?? '', 'messenger.redelivered': msg.fields.redelivered,
...(job ? { 'messenger.job.id': job.job_id, 'messenger.job.attempt': job.attempt, 'messenger.attachment.id': job.attachment_id } : {}),
},
}, parent);
const ctx = trace.setSpan(parent, span);
const started = performance.now();
let outcome: Outcome = 'error';
try {
outcome = await context.with(ctx, () => handle(db, s3, job, o));
} catch (err) {
span.recordException(err as Error);
context.with(ctx, () => log('error', 'job.requeued', `job не обработан, вернётся в очередь: ${(err as Error).message}`,
{ 'messenger.job.id': job?.job_id ?? '' }));
throw err;
} finally {
if (!['done', 'noop', 'discarded'].includes(outcome)) span.setStatus({ code: SpanStatusCode.ERROR });
span.setAttribute('messenger.job.outcome', outcome);
span.end();
jobDuration.record((performance.now() - started) / 1000, { 'job.type': JOB_TYPE, outcome });
}
}
// Ошибка бизнес-уровня здесь не бросается: она переводит job в retry/failed, сообщение подтверждается.
async function handle(db: Pool, s3: Storage, job: Job | null, o: Opts): Promise<Outcome> {
if (!job) {
log('error', 'job.invalid_message', 'сообщение не по jobs.schema.json отброшено');
return 'invalid';
}
const claim = await inSpan('claim job', {}, () => claimJob(db, job, o.leaseSeconds));
if (!claim) return 'noop';
const written: string[] = [];
let reason = 'storage_unavailable'; // безопасная причина временной ошибки (в jobs.error_code, без текста исключения)
try {
await failpoint(db, 'worker_after_claim', claim.a.id, claim.a.filename); // до любого side effect
const source = await readSource(s3, claim);
const variants = await inSpan('render variants', { 'messenger.pipeline.version': claim.version, 'messenger.source.bytes': claim.a.size_bytes },
() => render(source, claim.version, o.maxPixels, o.cfg.timeoutSeconds));
for (const v of variants) {
// Токен попытки в ключе: проигравшая аренду попытка не перезапишет объекты победителя.
const key = `variants/${claim.a.id}/v${claim.version}/${v.name}-${claim.token.slice(0, 8)}.${v.ext}`;
await s3.putBuffer(key, v.data, v.content_type);
written.push(key);
}
if (claim.initial) await s3.copy(claim.a.staging_key, claim.a.object_key); // тот же ключ при повторе
await failpoint(db, 'worker_after_side_effect', claim.a.id, claim.a.filename);
reason = 'database_unavailable';
const age = await inSpan('commit result', {}, () => commit(db, claim, variants.map((v, i) => ({ ...v, key: written[i] }))));
if (age === null) {
await removeAll(s3, written);
return 'discarded';
}
await failpoint(db, 'worker_after_commit', claim.a.id, claim.a.filename); // результат зафиксирован, ack ещё нет
// Staging больше не нужен; если удаление не удалось, остаток уберёт reconciler.
if (claim.initial) {
await s3.remove(claim.a.staging_key).catch((err) => log('warn', 'job.staging_not_removed', `staging не удалён: ${err.message}`, ids(claim)));
timeToReady.record(age, { 'job.type': JOB_TYPE, outcome: 'ready' });
}
log('info', 'job.ready', `job v${claim.version} попытка ${claim.attempts}: ready через ${age.toFixed(2)} с после приёма`,
{ ...ids(claim), 'messenger.time_to_ready_s': Math.round(age * 1000) / 1000 });
return 'done';
} catch (err) {
await removeAll(s3, written);
return failOrRetry(db, claim, err, o.cfg, reason);
}
}
async function claimJob(db: Pool, job: Job, leaseSeconds: number): Promise<Claim | null> {
const client = await db.connect();
try {
await client.query('BEGIN');
const token = randomUUID();
// Захват только ожидаемой попытки: сообщение старой попытки (redelivery после падения) — no-op,
// живую аренду другого worker не трогаем — при его смерти работу вернёт sweeper.
const r = await client.query(`UPDATE jobs SET state = 'processing', attempts = attempts + 1, lease_token = $2,
lease_until = clock_timestamp() + make_interval(secs => $3), updated_at = clock_timestamp()
WHERE job_id = $1 AND attempts + 1 = $4
AND (state = 'queued' OR (state = 'processing' AND lease_until < clock_timestamp()))
RETURNING attachment_id, pipeline_version, attempts`, [job.job_id, token, leaseSeconds, job.attempt]);
if (!r.rowCount) {
await client.query('COMMIT');
const s = await db.query('SELECT state, attempts FROM jobs WHERE job_id = $1', [job.job_id]);
log('info', 'job.noop', `job попытка ${job.attempt}: no-op (${s.rows[0] ? `${s.rows[0].state}, попыток ${s.rows[0].attempts}` : 'неизвестная job'})`,
{ 'messenger.job.id': job.job_id, 'messenger.job.attempt': job.attempt });
return null;
}
const { attachment_id, pipeline_version, attempts } = r.rows[0];
const a = (await client.query(`SELECT id, filename, staging_key, object_key, size_bytes, sha256, state, pipeline_version
FROM attachments WHERE id = $1 FOR UPDATE`, [attachment_id])).rows[0];
// Результат этой или более новой версии уже опубликован: старая job не должна ничего перезаписать.
if (a.pipeline_version !== null && a.pipeline_version >= pipeline_version) {
await client.query(`UPDATE jobs SET state = 'superseded', lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
WHERE job_id = $1`, [job.job_id]);
await client.query('COMMIT');
log('info', 'job.superseded', `job v${pipeline_version}: superseded (опубликована v${a.pipeline_version})`, { 'messenger.job.id': job.job_id });
return null;
}
const initial = a.pipeline_version === null;
if (initial) await client.query(`UPDATE attachments SET state = 'processing', updated_at = clock_timestamp() WHERE id = $1 AND state = 'queued'`, [a.id]);
await client.query('COMMIT');
return { job, token, attempts, version: pipeline_version, initial, a };
} catch (err) {
await client.query('ROLLBACK').catch(() => {});
throw err;
} finally {
client.release();
}
}
// Исходник: при первой обработке — staging, при переобработке новой версией — опубликованный оригинал.
// Читается не больше size_bytes + 1 байт и сверяется с доверенными метаданными из БД.
async function readSource(s3: Storage, claim: Claim): Promise<Buffer> {
const body = await s3.get(claim.initial ? claim.a.staging_key : claim.a.object_key);
if (!body) throw new PermanentError('source_missing', 'исходник отсутствует в S3');
const chunks: Buffer[] = [];
let size = 0;
for await (const chunk of body) {
size += chunk.length;
if (size > claim.a.size_bytes) {
body.destroy();
break;
}
chunks.push(chunk);
}
const data = Buffer.concat(chunks);
if (size !== claim.a.size_bytes || createHash('sha256').update(data).digest('hex') !== claim.a.sha256) {
throw new PermanentError('source_corrupted', 'исходник не совпадает с метаданными');
}
return data;
}
type Stored = { name: string; content_type: string; size_bytes: number; width: number; height: number; sha256: string; key: string };
// Возвращает секунды от приёма загрузки (jobs.created_at) до публикации ready или null, если результат отброшен.
async function commit(db: Pool, claim: Claim, variants: Stored[]): Promise<number | null> {
const client = await db.connect();
try {
await client.query('BEGIN');
// Fencing: если аренда истекла и работу забрал другой worker, токен уже не совпадает.
const done = await client.query(`UPDATE jobs SET state = 'done', lease_token = NULL, lease_until = NULL, error_code = NULL,
updated_at = clock_timestamp() WHERE job_id = $1 AND lease_token = $2 AND state = 'processing'
RETURNING extract(epoch FROM clock_timestamp() - created_at)::float8 AS age`, [claim.job.job_id, claim.token]);
if (!done.rowCount) {
await client.query('ROLLBACK');
log('warn', 'job.lease_lost', `job попытка ${claim.attempts}: аренда потеряна, результат отброшен`, ids(claim));
return null;
}
const ready = await client.query(`UPDATE attachments SET state = 'ready', pipeline_version = $2, error_code = NULL, updated_at = clock_timestamp()
WHERE id = $1 AND (pipeline_version IS NULL OR pipeline_version < $2)`, [claim.a.id, claim.version]);
if (!ready.rowCount) {
await client.query(`UPDATE jobs SET state = 'superseded' WHERE job_id = $1`, [claim.job.job_id]);
await client.query('COMMIT');
log('info', 'job.superseded', `job v${claim.version}: superseded при фиксации`, ids(claim));
return null;
}
for (const v of variants) {
await client.query(`INSERT INTO attachment_variants (attachment_id, pipeline_version, name, object_key, content_type, size_bytes, width, height, sha256)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [claim.a.id, claim.version, v.name, v.key, v.content_type, v.size_bytes, v.width, v.height, v.sha256]);
}
await client.query('COMMIT');
return done.rows[0].age;
} catch (err) {
await client.query('ROLLBACK').catch(() => {});
throw err;
} finally {
client.release();
}
}
// Постоянная ошибка (свойство файла) → failed сразу. Временная → новая попытка через outbox с backoff и jitter,
// пока attempts < JOB_MAX_ATTEMPTS, затем failed retry_exhausted. Всё — только у владельца аренды.
// У job в error_code — последняя причина (и для queued), у вложения — только финальный код failed.
// Lab6: новая строка outbox несёт контекст текущего CONSUMER span — повтор продолжит тот же trace.
// Лог, исключение в span и метрика — только если UPDATE с fencing изменил job: проигравшая аренду попытка → discarded.
async function failOrRetry(db: Pool, claim: Claim, err: unknown, cfg: Opts['cfg'], reason: string): Promise<'retry' | 'failed' | 'discarded'> {
const permanent = err instanceof PermanentError ? err.code : null;
const exhausted = !permanent && claim.attempts >= cfg.maxAttempts;
const state = permanent || exhausted ? 'failed' : 'queued';
const code = permanent ?? (exhausted ? 'retry_exhausted' : null);
const delayMs = Math.min(60000, cfg.retryBaseMs * 2 ** (claim.attempts - 1)) * (0.5 + Math.random() / 2);
const { traceparent, tracestate } = traceCarrier();
const client = await db.connect();
try {
await client.query('BEGIN');
const r = await client.query(`UPDATE jobs SET state = $3, error_code = $4, lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
WHERE job_id = $1 AND lease_token = $2 RETURNING extract(epoch FROM clock_timestamp() - created_at)::float8 AS age`,
[claim.job.job_id, claim.token, state, code ?? reason]);
if (r.rowCount) {
if (state === 'queued') {
await client.query(`INSERT INTO outbox (job_id, attempt, available_at, traceparent, tracestate)
VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3), $4, $5)`, [claim.job.job_id, claim.attempts + 1, delayMs / 1000, traceparent, tracestate]);
}
if (claim.initial) {
await client.query(`UPDATE attachments SET state = $2, error_code = $3, updated_at = clock_timestamp()
WHERE id = $1 AND pipeline_version IS NULL AND state IN ('queued', 'processing')`, [claim.a.id, state, code]);
}
}
await client.query('COMMIT');
if (!r.rowCount) {
log('warn', 'job.lease_lost', `job попытка ${claim.attempts}: аренда потеряна, ошибка попытки отброшена`, ids(claim));
return 'discarded';
}
trace.getActiveSpan()?.recordException(err as Error);
log(state === 'failed' ? 'error' : 'warn', state === 'failed' ? 'job.failed' : 'job.retry',
`job попытка ${claim.attempts}: ${(err as Error).message} → ${state}${code ? ` ${code}` : `, повтор через ${Math.round(delayMs)} мс`}`,
{ ...ids(claim), 'error.type': code ?? reason });
if (state === 'failed' && claim.initial) {
timeToReady.record(r.rows[0].age, { 'job.type': JOB_TYPE, outcome: 'failed', 'error.type': code ?? reason });
}
return state === 'failed' ? 'failed' : 'retry';
} catch (e) {
await client.query('ROLLBACK').catch(() => {});
throw e; // job останется processing: аренда истечёт и sweeper вернёт её
} finally {
client.release();
}
}
async function removeAll(s3: Storage, keys: string[]): Promise<void> {
for (const key of keys) await s3.remove(key).catch(() => {}); // остаток уберёт reconciler
}
+87
View File
@@ -0,0 +1,87 @@
// Точка входа мессенджера (лабораторная 6).
// Реплика не хранит состояния: пользователи, сессии, чаты, сообщения, ключи идемпотентности, метаданные
// вложений и задания (jobs, outbox) — в PostgreSQL, байты — в S3, поэтому запрос может обслужить любая реплика.
// node src/main.ts — HTTP-сервер + relay outbox → RabbitMQ (src/jobs/relay.ts)
// node src/main.ts worker — обработка изображений из очереди (src/jobs/worker.ts, сервис worker)
// api и worker запускаются с --import ./src/telemetry.ts (OpenTelemetry SDK, см. Dockerfile и compose.yaml).
// node src/main.ts jobs … — операторские команды: failed | replay <id> | reprocess --version=N
// node src/main.ts migrate — однократный прогон миграций (сервис migrate)
// node src/main.ts s3-init — идемпотентное создание приватного bucket ключом администратора (сервис s3-init)
// node src/main.ts reconcile — сверка БД ↔ S3, параметры в src/reconcile.ts (сервис reconciler)
import { createServer } from 'node:http';
import { setTimeout as sleep } from 'node:timers/promises';
import { createApp } from './app.ts';
import { envInt, loadConfig, s3Config, secret } from './config.ts';
import { createPool, migrate } from './db.ts';
import { adminCommand } from './jobs/admin.ts';
import { createPublisher } from './jobs/broker.ts';
import { startRelay } from './jobs/relay.ts';
import { runWorker } from './jobs/worker.ts';
import { flushTelemetry, log } from './otel.ts';
import { reconcileCommand } from './reconcile.ts';
import { createStorage } from './storage/s3.ts';
async function serve(): Promise<void> {
const config = loadConfig();
const db = createPool(config.databaseUrl, config.dbPoolMax);
const relay = startRelay(db, createPublisher(config.brokerUrl), config.jobs);
const app = createApp(db, createStorage(config.s3), config, relay);
const server = createServer(app.handle);
server.headersTimeout = 5000;
server.requestTimeout = 60000; // 10 MiB на медленном канале; grace reconciler-а (15 мин) заведомо больше
server.keepAliveTimeout = 60000;
server.listen(config.port, config.host, () =>
log('info', 'server.started', `реплика ${config.instanceId} слушает :${config.port}, пул БД ${config.dbPoolMax}`));
// Graceful shutdown: сначала readiness → 503 и пауза drain, пока LB не исключит реплику (fall × inter),
// при этом запросы ещё обслуживаются; затем перестаём принимать соединения и дожидаемся текущих запросов.
const stop = (signal: string) => {
if (!app.state.ready) return;
log('info', 'server.draining', `${signal}: readiness=503, drain ${config.shutdownDrainMs} мс`);
app.state.ready = false;
relay.stop();
setTimeout(() => {
server.close(async () => {
await db.end();
log('info', 'server.stopped', 'остановлена');
await flushTelemetry(); // последние spans/логи/метрики — до выхода процесса
process.exit(0);
});
server.closeIdleConnections();
setTimeout(() => process.exit(1), 10000).unref(); // страховка от зависшего запроса
}, config.shutdownDrainMs);
};
process.on('SIGTERM', () => stop('SIGTERM'));
process.on('SIGINT', () => stop('SIGINT'));
}
// S3 может стартовать позже: повторяем до 30 с. Повторный запуск на готовом bucket ничего не меняет.
async function s3Init(): Promise<void> {
const storage = createStorage(s3Config());
for (let attempt = 1; ; attempt++) {
try {
console.log(`bucket ${storage.bucket}: ${await storage.createBucket()}`); // вывод проверяет scripts/check-s3-security.sh
return;
} catch (err) {
if (attempt >= 30) throw err;
await sleep(1000);
}
}
}
const command = process.argv[2];
if (command === 'migrate') {
await migrate(secret('DATABASE_URL'));
} else if (command === 's3-init') {
await s3Init();
} else if (command === 'worker') {
await runWorker();
} else if (command === 'jobs') {
const db = createPool(secret('DATABASE_URL'), 2);
await adminCommand(db, process.argv.slice(3));
await db.end();
} else if (command === 'reconcile') {
await reconcileCommand(process.argv.slice(3), envInt('RECONCILE_GRACE_SECONDS', 900), envInt('STAGING_RETENTION_SECONDS', 86400));
} else {
await serve();
}
+57
View File
@@ -0,0 +1,57 @@
-- Начальная схема мессенджера. Источник истины для всех реплик API.
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL UNIQUE,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
-- Хранится только sha256(токена): дамп БД не содержит рабочих Bearer-токенов.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id),
expires_at timestamptz NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
position int NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
sender_id uuid NOT NULL REFERENCES users (id),
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
-- Ключи идемпотентности: область = пользователь + метод + путь + ключ.
-- Строка вставляется тем же SQL-оператором, что и сообщение (атомарно).
-- ponytail: ключи не удаляются (контракт требует >= 24 ч); при росте таблицы добавить периодический DELETE.
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL,
method text NOT NULL,
path text NOT NULL,
key text NOT NULL,
request_hash bytea NOT NULL,
message_id uuid NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (user_id, method, path, key)
);
-- RFC 3339 UTC с микросекундами: формат ответа API и точная позиция keyset-cursor.
CREATE FUNCTION rfc3339(timestamptz) RETURNS text LANGUAGE sql STABLE AS
$$ SELECT to_char($1 AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') $$;
+38
View File
@@ -0,0 +1,38 @@
-- Вложения (lab4). Только добавление схемы: версия lab3 продолжает работать на этой схеме.
-- Метаданные — здесь, байты — в приватном S3-bucket под ключом object_key, который назначает сервер.
-- pending — запись-намерение: создаётся ДО загрузки байтов, поэтому у любого объекта в S3 сначала есть строка;
-- ready — объект загружен и проверен, метаданные описывают оригинал;
-- lost — reconciler не нашёл объект или он не совпал по размеру/SHA-256: вложение скрыто из API (404),
-- ссылки в сообщениях сохраняются, при возврате правильного объекта reconciler вернёт ready.
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
owner_id uuid NOT NULL REFERENCES users (id),
filename text NOT NULL,
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
-- Побайтовая сортировка совпадает с порядком ListObjectsV2: reconciler сливает два отсортированных потока.
object_key text COLLATE "C" NOT NULL UNIQUE,
state text NOT NULL DEFAULT 'pending' CHECK (state IN ('pending', 'ready', 'lost')),
size_bytes integer CHECK (size_bytes > 0),
sha256 text CHECK (sha256 ~ '^[0-9a-f]{64}$'),
width integer,
height integer,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
UNIQUE (chat_id, id), -- цель составного FK из message_attachments
CHECK (state = 'pending' OR (size_bytes IS NOT NULL AND sha256 IS NOT NULL))
);
-- Поиск зависших загрузок reconciler-ом.
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE state = 'pending';
-- Вложения сообщения. FK (chat_id, attachment_id) → attachments (chat_id, id): БД не даст прикрепить вложение
-- чужого чата и не даст удалить метаданные вложения, на которое ссылается сообщение (NO ACTION).
CREATE TABLE message_attachments (
message_id uuid NOT NULL REFERENCES messages (id),
chat_id uuid NOT NULL,
attachment_id uuid NOT NULL,
position int NOT NULL,
PRIMARY KEY (message_id, attachment_id),
FOREIGN KEY (chat_id, attachment_id) REFERENCES attachments (chat_id, id)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id, chat_id);
+74
View File
@@ -0,0 +1,74 @@
-- Фоновая обработка вложений (lab5). Только добавление: версия lab4 продолжает работать на этой схеме.
-- Состояния вложения: pending (байты ещё принимаются) → queued (оригинал устойчиво в staging, задание
-- сохранено) → processing → ready | failed; lost — карантин reconciler (объект пропал или повреждён).
ALTER TABLE attachments DROP CONSTRAINT attachments_state_check;
ALTER TABLE attachments ADD CONSTRAINT attachments_state_check
CHECK (state IN ('pending', 'queued', 'processing', 'ready', 'failed', 'lost'));
ALTER TABLE attachments
ADD COLUMN staging_key text COLLATE "C" UNIQUE, -- staging/<id>: принятый оригинал до публикации worker-ом
ADD COLUMN pipeline_version int, -- версия pipeline опубликованного результата (ready)
ADD COLUMN error_code text; -- машинный код failed, без деталей
-- Логическая работа: одна на (вложение, версия pipeline). job_id не меняется при повторах и redelivery.
CREATE TABLE jobs (
job_id uuid PRIMARY KEY,
attachment_id uuid NOT NULL REFERENCES attachments (id),
pipeline_version int NOT NULL,
state text NOT NULL DEFAULT 'queued'
CHECK (state IN ('queued', 'processing', 'done', 'failed', 'superseded')),
attempts int NOT NULL DEFAULT 0, -- начатые попытки (успешные захваты аренды)
lease_token uuid, -- fencing: результат фиксирует только владелец аренды
lease_until timestamptz,
error_code text,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
UNIQUE (attachment_id, pipeline_version)
);
CREATE INDEX jobs_lease_idx ON jobs (lease_until) WHERE state = 'processing';
CREATE INDEX jobs_queued_idx ON jobs (updated_at) WHERE state = 'queued';
-- Transactional outbox: строка пишется в одной транзакции с изменением состояния, relay публикует её
-- в брокер после COMMIT и только после publisher confirm отмечает published_at.
CREATE TABLE outbox (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
job_id uuid NOT NULL REFERENCES jobs (job_id),
attempt int NOT NULL,
available_at timestamptz NOT NULL DEFAULT clock_timestamp(), -- момент после backoff повтора
published_at timestamptz,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX outbox_due_idx ON outbox (available_at) WHERE published_at IS NULL;
CREATE INDEX outbox_job_idx ON outbox (job_id, created_at);
-- Результат обработки. Ключ эффекта (attachment_id, pipeline_version, name): повтор той же job
-- не может создать второй набор вариантов.
CREATE TABLE attachment_variants (
attachment_id uuid NOT NULL REFERENCES attachments (id),
pipeline_version int NOT NULL,
name text NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
object_key text COLLATE "C" NOT NULL UNIQUE,
content_type text NOT NULL,
size_bytes int NOT NULL,
width int NOT NULL,
height int NOT NULL,
sha256 text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (attachment_id, pipeline_version, name)
);
-- Аудит операторского replay failed → queued.
CREATE TABLE job_replays (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
job_id uuid NOT NULL REFERENCES jobs (job_id),
previous_error text,
previous_attempts int NOT NULL,
replayed_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
-- Учебный fault-injection (src/failpoints.ts): точка срабатывает один раз на вложение. Пусто, если FAILPOINTS выключены.
CREATE TABLE failpoint_hits (
name text NOT NULL,
attachment_id uuid NOT NULL,
hit_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (name, attachment_id)
);
+6
View File
@@ -0,0 +1,6 @@
-- Lab6: W3C trace context задания. Строка outbox хранит контекст того, кто поставил попытку в очередь
-- (upload, worker при повторе, sweeper — копия предыдущей), relay кладёт его в сообщение (traceparent/tracestate
-- из contracts/jobs.schema.json). Только добавление nullable-столбцов: код lab5 продолжает работать на этой схеме.
ALTER TABLE outbox
ADD COLUMN traceparent text,
ADD COLUMN tracestate text;
+182
View File
@@ -0,0 +1,182 @@
// Вложения: приём PNG/JPEG в устойчивый staging, фоновая обработка worker-ом, скачивание только через API.
//
// Приём (lab5): ответ 202 означает, что устойчиво сохранено всё, что нужно для завершения работы без клиента:
// 1. INSERT строки pending (запись-намерение с ключами staging и оригинала) — COMMIT;
// 2. поток байтов: клиент → проверка формата + SHA-256 → S3 staging/<id>;
// 3. одна транзакция: pending → queued, job и строка outbox (transactional outbox) — COMMIT → 202.
// Брокер в этот момент не нужен: relay (src/jobs/relay.ts) опубликует задание после COMMIT, даже если брокер
// поднимется позже. Ошибка на шагах 2–3 → компенсация; падение процесса → pending-строку уберёт reconciler.
// Lab6: строка outbox запоминает trace context запроса загрузки — publish и обработка worker-ом продолжат этот trace.
import { createHash, randomUUID } from 'node:crypto';
import { Transform } from 'node:stream';
import { failpoint } from '../failpoints.ts';
import type { Ctx, Result } from '../http/context.ts';
import { badRequest, conflict, notFound, tooLarge, unavailable, unsupported } from '../http/errors.ts';
import { isText, mediaType, uuidParam } from '../http/request.ts';
import { log, traceCarrier } from '../otel.ts';
import { requireMember } from './chats.ts';
import { imageValidator, type Dimensions } from './images.ts';
import type { User } from './model.ts';
import { authenticate } from './sessions.ts';
const FORBIDDEN_IN_FILENAME = /[/\\\p{Cc}]/u; // разделители путей, NUL и управляющие символы C0/C1
const VARIANTS = ['thumbnail', 'crop', 'optimized'];
// Варианты — опубликованной версии pipeline; у queued/processing/failed их нет.
const columns = `a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.state AS status, a.error_code,
rfc3339(a.created_at) AS created_at, rfc3339(a.updated_at) AS updated_at,
COALESCE((SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type, 'size_bytes', v.size_bytes,
'width', v.width, 'height', v.height, 'sha256', v.sha256) ORDER BY v.name)
FROM attachment_variants v WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version), '[]') AS variants`;
const VISIBLE = `('queued', 'processing', 'ready', 'failed')`; // pending ещё не принято, lost — в карантине
type Row = Record<string, unknown> & { object_key?: string; pipeline_version?: number | null };
// Ключи объектов и внутренняя версия pipeline наружу не отдаются.
const view = ({ object_key: _, pipeline_version: __, ...row }: Row) => row;
// POST /api/v1/chats/{chat_id}/attachments?filename=… — сырые байты одного PNG/JPEG → 202 queued.
// Все лимиты проверяются до чтения тела; тело не буферизуется целиком ни в памяти, ни на диске API.
export async function uploadAttachment(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const chatId = await requireMember(c, user);
const filename = c.url.searchParams.get('filename');
if (!isText(filename, 1, 255) || FORBIDDEN_IN_FILENAME.test(filename)) {
throw badRequest('filename: 1–255 символов, без / \\ и управляющих символов');
}
const type = mediaType(c.req);
if (type !== 'image/png' && type !== 'image/jpeg') throw unsupported('Ожидается image/png или image/jpeg');
const declared = c.req.headers['content-length'];
if (declared === undefined || !/^\d+$/.test(declared)) throw badRequest('Нужен Content-Length: файл передаётся потоком в S3');
const length = Number(declared);
if (length > c.config.maxUploadBytes) throw tooLarge(`Файл больше ${c.config.maxUploadBytes} байт`);
if (length === 0) throw unsupported('Пустое тело не является изображением');
const id = randomUUID();
const staging = `staging/${id}`; // filename только для отображения и в ключи не попадает
await c.db.query(`INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, object_key, staging_key)
VALUES ($1, $2, $3, $4, $5, $6, $7)`, [id, chatId, user.id, filename, type, `originals/${id}`, staging]);
let row: Row;
try {
const dims = await store(c, staging, type, length);
await failpoint(c.db, 'api_after_staging', id, filename); // байты в staging, задания ещё нет
row = await accept(c, id, length, dims);
} catch (err) {
void discard(c, id, staging); // в фоне: при зависшем S3 клиент не ждёт ещё и DELETE
throw err;
}
await failpoint(c.db, 'api_after_commit', id, filename); // задание в outbox, публикации ещё не было
c.relay.kick();
return [202, view(row)];
}
// pending → queued + job + outbox одной транзакцией: после COMMIT работа не теряется при падении API.
async function accept(c: Ctx, id: string, length: number, dims: { sha256: string; width: number; height: number }): Promise<Row> {
const client = await c.db.connect();
try {
await client.query('BEGIN');
const r = await client.query(`UPDATE attachments AS a SET state = 'queued', size_bytes = $2, sha256 = $3, width = $4, height = $5,
updated_at = clock_timestamp() WHERE a.id = $1 AND a.state = 'pending' RETURNING ${columns}`, [id, length, dims.sha256, dims.width, dims.height]);
if (!r.rowCount) throw unavailable('Загрузка не завершилась вовремя'); // строку уже убрал reconciler
const { traceparent, tracestate } = traceCarrier();
await client.query(`WITH j AS (INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES (gen_random_uuid(), $1, $2) RETURNING job_id)
INSERT INTO outbox (job_id, attempt, traceparent, tracestate) SELECT job_id, 1, $3, $4 FROM j`, [id, c.config.jobs.pipelineVersion, traceparent, tracestate]);
await client.query('COMMIT');
return r.rows[0];
} catch (err) {
await client.query('ROLLBACK').catch(() => {});
throw err;
} finally {
client.release();
}
}
// Клиент → проверка + SHA-256 → S3. Обратное давление: пока S3 не принял кусок, следующий не читается из сокета,
// поэтому память на загрузку не зависит от размера файла. Последний кусок уходит в S3 только после полной
// проверки файла: S3 не получит все Content-Length байт невалидного изображения, и объект не создастся.
async function store(c: Ctx, key: string, type: 'image/png' | 'image/jpeg', length: number) {
const check = imageValidator(type, c.config.maxImagePixels);
const hash = createHash('sha256');
const abort = new AbortController();
let received = 0;
let dims: Dimensions | undefined;
let failure: unknown;
const fail = (err: unknown) => {
failure ??= err;
abort.abort();
};
const body = new Transform({
transform(chunk: Buffer, _encoding, done) {
received += chunk.length;
hash.update(chunk);
check.write(chunk)
.then(async () => { if (received === length) dims = await check.end(); })
.then(() => done(null, chunk), done);
},
});
body.on('error', fail);
c.req.on('close', () => { if (!c.req.complete) fail(badRequest('Загрузка прервана клиентом')); });
c.req.pipe(body);
try {
await c.s3.put(key, body, length, type, abort.signal);
if (failure) throw failure;
if (!dims) throw new Error('S3 принял объект до конца проверки');
return { sha256: hash.digest('hex'), ...dims };
} catch (err) {
// Остаток тела читаем и выбрасываем: иначе ответ с ошибкой не дойдёт до клиента, который ещё отправляет файл.
c.req.unpipe(body);
c.req.resume();
body.destroy();
check.close();
throw failure ?? err;
}
}
// Компенсация неудачной загрузки. Объект удаляется, только если строка точно не стала queued: при
// неоднозначной ошибке COMMIT (соединение оборвалось) строка могла зафиксироваться, и байты нужны worker-у.
// Сбой здесь не теряет учёт: останется pending-строка с ключом staging, её подберёт reconciler.
async function discard(c: Ctx, id: string, key: string): Promise<void> {
try {
const deleted = await c.db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'`, [id]);
if (!deleted.rowCount && (await c.db.query('SELECT 1 FROM attachments WHERE id = $1', [id])).rowCount) return;
await c.s3.remove(key);
} catch (err) {
log('warn', 'attachment.compensation_failed', `компенсация вложения не завершена, остаток уберёт reconciler: ${(err as Error).message}`, { 'attachment.id': id });
}
}
// Вложение доступно только участникам его чата; постороннему — тот же 404, что и для несуществующего.
async function findVisible(c: Ctx, user: User): Promise<Row & { object_key: string }> {
const r = await c.db.query(`SELECT ${columns}, a.object_key, a.pipeline_version FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
WHERE a.id = $1 AND a.state IN ${VISIBLE}`, [uuidParam(c, 'attachment_id'), user.id]);
if (!r.rowCount) throw notFound();
return r.rows[0];
}
// GET /api/v1/attachments/{attachment_id} — снимок статуса; клиент опрашивает до ready/failed.
export async function getAttachment(c: Ctx): Promise<Result> {
return [200, view(await findVisible(c, await authenticate(c)))];
}
// GET /api/v1/attachments/{attachment_id}/content[?variant=original|thumbnail|crop|optimized] — байты потоком из S3.
// queued/processing/failed — 409; отсутствующий вариант ready-объекта — 404; без redirect.
export async function downloadAttachment(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const variant = c.url.searchParams.get('variant') ?? 'original';
if (variant !== 'original' && !VARIANTS.includes(variant)) throw badRequest('Неизвестный variant');
const row = await findVisible(c, user);
if (row.status !== 'ready') throw conflict(row.status === 'failed' ? 'Обработка вложения завершилась ошибкой' : 'Вложение ещё обрабатывается');
let target = { key: row.object_key, type: row.content_type as string, size: row.size_bytes as number };
if (variant !== 'original') {
const v = await c.db.query(`SELECT object_key, content_type, size_bytes FROM attachment_variants
WHERE attachment_id = $1 AND pipeline_version = $2 AND name = $3`, [row.id, row.pipeline_version, variant]);
if (!v.rowCount) throw notFound();
target = { key: v.rows[0].object_key, type: v.rows[0].content_type, size: v.rows[0].size_bytes };
}
const body = await c.s3.get(target.key);
if (!body) {
log('error', 'attachment.object_missing', `объект ${variant} вложения отсутствует в S3`, { 'attachment.id': row.id as string }); // reconciler пометит оригинал lost
throw notFound();
}
return [200, body, { 'Content-Type': target.type, 'Content-Length': target.size, 'X-Content-Type-Options': 'nosniff' }];
}
+68
View File
@@ -0,0 +1,68 @@
// Чаты: создание, список чатов пользователя, один чат, проверка членства.
import type { Ctx, Result } from '../http/context.ts';
import { badRequest, notFound } from '../http/errors.ts';
import { afterCursor, limitOf, page } from '../http/pagination.ts';
import { UUID, isText, jsonObject, readJson, uuidParam } from '../http/request.ts';
import { authenticate } from './sessions.ts';
import type { User } from './model.ts';
// Чаты, где состоит пользователь $1; member_ids в порядке, заданном при создании.
const chatSelect = `SELECT c.id, c.title, rfc3339(c.created_at) AS created_at,
(SELECT array_agg(m.user_id::text ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
FROM chats c JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1 `;
// chat_id из пути, если пользователь — участник. Постороннему тот же 404, что и для несуществующего чата.
export async function requireMember(c: Ctx, user: User): Promise<string> {
const chatId = uuidParam(c, 'chat_id');
const r = await c.db.query({
name: 'member',
text: 'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2',
values: [chatId, user.id],
});
if (!r.rowCount) throw notFound();
return chatId;
}
// POST /api/v1/chats: участники фиксируются при создании и обязательно включают создателя.
export async function createChat(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const b = jsonObject(await readJson(c.req), ['title', 'member_ids']);
const ids = b.member_ids;
if (!isText(b.title, 1, 100) || !Array.isArray(ids) || ids.length < 1 || ids.length > 100
|| !ids.every((id) => typeof id === 'string' && UUID.test(id))) {
throw badRequest('Неверные title или member_ids');
}
const members = ids.map((id: string) => id.toLowerCase());
if (new Set(members).size !== members.length || !members.includes(user.id)) {
throw badRequest('member_ids должны быть уникальны и включать создателя');
}
try {
// Один оператор = одна транзакция: при неизвестном участнике сработает FK и не создастся ничего.
const r = await c.db.query(`WITH c AS (INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at),
m AS (INSERT INTO chat_members (chat_id, user_id, position)
SELECT c.id, t.u::uuid, t.o FROM c, unnest($2::text[]) WITH ORDINALITY AS t(u, o))
SELECT id, title, rfc3339(created_at) AS created_at FROM c`, [b.title, members]);
return [201, { ...r.rows[0], member_ids: members }];
} catch (err) {
if ((err as { code?: string }).code === '23503') throw badRequest('Неизвестный участник'); // foreign_key_violation
throw err;
}
}
// GET /api/v1/chats: только чаты текущего пользователя, cursor привязан к пользователю.
export async function listChats(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const limit = limitOf(c.url);
const [ts, id] = afterCursor(c.url, 'c', user.id);
const r = await c.db.query(chatSelect + 'WHERE (c.created_at, c.id) > ($2, $3::uuid) ORDER BY c.created_at, c.id LIMIT $4',
[user.id, ts, id, limit + 1]);
return [200, page(r.rows, limit, 'c', user.id)];
}
// GET /api/v1/chats/{chat_id}
export async function getChat(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const r = await c.db.query(chatSelect + 'WHERE c.id = $2', [user.id, uuidParam(c, 'chat_id')]);
if (!r.rowCount) throw notFound();
return [200, r.rows[0]];
}
+411
View File
@@ -0,0 +1,411 @@
// Потоковая проверка PNG/JPEG по содержимому: без декодирования пикселей и без буферизации файла.
// Размеры берутся из заголовка (IHDR / SOF) и проверяются ДО распаковки данных, поэтому «бомба» отсекается сразу.
// PNG: сигнатура, порядок chunk-ов, CRC каждого chunk, длина PLTE; поток zlib распаковывается с подсчётом байтов
// (вывод выбрасывается, смотрится только байт фильтра 0–4 в начале каждой строки) и сверяется с объёмом,
// который следует из размеров и формата пикселя.
// JPEG: структура маркеров, ровно один SOF до первого SOS, обязательный EOI и те же проверки заголовков, на которых
// останавливается libjpeg-turbo (декодер Pillow и браузеров): 8 бит, 1/3/4 компонента, прореживание, таблицы
// DQT/DHT для каждого скана, параметры SOS; скан не пустой. Энтропийные данные не декодируются — битый
// Huffman-код libjpeg тоже считает лишь предупреждением.
// Обработанный кусок можно сразу передавать дальше: состояние проверки — несколько чисел и ≤ 13 байт хвоста
// (у JPEG ещё сегмент заголовка, ≤ 64 KiB).
import { finished } from 'node:stream/promises';
import { createInflate, crc32 } from 'node:zlib';
import { tooLarge, unsupported } from '../http/errors.ts';
export type Dimensions = { width: number; height: number };
export type ImageValidator = {
write(chunk: Buffer): Promise<void>;
end(): Promise<Dimensions>; // весь файл получен; бросает 415, если он обрезан
close(): void; // освободить ресурсы при обрыве загрузки
};
const broken = (why: string) => unsupported(`Содержимое не является корректным изображением: ${why}`);
export function imageValidator(type: 'image/png' | 'image/jpeg', maxPixels: number): ImageValidator {
return type === 'image/png' ? png(maxPixels) : jpeg(maxPixels);
}
function checkPixels(width: number, height: number, maxPixels: number): void {
if (width * height > maxPixels) throw tooLarge(`Изображение больше ${maxPixels} пикселей`);
}
const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
const CHANNELS: Record<number, number> = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
const DEPTHS: Record<number, number[]> = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
const ADAM7 = [[0, 0, 8, 8], [4, 0, 8, 8], [0, 4, 4, 8], [2, 0, 4, 4], [0, 2, 2, 4], [1, 0, 2, 2], [0, 1, 1, 2]];
// Строки распакованных данных PNG как [число строк, байт в строке]: байт фильтра + пиксели;
// при interlace — по одной паре на каждый непустой проход Adam7.
function rowLayout(width: number, height: number, bits: number, interlaced: boolean): [number, number][] {
const row = (w: number) => 1 + Math.ceil((w * bits) / 8);
if (!interlaced) return [[height, row(width)]];
const passes: [number, number][] = [];
for (const [x0, y0, dx, dy] of ADAM7) {
const w = Math.ceil((width - x0) / dx);
const h = Math.ceil((height - y0) / dy);
if (w > 0 && h > 0) passes.push([h, row(w)]);
}
return passes;
}
function png(maxPixels: number): ImageValidator {
let carry = Buffer.alloc(0);
let state: 'signature' | 'header' | 'data' | 'crc' | 'done' = 'signature';
let type = '';
let left = 0;
let crc = 0;
let ihdr = Buffer.alloc(0);
let dims: Dimensions | null = null;
let color = 0;
let palette = false;
let idat: 'none' | 'open' | 'closed' = 'none';
let expected = 0;
let inflated = 0;
let rows: [number, number][] = [];
let pass = 0; // текущий проход Adam7 (без interlace — единственный)
let rowsLeft = 0; // строк до конца прохода
let inRow = 0; // позиция внутри текущей строки
let badFilter = false;
const inflate = createInflate();
let zerr: Error | null = null;
let wake: (() => void) | null = null;
inflate.on('data', (d: Buffer) => {
inflated += d.length;
// Первый байт каждой строки — тип фильтра, допустимы только 0–4 (ISO/IEC 15948, 9.2).
for (let i = 0; i < d.length && pass < rows.length;) {
const len = rows[pass][1];
if (inRow === 0 && d[i] > 4) badFilter = true;
const step = Math.min(len - inRow, d.length - i);
i += step;
inRow += step;
if (inRow === len) {
inRow = 0;
if (--rowsLeft === 0 && ++pass < rows.length) rowsLeft = rows[pass][0];
}
}
});
// При ошибке zlib callback write не вызывается: будим ожидающего вручную.
inflate.on('error', (e) => { zerr = e; wake?.(); });
const feed = (data: Buffer) => zerr ? Promise.resolve() : new Promise<void>((resolve) => {
wake = resolve;
inflate.write(data, () => resolve());
});
function startChunk(len: number) {
if (!/^[A-Za-z]{4}$/.test(type) || len > 0x7fffffff) throw broken('неверный заголовок chunk');
if (!dims && type !== 'IHDR') throw broken('первым должен быть IHDR');
if (dims && type === 'IHDR') throw broken('повторный IHDR');
if (type === 'IHDR' && len !== 13) throw broken('неверная длина IHDR');
// Неизвестный критический chunk (заглавная первая буква) декодер обязан отвергнуть.
if (/^[A-Z]/.test(type) && !['IHDR', 'PLTE', 'IDAT', 'IEND'].includes(type)) throw broken(`неизвестный chunk ${type}`);
if (type === 'IDAT') {
if (idat === 'closed') throw broken('IDAT идут не подряд');
if (color === 3 && !palette) throw broken('нет палитры PLTE');
idat = 'open';
} else if (idat === 'open') {
idat = 'closed';
}
if (type === 'PLTE') {
if (palette || !len || len > 256 * 3 || len % 3) throw broken('неверная палитра PLTE');
palette = true;
}
if (type === 'IEND' && (len !== 0 || idat === 'none')) throw broken('неверный IEND');
}
function endChunk() {
if (type === 'IHDR') {
const width = ihdr.readUInt32BE(0);
const height = ihdr.readUInt32BE(4);
const depth = ihdr[8];
color = ihdr[9];
if (!width || !height || width > 0x7fffffff || height > 0x7fffffff) throw broken('неверные размеры');
if (!DEPTHS[color]?.includes(depth) || ihdr[10] !== 0 || ihdr[11] !== 0 || ihdr[12] > 1) throw broken('неверные параметры IHDR');
checkPixels(width, height, maxPixels); // до первого байта IDAT
dims = { width, height };
rows = rowLayout(width, height, CHANNELS[color] * depth, ihdr[12] === 1);
expected = rows.reduce((sum, [h, len]) => sum + h * len, 0);
rowsLeft = rows[0][0];
}
state = type === 'IEND' ? 'done' : 'header';
}
async function write(chunk: Buffer) {
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
let pos = 0;
while (pos < buf.length) {
const avail = buf.length - pos;
if (state === 'signature') {
if (avail < 8) break;
if (!buf.subarray(pos, pos + 8).equals(SIGNATURE)) throw broken('нет сигнатуры PNG');
pos += 8;
state = 'header';
} else if (state === 'header') {
if (avail < 8) break;
left = buf.readUInt32BE(pos);
type = buf.toString('latin1', pos + 4, pos + 8);
startChunk(left);
crc = crc32(buf.subarray(pos + 4, pos + 8));
pos += 8;
state = left ? 'data' : 'crc';
} else if (state === 'data') {
const part = buf.subarray(pos, pos + Math.min(left, avail));
crc = crc32(part, crc);
if (type === 'IHDR') ihdr = Buffer.concat([ihdr, part]);
if (type === 'IDAT') {
await feed(part);
if (zerr) throw broken('повреждён поток zlib');
if (badFilter) throw broken('неверный тип фильтра строки');
if (inflated > expected) throw broken('данных больше, чем пикселей');
}
left -= part.length;
pos += part.length;
if (!left) state = 'crc';
} else if (state === 'crc') {
if (avail < 4) break;
if (buf.readUInt32BE(pos) !== crc) throw broken(`неверная CRC chunk ${type}`);
pos += 4;
endChunk();
} else {
throw broken('данные после IEND');
}
}
carry = Buffer.from(buf.subarray(pos));
}
return {
async write(chunk) {
try {
await write(chunk);
} catch (err) {
inflate.destroy();
throw err;
}
},
async end() {
if (state !== 'done') throw broken('файл обрезан');
inflate.end();
try {
await finished(inflate);
} catch {
throw broken('поток zlib не завершён');
}
if (badFilter) throw broken('неверный тип фильтра строки');
if (inflated !== expected) throw broken('объём данных не совпадает с размерами');
return dims!;
},
close: () => inflate.destroy(),
};
}
// SOF0–SOF15 кроме DHT (C4), JPG (C8), DAC (CC): в них ширина и высота кадра.
const SOF = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
// Принимается то, что декодирует libjpeg-turbo через обычный 8-битный API: baseline, extended, progressive
// с Huffman- или arithmetic-кодированием. Lossless и hierarchical (C3, C5–C7, CB, CD–CF) отвергаются.
const SUPPORTED_SOF = new Set([0xc0, 0xc1, 0xc2, 0xc9, 0xca]);
const DHT = 0xc4;
const SOS = 0xda;
const DQT = 0xdb;
const DRI = 0xdd;
const PARSED = new Set([...SUPPORTED_SOF, DHT, SOS, DQT]);
type Component = { h: number; v: number; tq: number };
function jpeg(maxPixels: number): ImageValidator {
let carry = Buffer.alloc(0);
let state: 'soi' | 'marker' | 'length' | 'payload' | 'scan' | 'done' = 'soi';
let marker = 0;
let left = 0;
let seg = Buffer.alloc(0); // payload разбираемого сегмента (SOF, DHT, DQT, SOS)
let dims: Dimensions | null = null;
let progressive = false;
let arithmetic = false;
let scanned = false;
let scanData = 0; // байт энтропийных данных в текущем скане
const components = new Map<number, Component>();
const quant = new Set<number>(); // номера определённых таблиц DQT
const huff = new Set<number>(); // таблицы DHT: класс << 2 | номер
function frame() {
const [precision, n] = [seg[0], seg[5]];
const height = seg.readUInt16BE(1);
const width = seg.readUInt16BE(3);
if (!width || !height) throw broken('нулевые размеры');
if (precision !== 8) throw broken('поддерживается только 8 бит на канал');
if (![1, 3, 4].includes(n) || seg.length !== 6 + 3 * n) throw broken('неверный SOF');
for (let i = 6; i < seg.length; i += 3) {
const [id, h, v, tq] = [seg[i], seg[i + 1] >> 4, seg[i + 1] & 15, seg[i + 2]];
if (components.has(id) || h < 1 || h > 4 || v < 1 || v > 4 || tq > 3) throw broken('неверные компоненты SOF');
components.set(id, { h, v, tq });
}
// libjpeg восстанавливает цвет только при целом отношении прореживания к максимальному.
const all = [...components.values()];
const [maxH, maxV] = [Math.max(...all.map((c) => c.h)), Math.max(...all.map((c) => c.v))];
if (all.some((c) => maxH % c.h || maxV % c.v)) throw broken('неподдерживаемое прореживание цвета');
checkPixels(width, height, maxPixels); // до энтропийных данных
dims = { width, height };
progressive = marker === 0xc2 || marker === 0xca;
arithmetic = marker >= 0xc9;
}
function quantTables() {
for (let i = 0; i < seg.length;) {
const [pq, tq] = [seg[i] >> 4, seg[i] & 15];
const size = 1 + 64 * (pq + 1);
if (pq > 1 || tq > 3 || i + size > seg.length) throw broken('неверная таблица DQT');
quant.add(tq);
i += size;
}
}
function huffmanTables() {
for (let i = 0; i < seg.length;) {
if (i + 17 > seg.length) throw broken('неверная таблица DHT');
const [tc, th] = [seg[i] >> 4, seg[i] & 15];
let total = 0;
let code = 0;
for (let len = 1; len <= 16; len++) {
total += seg[i + len];
code += seg[i + len];
// Как jpeg_make_d_derived_tbl: коды длины len не должны занять всё пространство (код из одних 1 зарезервирован).
if (code >= 1 << len) throw broken('неверная таблица DHT');
code <<= 1;
}
const symbols = seg.subarray(i + 17, i + 17 + total);
if (tc > 1 || th > 3 || total > 256 || symbols.length !== total) throw broken('неверная таблица DHT');
if (tc === 0 && symbols.some((s) => s > 15)) throw broken('неверная таблица DHT');
huff.add((tc << 2) | th);
i += 17 + total;
}
}
function scan() {
const n = seg[0];
if (n < 1 || n > 4 || seg.length !== 4 + 2 * n) throw broken('неверный SOS');
const [ss, se, ah, al] = [seg[1 + 2 * n], seg[2 + 2 * n], seg[3 + 2 * n] >> 4, seg[3 + 2 * n] & 15];
if (progressive && (ss === 0 ? se !== 0 : ss > se || se > 63 || n !== 1)) throw broken('неверные параметры скана');
if (progressive && ((ah && al !== ah - 1) || al > 13)) throw broken('неверные параметры скана');
const seen = new Set<number>();
let blocks = 0;
for (let i = 1; i < 1 + 2 * n; i += 2) {
const comp = components.get(seg[i]);
if (!comp || seen.has(seg[i])) throw broken('SOS ссылается на неизвестный компонент');
seen.add(seg[i]);
blocks += comp.h * comp.v;
if (!quant.has(comp.tq)) throw broken('нет таблицы квантования DQT');
// Отсутствующие таблицы Хаффмана 0 и 1 libjpeg-turbo заменяет стандартными (Motion JPEG); 2 и 3 — нет.
// У arithmetic-кодирования таблицы условий (DAC) необязательны, проверяется только номер.
const [td, ta] = [seg[i + 1] >> 4, seg[i + 1] & 15];
const missing = (cls: number, t: number) => t > 3 || (!arithmetic && t > 1 && !huff.has((cls << 2) | t));
const needDC = !progressive || (ss === 0 && ah === 0);
const needAC = !progressive || ss > 0;
if ((needDC && missing(0, td)) || (needAC && missing(1, ta))) throw broken('нет таблицы энтропийного кодирования');
}
if (n > 1 && blocks > 10) throw broken('слишком большой MCU');
scanned = true;
scanData = 0;
}
function write(chunk: Buffer) {
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
let pos = 0;
loop: while (pos < buf.length) {
const avail = buf.length - pos;
switch (state) {
case 'soi':
if (avail < 2) break loop;
if (buf[pos] !== 0xff || buf[pos + 1] !== 0xd8) throw broken('нет сигнатуры JPEG');
pos += 2;
state = 'marker';
break;
case 'marker': {
if (avail < 2) break loop;
if (buf[pos] !== 0xff) throw broken('ожидался маркер');
const code = buf[pos + 1];
if (code === 0xff) { // байты-заполнители 0xFF перед маркером
pos += 1;
break;
}
pos += 2;
if (code === 0xd9) {
if (!scanned) throw broken('EOI до данных изображения');
state = 'done';
} else if (code === 0x00 || code === 0xd8 || (code >= 0xd0 && code <= 0xd7)) {
throw broken('неожиданный маркер');
} else if (code !== 0x01) { // TEM не имеет длины
marker = code;
state = 'length';
}
break;
}
case 'length': {
if (avail < 2) break loop;
left = buf.readUInt16BE(pos) - 2;
pos += 2;
if (left < 0) throw broken('неверная длина сегмента');
if (SOF.has(marker) && !SUPPORTED_SOF.has(marker)) throw broken('неподдерживаемый вид JPEG (lossless, hierarchical)');
if (SOF.has(marker) && (dims || left < 6)) throw broken('неверный SOF');
if (marker === SOS && !dims) throw broken('SOS до SOF');
if (marker === DRI && left !== 2) throw broken('неверный DRI');
seg = Buffer.alloc(0);
state = 'payload';
break;
}
case 'payload': {
const n = Math.min(left, avail);
if (PARSED.has(marker)) seg = Buffer.concat([seg, buf.subarray(pos, pos + n)]);
pos += n;
left -= n;
if (left) break;
if (SUPPORTED_SOF.has(marker)) frame();
else if (marker === DQT) quantTables();
else if (marker === DHT) huffmanTables();
else if (marker === SOS) scan();
state = marker === SOS ? 'scan' : 'marker';
break;
}
case 'scan': {
// Внутри энтропийных данных 0xFF допустим только как FF00 (stuffing) и RSTn; иначе начинается маркер.
const ff = buf.indexOf(0xff, pos);
scanData += (ff < 0 ? buf.length : ff) - pos;
if (ff < 0) {
pos = buf.length;
} else if (ff + 1 >= buf.length) {
pos = ff;
break loop;
} else {
const next = buf[ff + 1];
if (next === 0x00) {
pos = ff + 2;
scanData += 1;
} else if (next >= 0xd0 && next <= 0xd7) {
pos = ff + 2;
} else if (next === 0xff) {
pos = ff + 1; // заполнитель перед маркером
} else {
if (!scanData) throw broken('скан без данных');
pos = ff;
state = 'marker';
}
}
break;
}
case 'done': // данные после EOI (MPF, «живые» фото) — нормальная практика камер
pos = buf.length;
break;
}
}
carry = Buffer.from(buf.subarray(pos));
}
return {
write: async (chunk) => write(chunk),
async end() {
if (state !== 'done') throw broken('нет EOI: файл обрезан');
return dims!;
},
close: () => {},
};
}
+104
View File
@@ -0,0 +1,104 @@
// Сообщения: идемпотентная отправка и история чата.
import type { Ctx, Result } from '../http/context.ts';
import { badRequest, conflict, notFound } from '../http/errors.ts';
import { afterCursor, limitOf, page } from '../http/pagination.ts';
import { UUID, isText, jsonObject, readJson } from '../http/request.ts';
import { requireMember } from './chats.ts';
import { authenticate, sha256 } from './sessions.ts';
const IDEMPOTENCY_KEY = /^[A-Za-z0-9._:-]{1,128}$/;
// attachment_ids в порядке, заданном отправителем; text[] драйвер pg возвращает как массив строк.
const attachmentIds = (m: string) =>
`ARRAY(SELECT ma.attachment_id::text FROM message_attachments ma WHERE ma.message_id = ${m}.id ORDER BY ma.position) AS attachment_ids`;
const messageColumns = `id, chat_id, sender_id, text, rfc3339(created_at) AS created_at, ${attachmentIds('messages')}`;
// POST /api/v1/chats/{chat_id}/messages с обязательным Idempotency-Key.
// Область ключа: пользователь + метод + путь чата + ключ.
// Ключ и сообщение вставляются ОДНИМ оператором, поэтому фиксируются атомарно: при ошибке БД нет ни того,
// ни другого, и клиент может безопасно повторить запрос с тем же ключом.
// Одновременный дубль (с любой реплики) ждёт на первичном ключе idempotency_keys, пока первая транзакция
// не зафиксируется, затем получает ON CONFLICT DO NOTHING и отдаёт сохранённый результат.
export async function sendMessage(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const chatId = await requireMember(c, user); // повтор тоже заново проверяет сессию и доступ
const key = c.req.headers['idempotency-key'];
if (typeof key !== 'string' || !IDEMPOTENCY_KEY.test(key)) throw badRequest('Нужен Idempotency-Key [A-Za-z0-9._:-]{1,128}');
// sender_id в теле не принимается: отправитель — из сессии.
const b = jsonObject(await readJson(c.req), ['text', 'attachment_ids']);
const ids = attachmentList(b.attachment_ids);
const text = b.text;
// С вложениями текст может быть пустым; без вложений — 1–4000 символов, не только пробелы.
if (typeof text !== 'string' || [...text].length > 4000 || (!ids.length && !isText(text, 1, 4000))) {
throw badRequest('text: до 4000 символов; пустой текст допустим только с вложениями');
}
if (ids.length) await requireAttachments(c, chatId, ids);
const path = `/api/v1/chats/${chatId}/messages`;
// Каноническое тело: порядок ключей JSON не важен, отсутствующий attachment_ids = [].
// Без вложений hash тот же, что в lab3 (32 байта); с вложениями 64 байта — с текстовым не совпадёт.
const hash = ids.length ? Buffer.concat([sha256(text), sha256(ids.join(','))]) : sha256(text);
let inserted;
try {
inserted = await c.db.query({
name: 'send',
text: `WITH k AS (
INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, message_id)
VALUES ($1, 'POST', $2, $3, $4, gen_random_uuid()) ON CONFLICT DO NOTHING RETURNING message_id),
m AS (INSERT INTO messages (id, chat_id, sender_id, text) SELECT message_id, $5, $1, $6 FROM k
RETURNING id, chat_id, sender_id, text, rfc3339(created_at) AS created_at),
a AS (INSERT INTO message_attachments (message_id, chat_id, attachment_id, position)
SELECT m.id, m.chat_id, t.id, t.ord FROM m, unnest($7::uuid[]) WITH ORDINALITY AS t(id, ord))
SELECT * FROM m`,
values: [user.id, path, key, hash, chatId, text, ids],
});
} catch (err) {
// Составной FK (chat_id, attachment_id): вложение другого чата не прикрепить даже в обход проверки выше.
if ((err as { code?: string }).code === '23503') throw notFound();
throw err;
}
if (inserted.rowCount) return [201, { ...inserted.rows[0], attachment_ids: ids }];
// Ключ уже использован: тот же body → тот же 201 и то же сообщение, другой body → 409.
const stored = await c.db.query(`SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, rfc3339(m.created_at) AS created_at,
${attachmentIds('m')}
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
WHERE k.user_id = $1 AND k.method = 'POST' AND k.path = $2 AND k.key = $3`, [user.id, path, key]);
const { request_hash, ...message } = stored.rows[0];
if (!hash.equals(request_hash)) throw conflict('Idempotency-Key уже использован с другим телом');
return [201, message];
}
// GET /api/v1/chats/{chat_id}/messages: история по возрастанию (created_at, id), limit 1–100.
export async function listMessages(c: Ctx): Promise<Result> {
const user = await authenticate(c);
const chatId = await requireMember(c, user);
const limit = limitOf(c.url);
const [ts, id] = afterCursor(c.url, 'm', chatId);
const r = await c.db.query({
name: 'history',
text: `SELECT ${messageColumns} FROM messages WHERE chat_id = $1 AND (created_at, id) > ($2, $3::uuid)
ORDER BY created_at, id LIMIT $4`,
values: [chatId, ts, id, limit + 1],
});
return [200, page(r.rows, limit, 'm', chatId)];
}
// attachment_ids: 0–10 уникальных UUID (в нижнем регистре), по умолчанию [].
function attachmentList(value: unknown): string[] {
if (value === undefined) return [];
if (!Array.isArray(value) || value.length > 10 || !value.every((id) => typeof id === 'string' && UUID.test(id))) {
throw badRequest('attachment_ids: до 10 UUID');
}
const ids = value.map((id: string) => id.toLowerCase());
if (new Set(ids).size !== ids.length) throw badRequest('attachment_ids должны быть уникальны');
return ids;
}
// Все вложения из этого чата и приняты (queued/processing/ready). Чужое или неизвестное — 404, как и чужой чат;
// failed — 409: прикреплять нечего, но объект виден участнику.
async function requireAttachments(c: Ctx, chatId: string, ids: string[]): Promise<void> {
const r = await c.db.query(`SELECT count(*)::int AS visible, count(*) FILTER (WHERE state = 'failed')::int AS failed
FROM attachments WHERE id = ANY($1::uuid[]) AND chat_id = $2 AND state IN ('queued', 'processing', 'ready', 'failed')`, [ids, chatId]);
if (r.rows[0].visible !== ids.length) throw notFound();
if (r.rows[0].failed) throw conflict('Вложение не обработано (failed), прикрепить нельзя');
}
+8
View File
@@ -0,0 +1,8 @@
// Общая модель пользователя для модулей users и sessions.
export type User = { id: string; username: string; display_name: string; created_at: string };
export const USERNAME = /^[a-z0-9_]{3,32}$/;
// Время форматирует PostgreSQL: Date в JS потерял бы микросекунды, на которых держится cursor.
export const userColumns = 'u.id, u.username, u.display_name, rfc3339(u.created_at) AS created_at';
+29
View File
@@ -0,0 +1,29 @@
// Хеширование паролей: scrypt из node:crypto (N=2^14, r=8, p=1, 16 MiB на хеш).
// Формат хранения: scrypt$N$r$p$соль$хеш (base64), параметры читаются из записи при проверке.
import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
const N = 16384;
const R = 8;
const P = 1;
function scryptKey(password: string, salt: Buffer, n: number, r: number, p: number): Promise<Buffer> {
return new Promise((resolve, reject) =>
scrypt(password, salt, 32, { N: n, r, p, maxmem: 64 << 20 }, (err, key) => (err ? reject(err) : resolve(key))));
}
export async function hashPassword(password: string): Promise<string> {
const salt = randomBytes(16);
const key = await scryptKey(password, salt, N, R, P);
return ['scrypt', N, R, P, salt.toString('base64'), key.toString('base64')].join('$');
}
export async function checkPassword(password: string, encoded: string): Promise<boolean> {
const [alg, n, r, p, salt, hash] = encoded.split('$');
if (alg !== 'scrypt') return false;
const got = await scryptKey(password, Buffer.from(salt, 'base64'), Number(n), Number(r), Number(p));
return timingSafeEqual(got, Buffer.from(hash, 'base64'));
}
// Хеш-пустышка: вход несуществующего пользователя стоит столько же, сколько неверный пароль,
// поэтому по времени ответа нельзя узнать, существует ли username.
export const dummyHash = hashPassword('dummy-password-for-timing');
+62
View File
@@ -0,0 +1,62 @@
// Сессии: вход по Basic, выход, проверка Bearer-токена.
// В БД хранится только sha256(токена): дамп базы не даёт рабочих токенов.
import { createHash, randomBytes } from 'node:crypto';
import type { Ctx, Result } from '../http/context.ts';
import { HttpError, unauthorized } from '../http/errors.ts';
import { isText, requireEmptyBody } from '../http/request.ts';
import { checkPassword, dummyHash } from './passwords.ts';
import { USERNAME, userColumns, type User } from './model.ts';
export const sha256 = (s: string) => createHash('sha256').update(s).digest();
function bearerToken(c: Ctx): string | null {
return /^Bearer +(\S+)$/i.exec(c.req.headers.authorization ?? '')?.[1] ?? null;
}
// Текущий пользователь по Bearer-сессии. Basic и X-User-Id на бизнес-эндпоинтах не аутентифицируют.
// Запрос именованный: pg готовит его один раз на соединение (улучшение из трека 1).
export async function authenticate(c: Ctx): Promise<User> {
const token = bearerToken(c);
if (!token) throw unauthorized();
const r = await c.db.query<User>({
name: 'auth',
text: `SELECT ${userColumns} FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.expires_at > now()`,
values: [sha256(token)],
});
if (!r.rowCount) throw unauthorized();
return r.rows[0];
}
// POST /api/v1/auth/sessions: Basic username:password → новый Bearer-токен.
export async function createSession(c: Ctx): Promise<Result> {
await requireEmptyBody(c.req); // контракт: только заголовок Basic, без JSON-тела
const deny = new HttpError(401, 'unauthorized', 'Неверные учётные данные'); // одинаковый ответ на любую ошибку входа
const m = /^Basic +([A-Za-z0-9+/]+=*)$/i.exec(c.req.headers.authorization ?? '');
if (!m) throw deny;
const decoded = Buffer.from(m[1], 'base64').toString('utf8');
const colon = decoded.indexOf(':'); // в username двоеточия нет, в пароле может быть
const username = decoded.slice(0, colon);
const password = decoded.slice(colon + 1);
if (colon < 0 || !USERNAME.test(username)) throw deny;
const r = await c.db.query<User & { password_hash: string }>(
`SELECT ${userColumns}, u.password_hash FROM users u WHERE u.username = $1`, [username]);
const row = r.rows[0];
const valid = await checkPassword(password, row?.password_hash ?? await dummyHash);
if (!row || !valid || !isText(password, 12, 128)) throw deny;
const token = randomBytes(32).toString('base64url'); // 256 бит энтропии
const s = await c.db.query(
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, now() + make_interval(secs => $3))
RETURNING rfc3339(expires_at) AS expires_at`, [sha256(token), row.id, c.config.sessionTtlSeconds]);
const { password_hash: _, ...user } = row;
return [201, { token, token_type: 'Bearer', expires_at: s.rows[0].expires_at, user }];
}
// DELETE /api/v1/auth/sessions/current: отзыв текущего токена.
export async function deleteSession(c: Ctx): Promise<Result> {
await authenticate(c);
await c.db.query('DELETE FROM sessions WHERE token_hash = $1', [sha256(bearerToken(c)!)]);
return [204];
}
+29
View File
@@ -0,0 +1,29 @@
// Пользователи: регистрация и профиль текущего пользователя.
import type { Ctx, Result } from '../http/context.ts';
import { badRequest, conflict } from '../http/errors.ts';
import { isText, jsonObject, readJson } from '../http/request.ts';
import { hashPassword } from './passwords.ts';
import { USERNAME, userColumns, type User } from './model.ts';
import { authenticate } from './sessions.ts';
// POST /api/v1/users: публичная регистрация. Пароль и его хеш в ответ не попадают.
export async function createUser(c: Ctx): Promise<Result> {
const b = jsonObject(await readJson(c.req), ['username', 'display_name', 'password']);
if (typeof b.username !== 'string' || !USERNAME.test(b.username) || !isText(b.display_name, 1, 100) || !isText(b.password, 12, 128)) {
throw badRequest('Неверные username, display_name или password');
}
try {
const r = await c.db.query<User>(
`INSERT INTO users AS u (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING ${userColumns}`,
[b.username, b.display_name, await hashPassword(b.password)]);
return [201, r.rows[0]];
} catch (err) {
if ((err as { code?: string }).code === '23505') throw conflict('Username уже занят'); // unique_violation
throw err;
}
}
// GET /api/v1/users/me
export async function me(c: Ctx): Promise<Result> {
return [200, await authenticate(c)];
}
+73
View File
@@ -0,0 +1,73 @@
// Наблюдаемость на уровне API OpenTelemetry: tracer, meter, структурный лог, перенос W3C trace context.
// SDK подключает src/telemetry.ts (node --import, только api и worker); без него всё здесь — no-op,
// а лог пишется только в stdout. Модуль не зависит от SDK, поэтому его импортируют и утилиты (migrate, reconcile).
import { setTimeout as sleep } from 'node:timers/promises';
import { context, metrics, propagation, ROOT_CONTEXT, SpanStatusCode, trace, type Attributes, type Context } from '@opentelemetry/api';
import { logs, SeverityNumber } from '@opentelemetry/api-logs';
import { getRPCMetadata, RPCType } from '@opentelemetry/core';
export const tracer = trace.getTracer('messenger');
export const meter = metrics.getMeter('messenger');
const logger = logs.getLogger('messenger');
const service = process.env.OTEL_SERVICE_NAME || 'messenger';
type Level = 'info' | 'warn' | 'error';
const SEVERITY = { info: SeverityNumber.INFO, warn: SeverityNumber.WARN, error: SeverityNumber.ERROR };
// Структурный лог: JSON-строка в stdout/stderr (docker logs) и запись OTLP (Loki) с trace_id/span_id активного span.
// event — стабильный машинный ключ события, message — текст для человека. В attrs только технические поля:
// без паролей, токенов, Authorization, текста сообщений, имён файлов и байтов изображений.
export function log(level: Level, event: string, message: string, attrs: Attributes = {}): void {
const span = trace.getActiveSpan()?.spanContext();
const line = { time: new Date().toISOString(), level, service, event, message, ...attrs, trace_id: span?.traceId, span_id: span?.spanId };
(level === 'info' ? process.stdout : process.stderr).write(JSON.stringify(line) + '\n');
logger.emit({ severityNumber: SEVERITY[level], severityText: level.toUpperCase(), body: message, attributes: { event, ...attrs } });
}
// Дочерний span вокруг шага (захват job, рендер, фиксация): группирует его SQL/S3-spans; ошибка помечает span.
export function inSpan<T>(name: string, attributes: Attributes, fn: () => Promise<T>): Promise<T> {
return tracer.startActiveSpan(name, { attributes }, async (span) => {
try {
return await fn();
} catch (err) {
span.recordException(err as Error);
span.setStatus({ code: SpanStatusCode.ERROR });
throw err;
} finally {
span.end();
}
});
}
export type TraceCarrier = { traceparent: string | null; tracestate: string | null };
// Trace context для переноса через outbox и брокер: поля traceparent/tracestate из contracts/jobs.schema.json.
// tracestate длиннее 512 символов (предел схемы) не переносится.
export function traceCarrier(ctx: Context = context.active()): TraceCarrier {
const c: Record<string, string> = {};
propagation.inject(ctx, c);
return { traceparent: c.traceparent ?? null, tracestate: c.tracestate && c.tracestate.length <= 512 ? c.tracestate : null };
}
// Обратное преобразование; пустой carrier (строки до lab6, сообщение без полей) — корневой контекст, новый trace.
export function contextFrom(carrier: Partial<TraceCarrier>): Context {
return propagation.extract(ROOT_CONTEXT, carrier);
}
// Шаблон маршрута (/api/v1/chats/{chat_id}/messages) для имени server span и метрики http.server.request.duration:
// реальный путь с UUID в label метрики попасть не должен.
export function setRoute(template: string): void {
const rpc = getRPCMetadata(context.active());
if (rpc?.type === RPCType.HTTP) rpc.route = template;
}
let flushHook: () => Promise<void> = async () => {};
export function onFlush(f: () => Promise<void>): void {
flushHook = f;
}
// Перед выходом процесса: отправить накопленные spans, логи и метрики, но не дольше timeoutMs —
// недоступный Collector не должен задерживать остановку.
export async function flushTelemetry(timeoutMs = 3000): Promise<void> {
await Promise.race([flushHook().catch(() => {}), sleep(timeoutMs)]);
}
+260
View File
@@ -0,0 +1,260 @@
// Сверка PostgreSQL ↔ S3: очистка после сбоев загрузки (уровень 4) и исправление расхождений (трек 2).
// node src/main.ts reconcile — dry-run: только отчёт, ничего не меняет
// ... reconcile --apply — выполнить исправления
// --verify дополнительно скачать ready-объекты и сверить SHA-256 (читает все байты bucket)
// --grace=N pending-строки и объекты без строки моложе N секунд не трогаются (RECONCILE_GRACE_SECONDS, 900)
// --retention=N staging failed-вложений хранится N секунд для replay (STAGING_RETENTION_SECONDS, 86400)
// --every=N повторять каждые N секунд (так работает сервис reconciler)
//
// Правила. Строки ready/lost не удаляются никогда, используемые сообщениями дополнительно защищены FK.
// stale_pending pending старше grace: запрос загрузки давно завершён (таймаут API 60 с ≪ grace)
// → удалить строку, затем объект (если упадём между ними — останется orphan_object)
// orphan_object объект без строки старше grace → удалить объект. Строка создаётся раньше объекта,
// ключ случайный, поэтому строка для такого объекта уже не появится
// missing_object ready без объекта (повторно проверено HEAD) → lost: скрыть из API, ссылки сохранить
// size_mismatch ready, размер объекта ≠ size_bytes → lost
// checksum_mismatch ready, SHA-256 объекта ≠ sha256 (только --verify) → lost
// restored lost, объект на месте и SHA-256 совпал → снова ready (карантин обратим)
// Lab5, префиксы staging/ и variants/ (объект нужен, пока на него ссылается БД):
// orphan_staging staging без строки старше grace → удалить
// published_staging staging ready-вложения старше grace (worker не успел удалить после фиксации) → удалить
// expired_staging staging failed-вложения старше STAGING_RETENTION_SECONDS → удалить (replay после этого невозможен)
// orphan_variant объект варианта без строки attachment_variants старше grace (попытка проиграла аренду
// или упала до фиксации; grace ≫ JOB_TIMEOUT_SECONDS) → удалить
//
// Обход: ListObjectsV2 и строки БД, оба отсортированы по ключу побайтово, сливаются как два потока
// (merge join) — память O(страница), запросов O(N / 1000). Конкурентные загрузки: строки, изменённые после
// начала обхода (updated_at ≥ t0), не проверяются; их объекты моложе grace и тоже не трогаются.
import { createHash } from 'node:crypto';
import type { Readable } from 'node:stream';
import { setTimeout as sleep } from 'node:timers/promises';
import type pg from 'pg';
import { s3Config, secret } from './config.ts';
import { createPool } from './db.ts';
import { createStorage, type Storage } from './storage/s3.ts';
const PREFIX = 'originals/';
const PAGE = 1000;
const PRINT_LIMIT = 20; // находки сверх лимита только считаются
type Options = { apply: boolean; verify: boolean; grace: number; retention: number };
type Obj = { key: string; size: number; modified: Date };
type Row = { id: string; object_key: string; state: string; size_bytes: number | null; sha256: string | null; settled: boolean };
export async function reconcileCommand(args: string[], defaultGrace: number, defaultRetention: number): Promise<void> {
const flag = (name: string) => args.find((a) => a.startsWith(`--${name}=`))?.split('=')[1];
const opts: Options = { apply: args.includes('--apply'), verify: args.includes('--verify'), grace: Number(flag('grace') ?? defaultGrace),
retention: Number(flag('retention') ?? defaultRetention) };
const every = Number(flag('every') ?? 0);
if (!Number.isInteger(opts.grace) || opts.grace < 0 || !Number.isInteger(every) || every < 0) throw new Error('--grace/--every: целые секунды');
const db = createPool(secret('DATABASE_URL'), 2);
const s3 = createStorage(s3Config());
process.on('SIGTERM', () => process.exit(0)); // прерванный обход безопасен: каждое действие атомарно
for (;;) {
try {
console.log(JSON.stringify(await reconcile(db, s3, opts)));
} catch (err) {
console.error(`сверка не выполнена: ${(err as Error).message}`);
if (!every) process.exitCode = 1;
}
if (!every) break;
await sleep(every * 1000);
}
await db.end();
}
export async function reconcile(db: pg.Pool, s3: Storage, opts: Options) {
const started = performance.now();
const lock = await db.connect();
try {
// Два reconciler-а одновременно не работают: второй сразу выходит.
if (!(await lock.query('SELECT pg_try_advisory_lock(4004) AS ok')).rows[0].ok) return { skipped: 'другая сверка уже идёт' };
try {
return await run(db, s3, opts, started);
} finally {
await lock.query('SELECT pg_advisory_unlock(4004)');
}
} finally {
lock.release();
}
}
async function run(db: pg.Pool, s3: Storage, { apply, verify, grace, retention }: Options, started: number) {
const stats = { mode: apply ? 'apply' : 'dry-run', verify, grace_seconds: grace, objects: 0, rows: 0, fresh_skipped: 0,
s3_list: 0, s3_head: 0, s3_get_bytes: 0, db_queries: 0, findings: {} as Record<string, number>, applied: 0 };
const t0: Date = (await db.query('SELECT now() AS t0')).rows[0].t0;
stats.db_queries++;
const cutoff = t0.getTime() - grace * 1000;
const found = async (kind: string, detail: Record<string, unknown>, fix: () => Promise<boolean>) => {
const n = stats.findings[kind] = (stats.findings[kind] ?? 0) + 1;
const done = apply && await fix();
if (done) stats.applied++;
if (n <= PRINT_LIMIT) console.log(JSON.stringify({ finding: kind, ...detail, action: apply ? (done ? 'fixed' : 'changed meanwhile, skipped') : 'would fix' }));
};
const setState = async (id: string, from: string, to: string) => {
stats.db_queries++;
return Boolean((await db.query('UPDATE attachments SET state = $3, updated_at = clock_timestamp() WHERE id = $1 AND state = $2',
[id, from, to])).rowCount);
};
const sha256Of = async (key: string) => {
const body = await s3.get(key);
if (!body) return null;
const hash = createHash('sha256');
for await (const chunk of body as Readable) {
hash.update(chunk);
stats.s3_get_bytes += chunk.length;
}
return hash.digest('hex');
};
// 1. Зависшие загрузки. Условие повторяется в DELETE: если строка успела измениться, её не трогаем.
const stale = await db.query(`SELECT id, COALESCE(staging_key, object_key) AS object_key FROM attachments
WHERE state = 'pending' AND created_at < $1::timestamptz - make_interval(secs => $2)`, [t0, grace]);
stats.db_queries++;
for (const r of stale.rows) {
await found('stale_pending', { id: r.id, key: r.object_key }, async () => {
stats.db_queries++;
const d = await db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'
AND created_at < $2::timestamptz - make_interval(secs => $3)`, [r.id, t0, grace]);
if (!d.rowCount) return false;
await s3.remove(r.object_key);
return true;
});
}
// 2. Слияние отсортированных потоков объектов и строк.
const onlyObject = async (o: Obj) => {
if (o.modified.getTime() > cutoff) {
stats.fresh_skipped++;
return;
}
await found('orphan_object', { key: o.key, size: o.size, modified: o.modified }, async () => {
await s3.remove(o.key);
return true;
});
};
const onlyRow = async (r: Row) => {
// pending — этап 1; lost — уже в карантине; не settled — строка изменилась после начала обхода.
if (r.state !== 'ready' || !r.settled) return;
stats.s3_head++;
if (await s3.exists(r.object_key)) return; // объект не попал в листинг, но существует — не трогаем
await found('missing_object', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
};
const both = async (o: Obj, r: Row) => {
// Оригинал до фиксации ready (processing/queued) может уже лежать в originals/: его не проверяем.
if ((r.state !== 'ready' && r.state !== 'lost') || !r.settled) return;
if (o.size !== r.size_bytes) {
if (r.state === 'ready') await found('size_mismatch', { id: r.id, key: r.object_key, expected: r.size_bytes, actual: o.size }, () => setState(r.id, 'ready', 'lost'));
return;
}
if (r.state === 'ready' && !verify) return;
const actual = await sha256Of(o.key);
if (r.state === 'ready' && actual !== r.sha256) {
await found('checksum_mismatch', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
} else if (r.state === 'lost' && actual === r.sha256) {
await found('restored', { id: r.id, key: r.object_key }, () => setState(r.id, 'lost', 'ready'));
}
};
const objs = objects(s3, stats);
const rows = dbRows(db, t0, stats);
let o = (await objs.next()).value;
let r = (await rows.next()).value;
while (o || r) {
if (o && (!r || o.key < r.object_key)) {
stats.objects++;
await onlyObject(o);
o = (await objs.next()).value;
} else if (r && (!o || r.object_key < o.key)) {
stats.rows++;
await onlyRow(r);
r = (await rows.next()).value;
} else {
stats.objects++;
stats.rows++;
await both(o!, r!);
o = (await objs.next()).value;
r = (await rows.next()).value;
}
}
// 3. staging/ и variants/: постраничный поиск ключей в БД.
const remove = (key: string) => async () => {
await s3.remove(key);
return true;
};
for await (const page of pages(s3, 'staging/', stats)) {
const r = await db.query(`SELECT staging_key AS key, state, updated_at < $2::timestamptz - make_interval(secs => $3) AS expired
FROM attachments WHERE staging_key = ANY($1)`, [page.map((o) => o.key), t0, retention]);
stats.db_queries++;
const rows = new Map(r.rows.map((row) => [row.key, row]));
for (const o of page) {
stats.objects++;
const row = rows.get(o.key);
const old = o.modified.getTime() <= cutoff;
if (!row && !old) stats.fresh_skipped++;
else if (!row) await found('orphan_staging', { key: o.key }, remove(o.key));
else if (row.state === 'ready' && old) await found('published_staging', { key: o.key }, remove(o.key));
else if (row.state === 'failed' && row.expired) {
await found('expired_staging', { key: o.key }, async () => {
await s3.remove(o.key);
await db.query(`UPDATE attachments SET staging_key = NULL WHERE staging_key = $1 AND state = 'failed'`, [o.key]);
return true;
});
}
}
}
for await (const page of pages(s3, 'variants/', stats)) {
const r = await db.query('SELECT object_key FROM attachment_variants WHERE object_key = ANY($1)', [page.map((o) => o.key)]);
stats.db_queries++;
const known = new Set(r.rows.map((row) => row.object_key));
for (const o of page) {
stats.objects++;
if (known.has(o.key)) continue;
if (o.modified.getTime() > cutoff) stats.fresh_skipped++;
else await found('orphan_variant', { key: o.key }, remove(o.key));
}
}
return { ...stats, duration_ms: Math.round(performance.now() - started), max_rss_mb: Math.round(process.resourceUsage().maxRSS / 1024) };
}
async function* pages(s3: Storage, prefix: string, stats: { s3_list: number }): AsyncGenerator<Obj[], undefined> {
let token: string | undefined;
do {
const page = await s3.list(prefix, token);
stats.s3_list++;
yield (page.Contents ?? []).map((item) => ({ key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! }));
token = page.IsTruncated ? page.NextContinuationToken : undefined;
} while (token);
return undefined;
}
async function* objects(s3: Storage, stats: { s3_list: number }): AsyncGenerator<Obj, undefined> {
let token: string | undefined;
let last = '';
do {
const page = await s3.list(PREFIX, token);
stats.s3_list++;
for (const item of page.Contents ?? []) {
// Слияние корректно только на отсортированных потоках: иначе остановиться, а не удалить лишнее.
if (item.Key! <= last) throw new Error('S3 вернул ключи не по порядку');
last = item.Key!;
yield { key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! };
}
token = page.IsTruncated ? page.NextContinuationToken : undefined;
} while (token);
return undefined;
}
async function* dbRows(db: pg.Pool, t0: Date, stats: { db_queries: number }): AsyncGenerator<Row, undefined> {
let last = '';
for (;;) {
const r = await db.query<Row>(`SELECT id, object_key, state, size_bytes, sha256, updated_at < $2 AS settled
FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT ${PAGE}`, [last, t0]);
stats.db_queries++;
yield* r.rows;
if (r.rows.length < PAGE) return undefined;
last = r.rows[r.rows.length - 1].object_key;
}
}
+100
View File
@@ -0,0 +1,100 @@
// S3-совместимое хранилище байтов вложений (SeaweedFS). Один приватный bucket, ключи объектов назначает сервер.
// Ошибки переводятся в ответы контракта: недоступность хранилища — 503, ошибка конфигурации/прав — 500.
import {
CopyObjectCommand,
CreateBucketCommand,
DeleteObjectCommand,
GetObjectCommand,
HeadObjectCommand,
ListObjectsV2Command,
PutObjectCommand,
S3Client,
} from '@aws-sdk/client-s3';
import type { Readable } from 'node:stream';
import type { S3Config } from '../config.ts';
import { HttpError, unavailable } from '../http/errors.ts';
import { log } from '../otel.ts';
export type Storage = ReturnType<typeof createStorage>;
export function createStorage(cfg: S3Config) {
const client = new S3Client({
endpoint: cfg.endpoint,
region: cfg.region,
forcePathStyle: true,
credentials: { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey },
// Тело PUT уходит как есть с Content-Length, без aws-chunked/trailer: SHA-256 считает сам API.
requestChecksumCalculation: 'WHEN_REQUIRED',
responseChecksumValidation: 'WHEN_REQUIRED',
// Потоковое тело PUT нельзя отправить повторно; повтор — решение клиента API (он получит 503).
maxAttempts: 1,
// Недоступный S3 — быстрый отказ (1 с); requestTimeout — простой сокета, а не длительность всей загрузки.
// requestTimeout < timeout server HAProxy (10 с): при зависшем S3 ответит API (503), а не LB (504).
requestHandler: { connectionTimeout: 1000, requestTimeout: 8000, throwOnRequestTimeout: true },
});
const Bucket = cfg.bucket;
const send = async <T>(p: Promise<T>): Promise<T> => {
try {
return await p;
} catch (err) {
throw storageError(err);
}
};
return {
bucket: Bucket,
put: (key: string, body: Readable, length: number, type: string, signal: AbortSignal) =>
send(client.send(new PutObjectCommand({ Bucket, Key: key, Body: body, ContentLength: length, ContentType: type }), { abortSignal: signal })),
putBuffer: (key: string, body: Buffer, type: string) =>
send(client.send(new PutObjectCommand({ Bucket, Key: key, Body: body, ContentType: type }))),
// Копия на стороне S3 (байты не идут через процесс): публикация оригинала из staging в конечный prefix.
copy: (from: string, to: string) =>
send(client.send(new CopyObjectCommand({ Bucket, CopySource: `${Bucket}/${from}`, Key: to }))),
// null — объекта нет.
async get(key: string): Promise<Readable | null> {
try {
return (await client.send(new GetObjectCommand({ Bucket, Key: key }))).Body as Readable;
} catch (err) {
if (isMissing(err)) return null;
throw storageError(err);
}
},
async exists(key: string): Promise<boolean> {
try {
await client.send(new HeadObjectCommand({ Bucket, Key: key }));
return true;
} catch (err) {
if (isMissing(err)) return false;
throw storageError(err);
}
},
remove: (key: string) => send(client.send(new DeleteObjectCommand({ Bucket, Key: key }))),
list: (prefix: string, token?: string) =>
send(client.send(new ListObjectsV2Command({ Bucket, Prefix: prefix, ContinuationToken: token, MaxKeys: 1000 }))),
// Идемпотентный bootstrap: существующий bucket этого владельца — не ошибка.
async createBucket(): Promise<'created' | 'exists'> {
try {
await client.send(new CreateBucketCommand({ Bucket }));
return 'created';
} catch (err) {
if ((err as Error).name === 'BucketAlreadyOwnedByYou') return 'exists';
throw err;
}
},
};
}
function isMissing(err: unknown): boolean {
const e = err as { name?: string; $metadata?: { httpStatusCode?: number } };
return e.name === 'NoSuchKey' || e.name === 'NotFound' || e.$metadata?.httpStatusCode === 404;
}
// 4xx от S3 (AccessDenied, неверный bucket) — ошибка конфигурации: 500. Сеть, таймаут, 5xx — 503, клиент может повторить.
function storageError(err: unknown): Error {
if (err instanceof HttpError) return err;
const e = err as { name?: string; message?: string; $metadata?: { httpStatusCode?: number } };
if (e.name === 'AbortError') return err as Error; // загрузку прервал сам API, причину знает вызывающий
log('error', 's3.error', `S3: ${e.name} ${e.message}`, { 'error.type': e.name ?? 'Error' });
const status = e.$metadata?.httpStatusCode ?? 0;
return status >= 400 && status < 500 ? new HttpError(500, 'internal_error', 'Внутренняя ошибка') : unavailable('Хранилище файлов недоступно');
}
+56
View File
@@ -0,0 +1,56 @@
// OpenTelemetry SDK для api и worker: node --import ./src/telemetry.ts src/main.ts [worker].
// Загружается до приложения, чтобы инструментации успели перехватить http, pg и AWS SDK (ESM — через
// import-in-the-middle). Экспорт traces/metrics/logs — OTLP/HTTP в Collector; адрес, протокол, service.name,
// интервалы и OTEL_SDK_DISABLED задаются переменными OTEL_* (compose.yaml). Недоступный Collector не влияет на
// обработку запросов: очереди SDK ограничены (BSP/BLRP 2048 записей), при переполнении данные отбрасываются.
import { readFileSync } from 'node:fs';
import { register } from 'node:module';
import { hostname } from 'node:os';
import { AwsInstrumentation } from '@opentelemetry/instrumentation-aws-sdk';
import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
import { RuntimeNodeInstrumentation } from '@opentelemetry/instrumentation-runtime-node';
import { NodeSDK, resources } from '@opentelemetry/sdk-node';
// OTEL_SDK_DISABLED=true — ни ESM-hook, ни патчей модулей instrumentations: чистая база для сравнения.
if (process.env.OTEL_SDK_DISABLED !== 'true') {
register('@opentelemetry/instrumentation/hook.mjs', import.meta.url);
const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
const sdk = new NodeSDK({
// Только явные атрибуты и OTEL_SERVICE_NAME/OTEL_RESOURCE_ATTRIBUTES: host/process detectors добавили бы
// аргументы командной строки и пр. в каждую запись. service.instance.id = hostname = X-Instance-Id.
resourceDetectors: [resources.envDetector],
resource: resources.resourceFromAttributes({ 'service.version': version, 'service.instance.id': hostname() }),
instrumentations: [
new HttpInstrumentation({
// Health-проверки HAProxy и Docker (каждую секунду) — не бизнес-трафик: без spans и без метрик.
ignoreIncomingRequestHook: (req) => req.url?.startsWith('/health/') ?? false,
// filename (пользовательский текст) и cursor не попадают в url.query server span.
redactedQueryParamsServer: ['filename', 'cursor'],
}),
// requireParentSpan: фоновые опросы outbox/sweeper (каждые 0.5–5 с) не создают отдельных trace.
// enhancedDatabaseReporting выключен: значения параметров SQL (текст сообщений, хеши) не записываются.
new PgInstrumentation({ requireParentSpan: true, enhancedDatabaseReporting: false }),
// Span на операцию S3 (PutObject, GetObject …) вместо дублирующего HTTP-клиентского span.
new AwsInstrumentation({ suppressInternalInstrumentation: true }),
new RuntimeNodeInstrumentation(),
],
});
sdk.start();
// otel.ts загружается только после start(): metrics.getMeter() до регистрации провайдера вернул бы no-op meter.
const { meter, onFlush } = await import('./otel.ts');
onFlush(() => sdk.shutdown());
// CPU и RSS процесса (в контейнере один процесс, поэтому это и нагрузка контейнера).
meter.createObservableCounter('process.cpu.time', { unit: 's', description: 'CPU time of the process' })
.addCallback((r) => {
const { user, system } = process.cpuUsage();
r.observe(user / 1e6, { 'cpu.mode': 'user' });
r.observe(system / 1e6, { 'cpu.mode': 'system' });
});
meter.createObservableGauge('process.memory.usage', { unit: 'By', description: 'Resident set size of the process' })
.addCallback((r) => r.observe(process.memoryUsage.rss()));
}
+220
View File
@@ -0,0 +1,220 @@
#!/usr/bin/env python3
"""Негативные и граничные сценарии вложений (уровень 4) через LB: ни один из них не должен дать 500.
Lab5: принятый файл — 202 queued, байты и варианты доступны после ready (worker).
Изображения генерируются кодом (PNG — zlib/struct), JPEG — синтетический fixtures/sample.jpg (sips из sample.png).
Запуск: python3 student-tests/attachments.py --base-url http://localhost:8080"""
import hashlib
import http.client
import os
from pathlib import Path
import struct
import sys
import time
import urllib.parse
import uuid
import zlib
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, ROOT, arguments, check, run # noqa: E402
MiB = 1024 * 1024
SAMPLE_PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
SAMPLE_JPG = (Path(__file__).parent / 'fixtures/sample.jpg').read_bytes()
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
def png(width, height, raw, depth=8, color=2, level=1):
"""PNG из готовых распакованных строк raw (байт фильтра + пиксели)."""
ihdr = struct.pack('>IIBBBBB', width, height, depth, color, 0, 0, 0)
return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', ihdr) + chunk(b'IDAT', zlib.compress(raw, level)) + chunk(b'IEND', b'')
def noise_png(side):
"""RGB-шум не сжимается: размер файла ≈ side² × 3 байт."""
row = 1 + side * 3
return png(side, side, b''.join(b'\0' + os.urandom(row - 1) for _ in range(side)))
def gray1(width, height):
"""1-битный серый PNG из нулей: 40 Мпикс занимают несколько килобайт файла."""
return png(width, height, bytes(height * (1 + (width + 7) // 8)), depth=1, color=0, level=9)
def jpeg_with_size(data, width, height):
"""Подменить размеры в SOF0 существующего JPEG."""
i = data.index(b'\xff\xc0')
return data[:i + 5] + struct.pack('>HH', height, width) + data[i + 9:]
def jpeg_without(data, marker):
"""Вырезать из JPEG все сегменты с маркером marker, стоящие до SOS."""
out, i = data[:2], 2
while data[i + 1] != 0xda:
size = 2 + struct.unpack('>H', data[i + 2:i + 4])[0]
if data[i + 1] != marker:
out += data[i:i + size]
i += size
return out + data[i:]
def bare_jpeg():
"""27 байт: SOI, SOF0 1x1, SOS, EOI — без таблиц DQT/DHT и без данных скана."""
return (b'\xff\xd8' + b'\xff\xc0' + struct.pack('>HBHHB', 11, 8, 1, 1, 1) + b'\x01\x11\x00'
+ b'\xff\xda' + struct.pack('>HB', 8, 1) + b'\x01\x00\x00\x3f\x00' + b'\xff\xd9')
def main():
args = arguments('Attachment negative suite')
c = Client(args.base_url, args.ca_file, timeout=30)
alice, bob, eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой чат', 'member_ids': [alice['id']]}, schema='Chat')['json']
results = []
def upload(data, expected, ctype='image/png', name='file.png', actor=alice, target=chat, label=None):
path = '/api/v1/chats/' + target['id'] + '/attachments?filename=' + urllib.parse.quote(name, safe='')
r = c.call('POST', path, expected, actor=actor, raw=data, headers={'Content-Type': ctype}, schema='Attachment' if expected == 202 else None)
results.append((label or name, r['status'], (r['json'] or {}).get('error', {}).get('code', ''), round(r['elapsed'] * 1000)))
if expected == 202:
att = r['json']
check(att['sha256'] == hashlib.sha256(data).hexdigest() and att['size_bytes'] == len(data), label + ': checksum/size')
check(att['content_type'] == ctype and att['filename'] == name, label + ': metadata')
check(att['status'] == 'queued' and att['variants'] == [] and att['error_code'] is None, label + ': 202 snapshot')
return att
return r['json']
def download(att, actor=bob, expect=None):
att = c.wait_ready(actor, att, 120)
r = c.call('GET', '/api/v1/attachments/' + att['id'] + '/content', actor=actor)
check(r['bytes'] == expect and hashlib.sha256(r['bytes']).hexdigest() == att['sha256'], 'download differs')
check(r['headers'].get_content_type() == att['content_type'], 'download content type')
check(r['headers'].get('X-Content-Type-Options') == 'nosniff', 'missing nosniff')
check(not r['headers'].get('Location'), 'download must not redirect')
# Принимаются реальные PNG/JPEG, граница по размеру и по пикселям.
jpg = upload(SAMPLE_JPG, 202, 'image/jpeg', 'фото 📷 2026.jpg', label='real JPEG + unicode filename')
download(jpg, expect=SAMPLE_JPG)
big = noise_png(1860)
check(9 * MiB < len(big) <= 10 * MiB, 'big fixture size %d' % len(big))
big_att = upload(big, 202, label='PNG %.2f MiB (noise 1860x1860)' % (len(big) / MiB))
download(big_att, expect=big)
huge = upload(gray1(6400, 6250), 202, label='PNG ровно 40 000 000 px')
huge = c.wait_ready(bob, huge, 120) # worker обрабатывает предельный по пикселям файл в своих лимитах
dims = {v['name']: (v['width'], v['height']) for v in huge['variants']}
check(dims == {'thumbnail': (256, 250), 'crop': (128, 128), 'optimized': (1280, 1250)}, 'variants of 6400x6250: %s' % dims)
# Лимиты: до чтения тела (Content-Length) и по заголовку изображения до распаковки.
upload(noise_png(1900), 413, label='PNG 10.33 MiB > 10 MiB')
upload(os.urandom(10 * MiB + 1), 413, label='10 MiB + 1 байт')
upload(gray1(6400, 6251), 413, label='PNG 40 006 400 px')
bomb = gray1(30000, 30000)
upload(bomb, 413, label='pixel-bomb 30000x30000, файл %d КБ' % (len(bomb) // 1024))
upload(jpeg_with_size(SAMPLE_JPG, 10000, 10000), 413, 'image/jpeg', 'bomb.jpg', label='JPEG SOF 10000x10000')
# IHDR обещает 100x100, а IDAT распаковывается в 64 МБ нулей: распаковка останавливается на лишних данных.
upload(png(100, 100, bytes(64 * MiB), level=9), 415, label='zip-bomb в IDAT (64 МБ при 100x100)')
# Повреждённые файлы и подмена типа.
bad_crc = bytearray(SAMPLE_PNG)
bad_crc[1000] ^= 0xFF
upload(bytes(bad_crc), 415, label='PNG: байт IDAT испорчен (CRC)')
upload(png(320, 200, os.urandom(1000)), 415, label='PNG: корректные CRC, мусор в zlib')
upload(png(320, 200, bytes(100)), 415, label='PNG: данных меньше, чем пикселей')
upload(SAMPLE_PNG[:-200], 415, label='PNG обрезан')
upload(SAMPLE_PNG + b'<html>', 415, label='PNG + данные после IEND')
upload(png(1, 1, b'\x05\0\0\0'), 415, label='PNG 1x1: фильтр строки 5 (допустимы 0–4)')
upload(bare_jpeg(), 415, 'image/jpeg', 'bare.jpg', label='JPEG 27 байт: без DQT/DHT и скана')
upload(jpeg_without(SAMPLE_JPG, 0xdb), 415, 'image/jpeg', 'nodqt.jpg', label='JPEG без таблиц квантования DQT')
upload(SAMPLE_JPG[:-500], 415, 'image/jpeg', 'cut.jpg', label='JPEG обрезан (нет EOI)')
upload(SAMPLE_PNG, 415, 'image/jpeg', 'spoof.jpg', label='PNG под видом image/jpeg')
upload(SAMPLE_JPG, 415, 'image/png', 'spoof.png', label='JPEG под видом image/png')
upload(b'GIF89a' + os.urandom(100), 415, label='GIF под видом image/png')
upload(b'<svg xmlns="http://www.w3.org/2000/svg"/>', 415, label='SVG под видом image/png')
upload(SAMPLE_PNG, 415, 'image/gif', 'x.gif', label='Content-Type image/gif')
upload(SAMPLE_PNG, 415, 'application/octet-stream', 'x.png', label='Content-Type octet-stream')
upload(b'', 415, label='пустое тело')
# Опасные и некорректные filename: 400 до чтения тела.
for name in ['../etc/passwd', 'a/b.png', 'a\\b.png', 'nul\x00.png', 'tab\t.png', 'line\n.png', 'c1\x85.png', '', ' ', 'x' * 256]:
upload(SAMPLE_PNG, 400, name=name, label='filename %r' % name[:20])
r = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments', 400, actor=alice, raw=SAMPLE_PNG, headers={'Content-Type': 'image/png'})
results.append(('без filename', r['status'], r['json']['error']['code'], round(r['elapsed'] * 1000)))
results.append(('chunked без Content-Length',) + chunked_upload(c, alice, chat))
# Доступ: без сессии, посторонний, чужое вложение.
upload(SAMPLE_PNG, 401, actor={'id': '', 'token': 'bad'}, label='без действительной сессии')
upload(SAMPLE_PNG, 404, actor=eve, label='посторонний грузит в чужой чат')
upload(SAMPLE_PNG, 404, target={'id': str(uuid.uuid4())}, label='несуществующий чат')
upload(SAMPLE_PNG, 400, target={'id': 'not-a-uuid'}, label='chat_id не UUID')
own = upload(SAMPLE_PNG, 202, label='обычный PNG')
foreign = upload(SAMPLE_PNG, 202, target=other, label='PNG в другом чате')
for suffix in ('', '/content'):
c.call('GET', '/api/v1/attachments/' + own['id'] + suffix, 404, actor=eve)
c.call('GET', '/api/v1/attachments/' + foreign['id'] + suffix, 404, actor=bob)
c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()) + suffix, 404, actor=bob)
c.call('GET', '/api/v1/attachments/xyz' + suffix, 400, actor=bob)
c.call('GET', '/api/v1/attachments/' + own['id'] + suffix, 401)
content = '/api/v1/attachments/' + own['id'] + '/content'
c.wait_ready(bob, own)
check(c.call('GET', content + '?variant=thumbnail', actor=bob)['headers'].get_content_type() == 'image/jpeg', 'thumbnail type')
check(c.call('GET', content + '?variant=optimized', actor=bob)['headers'].get_content_type() == 'image/webp', 'optimized type')
c.call('GET', content + '?variant=bogus', 400, actor=bob)
check(c.call('GET', content + '?variant=original', actor=bob)['bytes'] == SAMPLE_PNG, 'variant=original')
# Привязка к сообщению: только вложения этого чата, 0–10 уникальных UUID.
send = '/api/v1/chats/' + chat['id'] + '/messages'
def post(body, expected, key=None):
return c.call('POST', send, expected, actor=alice, body=body, headers={'Idempotency-Key': key or uuid.uuid4().hex},
schema='Message' if expected == 201 else None)['json']
post({'text': 'чужое', 'attachment_ids': [foreign['id']]}, 404)
post({'text': 'смесь', 'attachment_ids': [own['id'], foreign['id']]}, 404)
post({'text': 'нет такого', 'attachment_ids': [str(uuid.uuid4())]}, 404)
post({'text': 'дубль', 'attachment_ids': [own['id'], own['id'].upper()]}, 400)
post({'text': 'много', 'attachment_ids': [str(uuid.uuid4()) for _ in range(11)]}, 400)
post({'text': 'не uuid', 'attachment_ids': ['x']}, 400)
post({'text': 'не массив', 'attachment_ids': own['id']}, 400)
post({'text': ' '}, 400)
post({'text': '', 'attachment_ids': []}, 400)
c.call('POST', '/api/v1/chats/' + other['id'] + '/messages', 404, actor=bob, body={'text': 'x', 'attachment_ids': [foreign['id']]},
headers={'Idempotency-Key': uuid.uuid4().hex})
key = uuid.uuid4().hex
m = post({'text': '', 'attachment_ids': [own['id'], jpg['id']]}, 201, key)
check(m['attachment_ids'] == [own['id'], jpg['id']] and m['text'] == '', 'attachment order/text')
check(post({'attachment_ids': [own['id'], jpg['id']], 'text': ''}, 201, key) == m, 'replay with attachments differs')
post({'text': '', 'attachment_ids': [jpg['id'], own['id']]}, 409, key)
post({'text': '', 'attachment_ids': [own['id']]}, 409, key)
key = uuid.uuid4().hex
t = post({'text': 'без вложений'}, 201, key)
check(post({'text': 'без вложений', 'attachment_ids': []}, 201, key) == t and t['attachment_ids'] == [], 'missing attachment_ids != []')
history = c.call('GET', send + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
check([x for x in history if x['id'] == m['id']] == [m], 'history lost attachment_ids')
width = max(len(r[0]) for r in results)
for label, status, code, ms in results:
print('%-*s %d %-24s %5d ms' % (width, label, status, code, ms))
check(all(status < 500 for _, status, _, _ in results), 'server error in negative suite')
print('PASS: %d upload cases, ACL and message linking; no 5xx' % len(results))
def chunked_upload(c, actor, chat):
"""Тело без Content-Length (Transfer-Encoding: chunked): потоковая запись в S3 требует длину — 400."""
url = urllib.parse.urlsplit(c.base)
conn = http.client.HTTPConnection(url.hostname, url.port, timeout=10)
conn.putrequest('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=c.png')
conn.putheader('Authorization', 'Bearer ' + actor['token'])
conn.putheader('Content-Type', 'image/png')
conn.putheader('Transfer-Encoding', 'chunked')
conn.endheaders()
start = time.monotonic()
conn.send(b'%x\r\n%s\r\n0\r\n\r\n' % (len(SAMPLE_PNG), SAMPLE_PNG))
r = conn.getresponse()
body = r.read()
check(r.status == 400 and b'invalid_request' in body, 'chunked upload: %d' % r.status)
return r.status, 'invalid_request', round((time.monotonic() - start) * 1000)
if __name__ == '__main__':
run(main)
+139
View File
@@ -0,0 +1,139 @@
#!/usr/bin/env python3
"""Отказы вокруг S3 и перезапуск всего стенда (уровни 3–4). Управляет Docker Compose этого каталога:
1. S3 остановлен: upload/download → 503 быстро, метаданные и текст работают, readiness = 200;
2. S3 «завис» (docker pause): ответ 503 по таймауту API раньше таймаута LB;
3. после возврата S3 всё работает; неудачные загрузки не оставили строк (lab5: компенсация сначала удаляет строку),
«воскресший» после pause объект staging убирает reconciler (orphan_staging);
4. docker compose down (без -v) + up: метаданные, оригинал и прежний токен сохранены.
Запуск: python3 student-tests/failures.py --base-url http://localhost:8080"""
import hashlib
import json
from pathlib import Path
import subprocess
import sys
import time
import uuid
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, ROOT, arguments, check, run # noqa: E402
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
def compose(*args, capture=False):
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True)
check(r.returncode == 0, 'docker compose %s: %s' % (args[0], r.stderr.strip().splitlines()[-1:]))
return r.stdout if capture else None
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-tAc', query, capture=True).strip()
def reconcile(*flags):
out = compose('run', '--rm', '--no-deps', '-T', 'reconciler', 'node', 'src/main.ts', 'reconcile', *flags, capture=True)
return json.loads(out.strip().splitlines()[-1])
def wait_ready(c, seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if c.call('GET', '/health/ready', [200, 503])['status'] == 200:
return
except AssertionError:
pass
time.sleep(1)
raise AssertionError('stand not ready')
def recover(c, path, actor, seconds=60):
"""Время до первого успешного скачивания после возврата S3."""
start = time.monotonic()
while c.call('GET', path, [200, 503], actor=actor)['status'] != 200:
check(time.monotonic() - start < seconds, 'S3 path did not recover')
time.sleep(0.5)
return time.monotonic() - start
def main():
args = arguments('S3 outage, S3 hang and full stand restart')
c = Client(args.base_url, args.ca_file, timeout=30)
alice, bob, _, chat = c.bootstrap()
up = '/api/v1/chats/' + chat['id'] + '/attachments?filename=outage.png'
send = '/api/v1/chats/' + chat['id'] + '/messages'
hdr = {'Content-Type': 'image/png'}
att = c.call('POST', up, 202, actor=alice, raw=PNG, headers=hdr, schema='Attachment')['json']
att = c.wait_ready(bob, att) # lab5: байты доступны после обработки worker
content = '/api/v1/attachments/' + att['id'] + '/content'
pending_before = int(sql("SELECT count(*) FROM attachments WHERE state = 'pending'"))
log = []
def step(name, r):
log.append('%-52s %d %5d ms' % (name, r['status'], r['elapsed'] * 1000))
# 1. S3 остановлен.
compose('stop', 's3')
try:
step('S3 stopped: /health/ready (S3 не критичен)', c.call('GET', '/health/ready', 200))
for i in range(3):
step('S3 stopped: upload #%d' % (i + 1), c.call('POST', up, 503, actor=alice, raw=PNG, headers=hdr))
step('S3 stopped: download', c.call('GET', content, 503, actor=bob))
step('S3 stopped: metadata (только БД)', c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment'))
step('S3 stopped: text message', c.call('POST', send, 201, actor=alice, body={'text': 'S3 недоступен'},
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
step('S3 stopped: message with ready attachment', c.call('POST', send, 201, actor=alice, body={'text': '', 'attachment_ids': [att['id']]},
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
finally:
compose('start', 's3')
# Компенсация сначала удаляет pending-строку (БД доступна), объектов при остановленном S3 не появилось.
leftover = int(sql("SELECT count(*) FROM attachments WHERE state = 'pending'")) - pending_before
log.append('pending-строк после 3 неудачных загрузок: %d' % leftover)
check(leftover == 0, 'failed uploads left pending rows')
log.append('S3 started: download снова 200 через %.1f s' % recover(c, content, bob))
# 2. S3 завис: TCP-соединения не отвечают.
c.call('GET', content, 200, actor=bob) # прогреть keep-alive соединения API → S3
compose('pause', 's3')
try:
step('S3 paused: download (таймаут сокета S3 8 с)', c.call('GET', content, 503, actor=bob))
step('S3 paused: upload', c.call('POST', up, 503, actor=alice, raw=PNG, headers=hdr))
step('S3 paused: text message', c.call('POST', send, 201, actor=alice, body={'text': 'S3 завис'},
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
finally:
compose('unpause', 's3')
# 3. S3 вернулся.
log.append('S3 unpaused: download снова 200 через %.1f s' % recover(c, content, bob))
r = c.call('POST', up, 202, actor=alice, raw=PNG, headers=hdr, schema='Attachment')
step('S3 back: upload', r)
c.wait_ready(bob, r['json']) # reconcile --grace=0 ниже не должен застать работу в процессе
r = c.call('GET', content, 200, actor=bob)
check(r['bytes'] == PNG, 'original changed')
step('S3 back: download old attachment', r)
# Возможен orphan_staging — PUT, который S3 буферизовал во время pause и выполнил после того, как API сдался
# и компенсационный DELETE уже прошёл (объект «воскрес»). Других расхождений быть не должно.
dry = reconcile('--grace=0')
log.append('reconcile dry-run --grace=0: %s' % json.dumps(dry['findings'], ensure_ascii=False))
check(set(dry['findings']) <= {'orphan_staging'}, 'unexpected findings')
fixed = reconcile('--grace=0', '--apply')
again = reconcile('--grace=0')
log.append('reconcile --apply: applied=%d; повтор: %s' % (fixed['applied'], json.dumps(again['findings'])))
check(not again['findings'], 'reconciler left inconsistencies')
# 4. Полный перезапуск стенда с сохранением volumes: down удаляет контейнеры и сети, не volumes.
compose('down')
compose('up', '-d', '--wait')
wait_ready(c)
r = c.call('GET', content, 200, actor=bob) # прежний токен
check(r['bytes'] == PNG and hashlib.sha256(r['bytes']).hexdigest() == att['sha256'], 'original lost after down/up')
step('down + up -d: download with old token', r)
meta = c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment')['json']
check(meta == att, 'metadata changed after restart')
print('\n'.join(log))
print('PASS: S3 outage/hang degrade only attachments (503), compensation + reconciler clean up, full restart keeps data')
if __name__ == '__main__':
run(main)
Binary file not shown.

After

Width:  |  Height:  |  Size: 10 KiB

+59
View File
@@ -0,0 +1,59 @@
#!/usr/bin/env python3
"""Один Idempotency-Key, N параллельных запросов через LB (то есть через разные реплики).
Половина запросов с телом A, половина с телом B: должно появиться ровно одно сообщение, каждый 201 возвращает его,
другое тело получает 409. Запуск: python3 student-tests/idempotency_race.py --base-url http://localhost:8080"""
from concurrent.futures import ThreadPoolExecutor
import json
from pathlib import Path
import sys
import threading
import uuid
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def main():
args = arguments('Parallel same-key POST race', lambda p: p.add_argument('--parallel', type=int, default=32))
c = Client(args.base_url, args.ca_file)
alice, bob, _, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id'] + '/messages'
key = 'race-' + uuid.uuid4().hex
texts = ['гонка A ' + key, 'гонка B ' + key]
barrier = threading.Barrier(args.parallel)
def send(i):
local = Client(args.base_url, args.ca_file)
barrier.wait()
r = local.call('POST', path, [201, 409], actor=alice, body={'text': texts[i % 2]}, headers={'Idempotency-Key': key}, schema='Message')
return r['status'], r['json'], r['headers']['X-Instance-Id']
with ThreadPoolExecutor(args.parallel) as pool:
results = list(pool.map(send, range(args.parallel)))
created = [body for status, body, _ in results if status == 201]
check(created, 'no request succeeded')
winner = created[0]
check(all(body == winner for body in created), 'replicas returned different messages for one key')
check(all(body['error']['code'] == 'conflict' for status, body, _ in results if status == 409), '409 without conflict code')
statuses = {texts[i % 2]: set() for i in range(2)}
for i, (status, _, _) in enumerate(results):
statuses[texts[i % 2]].add(status)
check(statuses[winner['text']] == {201}, 'winning body must always get 201')
check(statuses[next(t for t in texts if t != winner['text'])] == {409}, 'other body must always get 409')
instances = {inst for _, _, inst in results}
check(len(instances) >= 2, 'race did not reach two replicas')
history = c.call('GET', path + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
stored = [m for m in history if key in m['text']]
check(stored == [winner], 'expected exactly one stored message equal to the replayed one')
# Тот же ключ у другого пользователя независим.
other = c.message(bob, chat, texts[0], key=key)['json']
check(other['id'] != winner['id'] and other['sender_id'] == bob['id'], 'key scope leaked across users')
print(json.dumps({'parallel': args.parallel, 'replicas_hit': len(instances), 'created_201': len(created),
'conflict_409': args.parallel - len(created), 'stored_messages': len(stored)}, ensure_ascii=False))
print('PASS: concurrent same-key POSTs through different replicas created exactly one message')
if __name__ == '__main__':
run(main)
+354
View File
@@ -0,0 +1,354 @@
#!/usr/bin/env python3
"""Уровень 4 и трек 2: автоматический fault-injection pipeline вложений и проверка инвариантов.
На время теста api и worker пересоздаются с FAILPOINTS=1 и JOB_TIMEOUT_SECONDS=10 (аренда 25 с), в конце —
снова с конфигурацией из .env. Отказы настоящие: аварийный выход процесса в точке (src/failpoints.ts), пауза процесса,
дубли и перестановка сообщений через outbox, остановка S3 и брокера, устаревшая job после новой версии pipeline.
Инварианты (проверяются в конце по всем вложениям тестового чата):
I1 нет потерянной работы: каждое вложение, для которого записано задание, в конечном состоянии ready/failed;
I2 один результат: у пары (вложение, версия) ровно 3 варианта, лишние объекты попыток убирает reconciler;
I3 новый результат не перезаписан старым: версия только растёт, варианты v2 не меняются после старых job;
I4 повтор даёт тот же результат: sha256 вариантов после сбоев = sha256 контрольной обработки тех же байтов;
I5 API согласован: каждый вариант и оригинал скачиваются, размер и sha256 совпадают с метаданными;
I6 все job в конечном состоянии (done/failed/superseded), reconciler после очистки ничего не находит.
Запуск: python3 student-tests/pipeline_faults.py --base-url http://localhost:8080"""
import hashlib
import http.client
import json
import os
import struct
import subprocess
import time
import urllib.parse
import uuid
import zlib
from failures import PNG, ROOT, sql, wait_ready
from client import Client, arguments, check, run
TEST_ENV = {'FAILPOINTS': '1', 'JOB_TIMEOUT_SECONDS': '10'} # аренда = таймаут + 15 с
LEASE = 25
def compose(*args, env=None):
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True, env={**os.environ, **(env or {})})
check(r.returncode == 0, 'docker compose %s: %s' % (args[0], r.stderr.strip().splitlines()[-1:]))
return r.stdout
def jobs(*args):
out = compose('exec', '-T', 'api', 'node', 'src/main.ts', 'jobs', *args)
return [json.loads(line) for line in out.splitlines() if line.startswith('{')]
def reconcile(*flags):
"""Находки reconciler (по одной JSON-строке) и итоговая сводка."""
out = compose('run', '--rm', '--no-deps', '-T', 'reconciler', 'node', 'src/main.ts', 'reconcile', *flags)
lines = [json.loads(line) for line in out.splitlines() if line.startswith('{')]
return [x for x in lines if 'finding' in x], lines[-1]
def rows(query):
out = sql(query)
return [line.split('|') for line in out.splitlines()] if out else []
def wait_for(what, fn, seconds):
deadline = time.monotonic() + seconds
while True:
value = fn()
if value:
return value
check(time.monotonic() < deadline, 'timeout: ' + what)
time.sleep(1)
def healthy(service):
"""Все реплики сервиса healthy (после crash Docker перезапускает контейнер)."""
out = compose('ps', '-a', service, '--format', '{{.State}} {{.Health}}').split('\n')
return all(line == 'running healthy' for line in out if line)
def bad_filter_png():
"""Структура PNG верна (CRC, объём данных), но байт фильтра строк 9 не существует: API принимает, libvips — нет."""
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
raw = b''.join(b'\x09' + bytes(64 * 3) for _ in range(64))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 64, 64, 8, 2, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(raw)) + chunk(b'IEND', b''))
def main():
args = arguments('Pipeline fault injection with invariant checks')
c = Client(args.base_url, args.ca_file, timeout=30)
since = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
compose('up', '-d', '--no-deps', 'api', 'worker', env=TEST_ENV)
wait_for('api healthy with FAILPOINTS=1', lambda: healthy('api'), 90)
for service in ('api', 'worker'):
ids = compose('ps', '-q', service).split()
check(len(ids) == 2 and all(subprocess.run(['docker', 'exec', i, 'printenv', 'FAILPOINTS'], capture_output=True, text=True)
.stdout.strip() == '1' for i in ids), '%s replicas without FAILPOINTS=1' % service)
wait_ready(c)
alice, bob, _, chat = c.bootstrap()
report = []
def record(name, text):
report.append('%-44s %s' % (name, text))
print(report[-1], flush=True)
def upload(name, data=PNG):
path = '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], urllib.parse.quote(name))
return c.call('POST', path, 202, actor=alice, raw=data, headers={'Content-Type': 'image/png'}, schema='Attachment')['json']['id']
def raw_upload(name):
"""Upload, при котором API может погибнуть посреди запроса: статус без проверок клиента (0 — обрыв)."""
url = urllib.parse.urlsplit(c.base)
conn = http.client.HTTPConnection(url.hostname, url.port, timeout=30)
try:
conn.request('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), body=PNG,
headers={'Authorization': 'Bearer ' + alice['token'], 'Content-Type': 'image/png'})
return conn.getresponse().status
except OSError:
return 0
finally:
conn.close()
def find(name):
return sql("SELECT id FROM attachments WHERE chat_id = '%s' AND filename = '%s'" % (chat['id'], name))
def state(aid):
return rows("SELECT state, coalesce(pipeline_version, 0), coalesce(error_code, '') FROM attachments WHERE id = '%s'" % aid)[0]
def job(aid, version=1):
r = rows("SELECT job_id, state, attempts, coalesce(error_code, '') FROM jobs WHERE attachment_id = '%s' AND pipeline_version = %d"
% (aid, version))
return r[0] if r else None
def variants(aid, version):
return {name: sha for name, sha in rows("SELECT name, sha256 FROM attachment_variants WHERE attachment_id = '%s' "
"AND pipeline_version = %d" % (aid, version))}
def settle(aid, seconds=90, version=1):
"""Дождаться конечного состояния вложения и его job нужной версии."""
return wait_for('attachment %s final' % aid, lambda: state(aid)[0] in ('ready', 'failed')
and (job(aid, version) or ['', ''])[1] in ('done', 'failed', 'superseded') and state(aid), seconds)
def deliveries(job_id):
log = compose('logs', '--no-log-prefix', '--since', since, 'worker')
return [line for line in log.splitlines() if job_id in line]
try:
# S0. Контроль: эталонные sha256 вариантов v1 для тех же байтов.
control = upload('control.png')
settle(control)
ref = variants(control, 1)
check(len(ref) == 3, 'control variants')
record('S0 контроль', 'ready v1, варианты %s' % ', '.join(sorted(ref)))
# S1. API падает после записи staging, до транзакции задания: 202 не было — работы не обещано.
status = raw_upload('failpoint-api_after_staging.png')
s1 = find('failpoint-api_after_staging.png')
check(status != 202 and state(s1)[0] == 'pending' and job(s1) is None, 'S1: %s %s' % (status, state(s1)))
wait_for('api restarted', lambda: healthy('api'), 90)
record('S1 API: crash после staging', 'клиент получил %d; строка pending, заданий нет → stale_pending для reconciler' % status)
# S2. API падает после COMMIT задания+outbox, до publish и ответа: публикует relay другой реплики.
status = raw_upload('failpoint-api_after_commit.png')
s2 = find('failpoint-api_after_commit.png')
st = settle(s2)
j = job(s2)
check(status != 202 and st[0] == 'ready' and j[1:3] == ['done', '1'], 'S2: %s %s %s' % (status, st, j))
wait_for('api restarted', lambda: healthy('api'), 90)
record('S2 API: crash после COMMIT, до publish', 'клиент %d; задание из outbox опубликовано → ready, попыток 1' % status)
# S3. Relay падает после publisher confirm, до отметки published_at: строку публикует снова — дубль.
status = raw_upload('failpoint-relay_after_publish.png')
s3 = find('failpoint-relay_after_publish.png')
st = settle(s3)
j = job(s3)
seen = wait_for('duplicate delivered', lambda: len(deliveries(j[0])) >= 2 and deliveries(j[0]), 20)
check(st[0] == 'ready' and j[1:3] == ['done', '1'] and len(seen) >= 2 and len(variants(s3, 1)) == 3, 'S3: %s %s %s' % (st, j, seen))
wait_for('api restarted', lambda: healthy('api'), 90)
record('S3 relay: crash после confirm', 'клиент %d; доставок worker: %d (дубль), обработка 1, вариантов 3' % (status, len(seen)))
# S4. Тройная доставка одной попытки одновременно двум worker.
compose('stop', 'worker')
s4 = upload('duplicate.png')
j4 = job(s4)[0]
sql("INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1), ('%s', 1)" % (j4, j4))
wait_for('duplicates published', lambda: sql("SELECT count(*) FROM outbox WHERE job_id = '%s' AND published_at IS NOT NULL" % j4) == '3', 20)
compose('start', 'worker')
st = settle(s4)
seen = wait_for('all copies delivered', lambda: len(deliveries(j4)) >= 3 and deliveries(j4), 20)
noop = [line for line in seen if 'no-op' in line]
check(st[0] == 'ready' and job(s4)[2] == '1' and len(seen) == 3 and len(noop) == 2 and variants(s4, 1) == ref, 'S4: %s' % seen)
record('S4 дубль: 3 копии попытки 1', '3 доставки → 1 обработка, 2 no-op; попыток 1, варианты = контрольным')
# S5. Reorder в новой версии: сообщение попытки 2 опубликовано раньше попытки 1 (job v2 для ready v1).
j5 = str(uuid.uuid4())
sql("INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES ('%s', '%s', 2); "
"INSERT INTO outbox (job_id, attempt) VALUES ('%s', 2), ('%s', 1)" % (j5, s4, j5, j5))
st = settle(s4, version=2)
v2 = variants(s4, 2)
seen = wait_for('attempt 2 no-op', lambda: any('попытка 2: no-op' in line for line in deliveries(j5)) and deliveries(j5), 20)
check(st[:2] == ['ready', '2'] and job(s4, 2)[1:3] == ['done', '1'] and len(v2) == 3 and v2['thumbnail'] != ref['thumbnail']
and any('попытка 2: no-op' in line for line in seen), 'S5: %s %s' % (st, seen))
record('S5 reorder: попытка 2 раньше 1 (job v2)', 'попытка 2 → no-op, попытка 1 → done; версия 1 → 2, вариантов v2: 3')
# S6. Устаревшая job v1 после публикации v2: поздний дубль старого сообщения и повторно поставленная v1.
j1 = job(s4)[0]
before = len(deliveries(j1))
sql("INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1)" % j1)
wait_for('late duplicate handled', lambda: len(deliveries(j1)) > before, 20)
sql("UPDATE jobs SET state = 'queued' WHERE job_id = '%s'; "
"INSERT INTO outbox (job_id, attempt) SELECT job_id, attempts + 1 FROM jobs WHERE job_id = '%s'" % (j1, j1))
wait_for('stale v1 superseded', lambda: job(s4)[1] == 'superseded', 30)
check(state(s4)[:2] == ['ready', '2'] and variants(s4, 2) == v2, 'S6: v2 changed')
record('S6 устаревшая v1 после v2 (захват)', 'дубль старого сообщения → no-op; повторно поставленная v1 → superseded; v2 не тронута')
# S7. v1 фиксируется после v2: v1 «зависла» 10 с после записи объектов, тем временем v2 опубликована.
name = 'failpoint-worker_after_side_effect-10s.png'
s7 = upload(name)
wait_for('v1 stalled after side effects', lambda: sql("SELECT count(*) FROM failpoint_hits WHERE attachment_id = '%s'" % s7) == '1', 30)
j7 = str(uuid.uuid4())
sql("INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES ('%s', '%s', 2); "
"INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1)" % (j7, s7, j7))
wait_for('v2 done', lambda: (job(s7, 2) or ['', ''])[1] == 'done', 30)
v2_7 = variants(s7, 2)
wait_for('v1 superseded at commit', lambda: job(s7)[1] == 'superseded', 30)
check(state(s7)[:2] == ['ready', '2'] and variants(s7, 1) == {} and variants(s7, 2) == v2_7, 'S7: %s' % state(s7))
record('S7 v1 фиксируется после v2 (фиксация)', 'v2 ready; v1 при фиксации → superseded, вариантов v1 в БД 0, объекты удалены')
# S8–S10. Worker crash до side effect, после side effect, после COMMIT (до ack).
crashed = {}
for label, point, attempts in (('S8 worker: crash после захвата', 'worker_after_claim', '2'),
('S9 worker: crash после записи S3', 'worker_after_side_effect', '2'),
('S10 worker: crash после COMMIT до ack', 'worker_after_commit', '1')):
started = time.monotonic()
aid = crashed[point] = upload('failpoint-%s.png' % point)
st = settle(aid, LEASE * 3)
j = job(aid)
check(st[0] == 'ready' and j[1:3] == ['done', attempts] and variants(aid, 1) == ref, '%s: %s %s' % (point, st, j))
wait_for('worker restarted', lambda: set(compose('ps', '-a', 'worker', '--format', '{{.State}}').split()) == {'running'}, 30)
how = 'redelivery → no-op (аренда жива), аренда истекла → попытка 2' if attempts == '2' else 'redelivery → no-op (job done)'
record(label, '%s; ready за %.0f с, попыток %s, варианты = контрольным' % (how, time.monotonic() - started, attempts))
# S11. Зависший worker: пауза 35 с > аренды 25 с. Работу забирает другая попытка, поздний результат отброшен.
started = time.monotonic()
s11 = upload('failpoint-worker_after_side_effect-35s.png')
st = settle(s11, 90)
j = job(s11)
ready_after = time.monotonic() - started
wait_for('stale attempt fenced', lambda: any('аренда потеряна' in line for line in deliveries(j[0])), 60)
check(st[0] == 'ready' and j[1:3] == ['done', '2'] and variants(s11, 1) == ref, 'S11: %s %s' % (st, j))
record('S11 worker завис на 35 с (аренда 25 с)', 'попытка 2 → ready за %.0f с; попытка 1 проснулась → fencing: результат отброшен' % ready_after)
# S12. S3 недоступен для worker: backoff с jitter → retry_exhausted → реестр failed → replay.
compose('stop', 'worker')
s12 = upload('transient.png')
compose('stop', 's3')
try:
compose('up', '-d', '--no-deps', 'worker', env=TEST_ENV) # start поднял бы и S3 по цепочке depends_on
st = wait_for('retry exhausted', lambda: state(s12)[0] == 'failed' and state(s12), 120)
j = job(s12)
delays = rows("SELECT attempt, round(extract(epoch FROM available_at - created_at)::numeric, 1) FROM outbox "
"WHERE job_id = '%s' AND attempt > 1 ORDER BY attempt" % j[0])
registry = [r for r in jobs('failed') if r.get('attachment_id') == s12]
meta = c.call('GET', '/api/v1/attachments/' + s12, 200, actor=bob, schema='Attachment')['json']
c.call('GET', '/api/v1/attachments/' + s12 + '/content', 409, actor=bob)
c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, body={'text': '', 'attachment_ids': [s12]},
headers={'Idempotency-Key': uuid.uuid4().hex})
check(st[2] == 'retry_exhausted' and j[1:3] == ['failed', '5'] and len(registry) == 1
and meta['status'] == 'failed' and meta['error_code'] == 'retry_exhausted', 'S12: %s %s' % (st, j))
finally:
compose('start', 's3')
wait_for('s3 healthy', lambda: healthy('s3'), 60)
replay = jobs('replay', s12)[-1]
st = settle(s12)
audit = rows("SELECT previous_error, previous_attempts FROM job_replays WHERE job_id = '%s'" % j[0])
again = jobs('replay', s12)[-1]
check(replay['replayed'] and st[0] == 'ready' and audit == [['retry_exhausted', '5']] and not again['replayed']
and variants(s12, 1) == ref, 'S12 replay: %s %s %s' % (replay, st, again))
record('S12 S3 недоступен → retry_exhausted', 'задержки попыток 2–5: %s с; failed в реестре, API: failed/409'
% ', '.join(d for _, d in delays))
record(' replay', 'аудит (retry_exhausted, 5) → ready; повторный replay: %s' % again['reason'])
# S13. Постоянная ошибка: файл проходит приём, но не декодируется — failed сразу, без повторов.
s13 = upload('bad-filter.png', bad_filter_png())
st = wait_for('permanent failure', lambda: state(s13)[0] == 'failed' and state(s13), 60)
check(st[2] == 'invalid_image' and job(s13)[1:3] == ['failed', '1'], 'S13: %s' % st)
record('S13 постоянная ошибка (фильтр PNG = 9)', 'failed invalid_image с первой попытки, без повторов')
# S14. Брокер остановлен: API принимает файлы (202), задания ждут в outbox; брокер вернулся — ready.
compose('stop', 'rabbitmq')
try:
s14 = [upload('broker-down-%d.png' % i) for i in range(3)]
c.call('GET', '/health/ready', 200) # readiness API не зависит от брокера
unpublished = sql("SELECT count(*) FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE o.published_at IS NULL "
"AND j.attachment_id IN ('%s')" % "', '".join(s14))
check(unpublished == '3', 'S14: unpublished %s' % unpublished)
finally:
compose('start', 'rabbitmq')
started = time.monotonic()
for aid in s14:
check(settle(aid, 180)[0] == 'ready' and variants(aid, 1) == ref, 'S14: %s' % aid)
record('S14 брокер остановлен', '3 upload → 202, неопубликовано в outbox 3; брокер вернулся → все ready за %.0f с'
% (time.monotonic() - started))
# Инварианты по всем вложениям тестового чата.
print('\nИнварианты:')
atts = rows("SELECT id, state, coalesce(pipeline_version, 0), filename FROM attachments WHERE chat_id = '%s'" % chat['id'])
open_work = [a for a in atts if a[1] not in ('ready', 'failed') and a[0] != s1]
check(not open_work, 'I1: %s' % open_work)
print(' I1 нет потерянной работы: %d вложений с заданием, все ready/failed; S1 (без 202) — pending до reconciler' % (len(atts) - 1))
counts = rows("SELECT v.attachment_id, v.pipeline_version, count(*) FROM attachment_variants v JOIN attachments a ON a.id = v.attachment_id "
"WHERE a.chat_id = '%s' GROUP BY 1, 2" % chat['id'])
check(all(n == '3' for _, _, n in counts), 'I2: %s' % counts)
ready = [a for a in atts if a[1] == 'ready']
check(all(any(aid == a[0] and ver == a[2] for aid, ver, _ in counts) for a in ready), 'I2: ready without variants')
print(' I2 один результат: %d наборов (вложение, версия), в каждом ровно 3 варианта' % len(counts))
check(state(s4)[:2] == ['ready', '2'] and variants(s4, 2) == v2 and state(s7)[:2] == ['ready', '2'] and variants(s7, 2) == v2_7, 'I3')
print(' I3 v2 не перезаписана: S5–S7 остались v2, sha256 вариантов v2 не изменились после старых job')
same = [a for a in ready if a[2] == '1']
check(all(variants(a[0], 1) == ref for a in same) and variants(s4, 1) == ref, 'I4')
print(' I4 тот же результат: у %d ready v1 после сбоев sha256 вариантов = контрольным' % len(same))
downloads = 0
for a in ready:
meta = c.call('GET', '/api/v1/attachments/' + a[0], 200, actor=bob, schema='Attachment')['json']
check(c.call('GET', '/api/v1/attachments/' + a[0] + '/content', 200, actor=bob)['bytes'] == PNG, 'I5 original')
for v in meta['variants']:
body = c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (a[0], v['name']), 200, actor=bob)['bytes']
check(len(body) == v['size_bytes'] and hashlib.sha256(body).hexdigest() == v['sha256'], 'I5 %s' % v['name'])
downloads += 1
print(' I5 API согласован: %d оригиналов и %d вариантов скачаны, размер и sha256 = метаданным' % (len(ready), downloads))
states = dict((s, n) for s, n in rows("SELECT j.state, count(*) FROM jobs j JOIN attachments a ON a.id = j.attachment_id "
"WHERE a.chat_id = '%s' GROUP BY 1" % chat['id']))
check(set(states) <= {'done', 'failed', 'superseded'}, 'I6 jobs: %s' % states)
# Остатки ожидаются ровно от трёх сценариев; находки по чужим вложениям (прерванные прошлые прогоны) не считаем.
found, summary = reconcile('--grace=0')
ids = {a[0] for a in atts}
mine = {}
for f in found:
owner = f.get('id') or f['key'].split('/')[1]
if owner in ids:
mine.setdefault(f['finding'], set()).add(owner)
check(mine == {'stale_pending': {s1}, 'orphan_variant': {crashed['worker_after_side_effect']},
'published_staging': {crashed['worker_after_commit']}}, 'I6 reconcile: %s' % mine)
n_variants = sum(1 for f in found if f['finding'] == 'orphan_variant' and f['key'].split('/')[1] in ids)
fixed = reconcile('--grace=0', '--apply')[1]
after = reconcile('--grace=0')[1]['findings']
check(not after and n_variants == 3, 'I6 after cleanup: %s, orphan variants %d' % (after, n_variants))
print(' I6 job: %s; reconciler: stale_pending S1, orphan_variant ×%d попытки 1 в S9, published_staging S10 — и только они;'
' применено %d (всего на стенде %s), повторный обход: {}' % (json.dumps(states), n_variants, fixed['applied'],
json.dumps(summary['findings'])))
finally:
compose('start', 's3', 'worker')
compose('up', '-d', '--no-deps', 'api', 'worker') # FAILPOINTS и таймаут — снова из .env
wait_for('api healthy', lambda: healthy('api'), 90)
print('\n'.join(['', 'Сводка:'] + report))
print('PASS: 14 fault scenarios, invariants I1–I6 hold (at-least-once delivery + idempotent effect, not exactly-once)')
if __name__ == '__main__':
run(main)
+79
View File
@@ -0,0 +1,79 @@
#!/usr/bin/env python3
"""Трек 2, versioned pipeline: выкатка pipeline v2 без потери работы и без перезаписи.
1. Новые загрузки сразу получают v2: api пересоздаётся с PIPELINE_VERSION=2 (worker уже поддерживает v1 и v2).
2. Старые ready-вложения: `jobs reprocess --version=2`; повтор команды ничего не ставит (ключ attachment_id + версия).
3. Пока идёт переобработка, вложение остаётся ready и отдаёт прежние варианты: в processing не откатывается.
4. Итог: у всех ready версия 2; для одинаковых байтов v2 детерминирована (sha256 совпадает с новой загрузкой);
у каждой пары (вложение, версия) ровно 3 варианта, варианты v1 остаются историей и не отдаются.
В конце api возвращается к PIPELINE_VERSION из .env. Запуск: python3 student-tests/reprocess_v2.py --base-url http://localhost:8080"""
import hashlib
import time
from failures import PNG, sql
from pipeline_faults import compose, healthy, jobs, rows, wait_for
from client import Client, arguments, check, run
def main():
args = arguments('Pipeline v1 -> v2 rollout and reprocess')
c = Client(args.base_url, args.ca_file, timeout=30)
alice, bob, _, chat = c.bootstrap()
def upload(name):
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), 202, actor=alice, raw=PNG,
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
return c.wait_ready(bob, att)
def thumbnail(att):
return hashlib.sha256(c.call('GET', '/api/v1/attachments/%s/content?variant=thumbnail' % att['id'], 200, actor=bob)['bytes']).hexdigest()
def version(att):
return sql("SELECT pipeline_version FROM attachments WHERE id = '%s'" % att['id'])
def by_version():
return ', '.join('v%s: %s' % tuple(r) for r in rows("SELECT pipeline_version, count(*) FROM attachments WHERE state = 'ready' GROUP BY 1 ORDER BY 1"))
old = upload('before-v2.png')
old_thumb = thumbnail(old)
check(version(old) == '1', 'expected v1 before rollout')
print('до выкатки: ready по версиям — %s; вложение %s v1' % (by_version(), old['id']))
try:
compose('up', '-d', '--no-deps', 'api', env={'PIPELINE_VERSION': '2'})
wait_for('api healthy with PIPELINE_VERSION=2', lambda: healthy('api'), 90)
new = upload('after-v2.png')
check(version(new) == '2' and thumbnail(new) != old_thumb, 'new upload is not v2')
print('api с PIPELINE_VERSION=2: новая загрузка %s сразу v2 (thumbnail отличается от v1)' % new['id'])
started = time.monotonic()
first = jobs('reprocess', '--version=2')[-1]
states = set()
while True:
states.add(c.call('GET', '/api/v1/attachments/' + old['id'], 200, actor=bob, schema='Attachment')['json']['status'])
thumbnail(old) # во время переобработки вариант доступен
if not int(sql("SELECT count(*) FROM jobs WHERE pipeline_version = 2 AND state IN ('queued', 'processing')")):
break
check(time.monotonic() - started < 600, 'reprocess did not finish')
time.sleep(0.5)
elapsed = time.monotonic() - started
second = jobs('reprocess', '--version=2')[-1]
check(states == {'ready'}, 'attachment left ready during reprocess: %s' % states)
check(second['enqueued'] == 0, 'second reprocess enqueued %s' % second)
print('reprocess --version=2: поставлено %d, все done за %.1f с (%.1f вложений/с); статус во время: %s; повтор: поставлено %d'
% (first['enqueued'], elapsed, first['enqueued'] / max(elapsed, 0.001), ', '.join(sorted(states)), second['enqueued']))
left = rows("SELECT id FROM attachments WHERE state = 'ready' AND pipeline_version < 2")
check(not left, 'ready attachments still below v2: %d' % len(left))
bad = rows("SELECT attachment_id, pipeline_version, count(*) FROM attachment_variants GROUP BY 1, 2 HAVING count(*) <> 3")
check(not bad, 'variant sets with count != 3: %s' % bad)
failed = rows("SELECT state, count(*) FROM jobs WHERE pipeline_version = 2 GROUP BY 1")
check(version(old) == '2' and thumbnail(old) == thumbnail(new) != old_thumb, 'reprocessed result differs from fresh v2')
print('итог: ready по версиям — %s; jobs v2: %s; у всех пар (вложение, версия) по 3 варианта;'
% (by_version(), ', '.join('%s %s' % tuple(r) for r in failed)))
print(' %s после reprocess отдаёт v2, thumbnail побайтно равен свежей загрузке v2 (детерминизм pipeline)' % old['id'])
finally:
compose('up', '-d', '--no-deps', 'api')
wait_for('api healthy', lambda: healthy('api'), 90)
print('PASS: v2 rollout — new uploads v2, reprocess idempotent, no rollback of ready, deterministic result')
if __name__ == '__main__':
run(main)
+31
View File
@@ -0,0 +1,31 @@
// Проба прав S3 изнутри контейнера сервиса (его же ключами из /run/secrets).
// Запуск: docker compose exec -T api node --input-type=module - <key> < student-tests/s3_probe.mjs
// Печатает по строке «операция: результат»; ключи и секреты не выводятся.
import { readFileSync } from 'node:fs';
import { CreateBucketCommand, GetObjectCommand, ListObjectsV2Command, PutObjectCommand, DeleteObjectCommand, S3Client } from '@aws-sdk/client-s3';
const key = process.argv[2];
const bucket = process.env.S3_BUCKET;
const s3 = new S3Client({
endpoint: process.env.S3_ENDPOINT, region: process.env.S3_REGION, forcePathStyle: true, maxAttempts: 1,
credentials: {
accessKeyId: readFileSync('/run/secrets/s3_access_key_id', 'utf8').trim(),
secretAccessKey: readFileSync('/run/secrets/s3_secret_access_key', 'utf8').trim(),
},
});
const probe = async (name, command) => {
try {
await s3.send(command);
console.log(`${name}: allowed`);
} catch (err) {
console.log(`${name}: denied (${err.$metadata?.httpStatusCode} ${err.name})`);
}
};
const scratch = `probe/${Date.now()}`;
await probe('GetObject own bucket', new GetObjectCommand({ Bucket: bucket, Key: key }));
await probe('ListObjectsV2 own bucket', new ListObjectsV2Command({ Bucket: bucket, MaxKeys: 1 }));
await probe('CreateBucket other', new CreateBucketCommand({ Bucket: `probe-${Date.now()}` }));
await probe('PutObject other bucket', new PutObjectCommand({ Bucket: 'other-bucket', Key: 'x', Body: 'x' }));
await probe('PutObject own bucket', new PutObjectCommand({ Bucket: bucket, Key: scratch, Body: 'x' }));
await probe('DeleteObject own bucket', new DeleteObjectCommand({ Bucket: bucket, Key: scratch }));
s3.destroy(); // keep-alive сокеты иначе держат процесс до idle-таймаута S3
+265
View File
@@ -0,0 +1,265 @@
#!/usr/bin/env python3
"""Сигналы наблюдаемости lab6 (уровни 3–4) на запущенном стенде; данные читаются через API Grafana (datasource proxy).
1. Контролируемый запрос с заданным traceparent: server span в Tempo (шаблон маршрута, X-Request-Id,
service.instance.id = X-Instance-Id, дочерние SQL-spans) и access-лог в Loki с тем же trace_id/span_id.
2. Ошибка 404: request_id из тела ошибки находит лог, а лог — trace.
3. Upload → один trace: SERVER (api) → PRODUCER publish → CONSUMER process (worker) → S3 и SQL; лог worker в trace.
4. Retry: S3 «зависает» (docker compose pause) на первую попытку → в том же trace две публикации и две обработки,
первая с ошибкой, вторая — ready. Шаг управляет Docker Compose этого каталога: только учебный стенд.
5. Метрики сигналов есть в Prometheus; в labels нет id пользователей/чатов/сообщений/вложений, request_id и сырых URL.
6. В spans и логах нет пароля, session token, текста сообщения и имени файла.
7. Dashboard загружен provisioning-ом из репозитория, его запросы к Prometheus/Loki/Tempo находят данные.
Запуск: python3 student-tests/telemetry_check.py --base-url http://localhost:8096 --grafana http://localhost:3096"""
import base64
import json
from pathlib import Path
import re
import secrets
import subprocess
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
import uuid
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import SPEC, Client, ROOT, arguments, check, run # noqa: E402
UUID_RE = re.compile(r'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', re.I)
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
def hexid(b64): # Tempo отдаёт OTLP JSON: id spans в base64, в логах и traceparent — hex
return base64.b64decode(b64).hex()
class Grafana:
def __init__(self, base):
password = (ROOT / 'secrets/grafana_admin_password').read_text().strip() # не печатается
self.base = base.rstrip('/')
self.auth = 'Basic ' + base64.b64encode(f'admin:{password}'.encode()).decode()
def get(self, path, **params):
url = self.base + path + ('?' + urllib.parse.urlencode(params) if params else '')
req = urllib.request.Request(url, headers={'Authorization': self.auth, 'Accept': 'application/json'})
try:
with urllib.request.urlopen(req, timeout=15) as r:
return r.read().decode()
except urllib.error.HTTPError as e:
if e.code == 404:
return ''
raise
def trace(self, trace_id):
raw = self.get(f'/api/datasources/proxy/uid/tempo/api/traces/{trace_id}')
spans = []
for batch in json.loads(raw).get('batches', []) if raw else []:
res = {a['key']: next(iter(a['value'].values()), None) for a in batch['resource']['attributes']}
for scope in batch.get('scopeSpans', []):
for s in scope['spans']:
attrs = {a['key']: next(iter(a['value'].values()), None) for a in s.get('attributes', [])}
spans.append({'name': s['name'], 'kind': s.get('kind', '').replace('SPAN_KIND_', ''), 'id': hexid(s['spanId']),
'parent': hexid(s.get('parentSpanId', '')), 'status': s.get('status', {}).get('code', ''),
'start': int(s['startTimeUnixNano']), 'end': int(s['endTimeUnixNano']), 'attrs': attrs, 'resource': res})
return raw, spans
def logs(self, query, minutes=30):
raw = self.get('/api/datasources/proxy/uid/loki/loki/api/v1/query_range', query=query, limit=200,
start=str(int((time.time() - minutes * 60) * 1e9)), direction='forward')
rows = [{**stream['stream'], 'line': line} for stream in json.loads(raw)['data']['result'] for _, line in stream['values']]
return raw, rows
def prom(self, path, **params):
return json.loads(self.get('/api/datasources/proxy/uid/prometheus/api/v1/' + path, **params))['data']
def until(what, fn, ready=bool, seconds=45):
deadline = time.monotonic() + seconds
while True:
value = fn()
if ready(value):
return value
check(time.monotonic() < deadline, f'{what}: не дождались за {seconds} с')
time.sleep(1)
def has(kind, outcome=None):
return lambda x: any(s['kind'] == kind and (outcome is None or s['attrs'].get('messenger.job.outcome') == outcome) for s in x[1])
def traceparent():
tid, sid = secrets.token_hex(16), secrets.token_hex(8)
return tid, sid, f'00-{tid}-{sid}-01'
def compose(*args):
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True)
check(r.returncode == 0, f'docker compose {args[0]}: {r.stderr.strip()[-200:]}')
return r.stdout.strip()
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-tAc', query)
def main():
args = arguments('Сигналы наблюдаемости lab6', lambda p: p.add_argument('--grafana', default='http://localhost:3000'))
c, g = Client(args.base_url), Grafana(args.grafana)
raw_dump = [] # всё, что прочитано из Tempo/Loki, — для проверки отсутствия секретов (шаг 6)
alice, bob, eve, chat = c.bootstrap()
text = 'секретный текст ' + uuid.uuid4().hex
# 1. Контролируемый запрос: клиент сам задаёт trace_id, API продолжает этот trace.
tid, client_span, tp = traceparent()
r = c.call('POST', f'/api/v1/chats/{chat["id"]}/messages', 201, actor=alice, body={'text': text},
headers={'Idempotency-Key': uuid.uuid4().hex, 'traceparent': tp}, schema='Message')
rid, instance = r['headers']['X-Request-Id'], r['headers']['X-Instance-Id']
raw, spans = until('trace сообщения в Tempo', lambda: g.trace(tid), has('SERVER'))
raw_dump.append(raw)
server = [s for s in spans if s['kind'] == 'SERVER']
check(len(server) == 1, 'ожидался один server span')
srv = server[0]
check(srv['name'] == 'POST /api/v1/chats/{chat_id}/messages', f'имя span: {srv["name"]}')
check(srv['parent'] == client_span, 'server span не продолжает traceparent клиента')
check(srv['attrs'].get('http.route') == '/api/v1/chats/{chat_id}/messages', 'нет http.route')
check(srv['attrs'].get('messenger.request_id') == rid, 'request_id span ≠ X-Request-Id')
check(srv['resource'].get('service.name') == 'messenger-api', 'service.name')
check(srv['resource'].get('service.instance.id') == instance, 'service.instance.id ≠ X-Instance-Id')
check(srv['resource'].get('deployment.environment.name') == 'lab', 'deployment.environment.name')
check(srv['resource'].get('service.version'), 'service.version')
db_spans = [s for s in spans if s['parent'] == srv['id'] and s['name'].startswith('pg.query')]
check(db_spans, 'нет дочерних SQL-spans')
raw, logs = until('access-лог в Loki', lambda: g.logs(f'{{service_name="messenger-api"}} | trace_id="{tid}" | event="http.request"'),
lambda x: x[1])
raw_dump.append(raw)
log = logs[0]
check(log['request_id'] == rid and log['span_id'] == srv['id'], 'лог не связан с server span')
check(log['severity_text'] == 'INFO' and log['service_name'] == 'messenger-api', 'severity/service.name лога')
print(f'PASS 1 trace {tid}: server span {srv["name"]} ({len(db_spans)} SQL), лог request_id={rid}')
# 2. Ошибка клиента: по request_id из тела ответа находится лог, по trace_id лога — trace.
err = c.call('GET', f'/api/v1/chats/{chat["id"]}', 404, actor=eve)['json']['error']
raw, logs = until('лог ошибки по request_id', lambda: g.logs(f'{{service_name="messenger-api"}} | request_id="{err["request_id"]}"'),
lambda x: x[1])
raw_dump.append(raw)
err_tid = logs[0]['trace_id']
raw, spans = until('trace ошибки', lambda: g.trace(err_tid), has('SERVER'))
raw_dump.append(raw)
check(any(s['kind'] == 'SERVER' and s['attrs'].get('http.response.status_code') == '404' for s in spans), 'trace 404')
print(f'PASS 2 404 request_id={err["request_id"]} → лог → trace {err_tid}')
# 3. Upload → обработка worker-ом в одном trace.
filename = f'тайное-имя-{uuid.uuid4().hex[:8]}.png'
tid, client_span, tp = traceparent()
att = c.call('POST', f'/api/v1/chats/{chat["id"]}/attachments?filename={urllib.parse.quote(filename)}', 202, actor=alice,
raw=PNG, headers={'Content-Type': 'image/png', 'traceparent': tp}, schema='Attachment')['json']
c.wait_ready(alice, att)
raw, spans = until('trace upload → worker', lambda: g.trace(tid), has('CONSUMER', 'done'))
raw_dump.append(raw)
by_id = {s['id']: s for s in spans}
srv = next(s for s in spans if s['kind'] == 'SERVER')
prod = [s for s in spans if s['kind'] == 'PRODUCER']
cons = [s for s in spans if s['kind'] == 'CONSUMER']
check(len(prod) == 1 and prod[0]['parent'] == srv['id'], 'PRODUCER span не дочерний к upload')
check(len(cons) == 1 and cons[0]['parent'] == prod[0]['id'], 'CONSUMER span не дочерний к PRODUCER')
check(prod[0]['resource']['service.name'] == 'messenger-api' and cons[0]['resource']['service.name'] == 'messenger-worker', 'сервисы')
under = {s['name'] for s in spans if s['parent'] == cons[0]['id']}
check({'claim job', 'S3.GetObject', 'render variants', 'S3.PutObject', 'S3.CopyObject', 'commit result', 'S3.DeleteObject'} <= under,
f'шаги worker: {sorted(under)}')
check(any(by_id.get(s['parent'], {}).get('name') == 'commit result' and s['name'].startswith('pg.query') for s in spans),
'нет SQL фиксации результата')
raw, logs = until('лог worker в trace', lambda: g.logs(f'{{service_name="messenger-worker"}} | trace_id="{tid}" | event="job.ready"'),
lambda x: x[1])
raw_dump.append(raw)
check(logs[0]['span_id'] == cons[0]['id'], 'лог job.ready не связан с CONSUMER span')
print(f'PASS 3 trace {tid}: upload → publish → process ({len(spans)} spans), лог job.ready в том же trace')
# 4. Retry: первая попытка упирается в «зависший» S3 (requestTimeout 8 с), вторая после backoff — успешна.
# S3 размораживается сразу после первой ошибки: вторая попытка (backoff 1–2 с) застанет его рабочим.
compose('stop', 'worker')
tid, client_span, tp = traceparent()
try:
att = c.call('POST', f'/api/v1/chats/{chat["id"]}/attachments?filename=retry.png', 202, actor=alice,
raw=PNG, headers={'Content-Type': 'image/png', 'traceparent': tp}, schema='Attachment')['json']
compose('pause', 's3')
compose('up', '-d', '--no-deps', 'worker') # start ждал бы healthy у замороженного s3
until('первая попытка завершилась ошибкой',
lambda: sql(f"SELECT 1 FROM jobs WHERE attachment_id = '{att['id']}' AND error_code IS NOT NULL"), seconds=60)
finally:
compose('unpause', 's3')
compose('up', '-d', '--no-deps', 'worker')
c.wait_ready(alice, att, wait_seconds=60)
raw, spans = until('trace с повтором', lambda: g.trace(tid), has('CONSUMER', 'done'))
raw_dump.append(raw)
prod = sorted((s for s in spans if s['kind'] == 'PRODUCER'), key=lambda s: s['start'])
cons = sorted((s for s in spans if s['kind'] == 'CONSUMER'), key=lambda s: s['start'])
check(len(prod) == 2 and len(cons) == 2, f'ожидались 2 публикации и 2 обработки: {len(prod)}/{len(cons)}')
check(cons[0]['parent'] == prod[0]['id'] and prod[1]['parent'] == cons[0]['id'] and cons[1]['parent'] == prod[1]['id'],
'цепочка publish → process → publish → process нарушена')
check(cons[0]['status'] == 'STATUS_CODE_ERROR' and cons[0]['attrs'].get('messenger.job.outcome') == 'retry', 'первая попытка не retry')
check(cons[1]['attrs'].get('messenger.job.attempt') == '2', 'вторая попытка не attempt 2')
raw, logs = until('логи retry', lambda: g.logs(f'{{service_name="messenger-worker"}} | trace_id="{tid}"'),
lambda x: {'job.retry', 'job.ready'} <= {l['event'] for l in x[1]})
raw_dump.append(raw)
print(f'PASS 4 trace {tid}: publish#1 → process#1 (retry, S3 timeout) → publish#2 → process#2 (ready)')
# 5. Метрики контракта есть, labels — низкой кардинальности.
required = ['http_server_request_duration_seconds_bucket', 'messenger_job_duration_seconds_bucket',
'messenger_attachment_time_to_ready_seconds_bucket', 'messenger_jobs_backlog', 'messenger_jobs_oldest_age_seconds',
'messenger_outbox_pending', 'rabbitmq_detailed_queue_messages_ready', 'db_client_connection_count',
'db_client_connection_pending_requests', 'messenger_worker_busy', 'messenger_worker_capacity',
'process_cpu_time_seconds_total', 'process_memory_usage_bytes', 'nodejs_eventloop_delay_p99_seconds']
names = set(g.prom('label/__name__/values'))
missing = [m for m in required if m not in names]
check(not missing, f'нет метрик: {missing}')
# Labels метрик приложения (у otelcol_* есть url_path — постоянный путь экспортёра, не запрос пользователя).
forbidden = {'user_id', 'chat_id', 'message_id', 'attachment_id', 'request_id', 'url', 'url_path', 'url_full', 'url_query',
'filename', 'text', 'messenger_request_id', 'messenger_job_id', 'messenger_attachment_id'}
app_labels = set(g.prom('labels', **{'match[]': '{job=~"messenger-.+"}'}))
check(not app_labels & forbidden, f'запрещённые labels: {app_labels & forbidden}')
# Значения живых серий (instant query): label values API отдаёт и устаревшие серии всего head-блока TSDB.
labels = set(g.prom('labels'))
for label in labels - {'__name__'}:
values = [r['metric'].get(label, '') for r in g.prom('query', query=f'group by ({label}) ({{{label}!=""}})')['result']]
check(not any(UUID_RE.search(v) for v in values), f'UUID в значениях label {label}')
routes = set(g.prom('label/http_route/values'))
check(routes and routes <= set(SPEC['paths']), f'http_route не из шаблонов OpenAPI: {sorted(routes - set(SPEC["paths"]))}')
print(f'PASS 5 метрики: {len(required)} обязательных есть; {len(labels)} labels без id/URL; {len(routes)} шаблонов http_route')
# 6. Секреты и содержимое не экспортируются (поиск и в прочитанных trace/логах, и по всему Loki за 30 минут).
blob = '\n'.join(raw_dump)
for name, value in (('пароль', alice['registration']['password']), ('session token', alice['token']),
('текст сообщения', text), ('имя файла', filename), ('имя файла (urlencoded)', urllib.parse.quote(filename))):
check(value not in blob, f'{name} попал в telemetry')
check(not g.logs(f'{{service_name=~"messenger-.+"}} |= `{value}`')[1], f'{name} найден в Loki')
check('Bearer ' not in blob and 'Basic ' not in blob, 'заголовок Authorization попал в telemetry')
print(f'PASS 6 секреты/контент не найдены в {len(raw_dump)} ответах Tempo/Loki и во всём Loki за 30 мин')
# 7. Dashboard из репозитория загружен provisioning-ом, его запросы находят данные за последние 15 минут
# (пустыми допустимы только панели ошибок экспорта и alerts — в норме этих серий нет).
dash = json.loads(g.get('/api/dashboards/uid/messenger-lab6'))
check(dash['meta'].get('provisioned') and dash['meta'].get('folderTitle') == 'Messenger', 'dashboard не из provisioning')
targets = [(p['title'], p['datasource']['uid'], t) for p in dash['dashboard']['panels'] for t in p.get('targets', [])]
now, empty = int(time.time()), []
for title, ds, t in targets:
if ds == 'prometheus':
q = t['expr'].replace('$__rate_interval', '1m')
found = g.prom('query_range', query=q, start=now - 900, end=now, step=30)['result']
elif ds == 'loki':
found = g.logs(t['expr'], minutes=15)[1]
else:
found = json.loads(g.get('/api/datasources/proxy/uid/tempo/api/search', q=t['query'], start=now - 900, end=now))['traces']
if not found:
empty.append(title)
allowed = re.compile(r'потер|отказ|alert', re.I)
check(all(allowed.search(t) for t in empty), f'панели без данных: {empty}')
print(f'PASS 7 dashboard «{dash["dashboard"]["title"]}»: {len(dash["dashboard"]["panels"])} панелей, '
f'{len(targets) - len(empty)}/{len(targets)} запросов с данными (пусто: {sorted(set(empty))})')
print('PASS: сигналы lab6 (traces, logs, metrics, связь через очередь, retry, отсутствие секретов, dashboard)')
if __name__ == '__main__':
run(main)
+35
View File
@@ -0,0 +1,35 @@
#!/usr/bin/env python3
"""Сохранность истории telemetry после перезапуска хранилищ (scripts/restart.sh): trace, логи этого trace и метрики,
записанные ДО перезапуска, читаются ПОСЛЕ него. Запуск: telemetry_history.py --grafana URL --trace-id ID --before UNIX_TS"""
import json
from pathlib import Path
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parent))
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
from client import check, run # noqa: E402
from telemetry_check import Grafana # noqa: E402
def main():
import argparse
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--grafana', default='http://localhost:3000')
p.add_argument('--trace-id', required=True)
p.add_argument('--before', type=int, required=True, help='unix-время до перезапуска')
a = p.parse_args()
g = Grafana(a.grafana)
_, spans = g.trace(a.trace_id)
check(spans, 'trace до перезапуска не найден в Tempo')
_, logs = g.logs(f'{{service_name=~"messenger-.+"}} | trace_id="{a.trace_id}"', minutes=int((time.time() - a.before) / 60) + 60)
check(logs, 'логи trace до перезапуска не найдены в Loki')
series = g.prom('query_range', query='sum(http_server_request_duration_seconds_count{job="messenger-api"})',
start=a.before - 600, end=a.before, step=60)['result']
check(series and len(series[0]['values']) >= 5, 'нет метрик API за 10 минут до перезапуска')
print(f'PASS история после перезапуска: trace {a.trace_id} ({len(spans)} spans), {len(logs)} строк лога, '
f'{len(series[0]["values"])} точек метрики API за 10 мин до перезапуска')
if __name__ == '__main__':
run(main)
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Уровень 3, сценарий защиты 2–3: worker остановлен → upload 202 → сообщение с вложением → content 409, другие
сообщения работают → перезапуск API и брокера с сохранением volumes → worker запущен → то же вложение ready,
thumbnail скачивается. Печатает порядок действий, ID и состояние очереди (без токенов).
Управляет Docker Compose этого каталога. Запуск: python3 student-tests/worker_outage.py --base-url http://localhost:8080"""
import hashlib
import time
import uuid
from failures import PNG, compose, sql, wait_ready
from client import Client, arguments, check, run
from image_probe import jpeg_size
def queue():
"""Глубина quorum-очереди: (сообщений всего, без ack, consumers); None — брокер ещё не готов."""
try:
out = compose('exec', '-T', 'rabbitmq', 'rabbitmqctl', '-q', 'list_queues', '-p', 'messenger',
'name', 'messages', 'messages_unacknowledged', 'consumers', capture=True)
except AssertionError:
return None
for line in out.splitlines():
f = line.split()
if f and f[0] == 'attachments.process':
return tuple(map(int, f[1:4]))
return None
def main():
args = arguments('Worker outage: accepted job survives API and broker restart')
c = Client(args.base_url, args.ca_file, timeout=30)
alice, bob, _, chat = c.bootstrap()
t0 = time.monotonic()
def step(text):
print('%6.1f s %s' % (time.monotonic() - t0, text))
compose('stop', 'worker')
step('docker compose stop worker')
try:
att = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=outage.png', 202, actor=alice, raw=PNG,
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
check(att['status'] == 'queued' and att['variants'] == [], 'upload snapshot is not queued')
step('upload → 202 queued, attachment %s' % att['id'])
m = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, schema='Message',
body={'text': 'файл ещё в очереди', 'attachment_ids': [att['id']]}, headers={'Idempotency-Key': uuid.uuid4().hex})['json']
step('сообщение с queued-вложением → 201, message %s' % m['id'])
content = '/api/v1/attachments/' + att['id'] + '/content'
for variant in ('', '?variant=thumbnail'):
check(c.call('GET', content + variant, 409, actor=bob)['json']['error']['code'] == 'conflict', 'content must be 409')
step('content и content?variant=thumbnail → 409 conflict')
c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=bob, body={'text': 'обычное сообщение'},
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message')
c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=10', 200, actor=bob, schema='MessagePage')
step('другие сообщения без worker: POST 201, история 200')
deadline = time.monotonic() + 10
while sql("SELECT count(*) FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE j.attachment_id = '%s' "
"AND o.published_at IS NOT NULL" % att['id']) != '1':
check(time.monotonic() < deadline, 'outbox row was not published')
time.sleep(0.3)
job = sql("SELECT job_id || ' ' || state || ' attempts=' || attempts FROM jobs WHERE attachment_id = '%s'" % att['id'])
step('job %s; outbox опубликован (publisher confirm); очередь (messages, unacked, consumers) = %s' % (job, queue()))
compose('restart', 'api')
step('docker compose restart api (обе реплики, SIGTERM)')
compose('restart', 'rabbitmq')
deadline = time.monotonic() + 90
while (q := queue()) is None:
check(time.monotonic() < deadline, 'broker did not come back')
time.sleep(1)
wait_ready(c)
step('docker compose restart rabbitmq; после рестарта очередь = %s' % (q,))
check(q[0] >= 1, 'accepted job disappeared from the durable queue')
same = c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment')['json']
check(same['status'] == 'queued', 'attachment state lost after restart')
step('вложение после рестартов: %s (прежний токен)' % same['status'])
finally:
compose('start', 'worker')
started = time.monotonic()
step('docker compose start worker')
ready = c.wait_ready(bob, att, 90)
step('ready через %.1f s после старта worker; job: %s' % (time.monotonic() - started,
sql("SELECT state || ' attempts=' || attempts FROM jobs WHERE attachment_id = '%s'" % att['id'])))
thumb = [v for v in ready['variants'] if v['name'] == 'thumbnail']
check(len(thumb) == 1, 'expected exactly one thumbnail')
r = c.call('GET', content + '?variant=thumbnail', 200, actor=bob)
check(r['headers'].get_content_type() == 'image/jpeg' and jpeg_size(r['bytes']) == (256, 160), 'thumbnail is not 256x160 JPEG')
check(hashlib.sha256(r['bytes']).hexdigest() == thumb[0]['sha256'], 'thumbnail checksum mismatch')
original = c.call('GET', content, 200, actor=bob)['bytes']
check(original == PNG and hashlib.sha256(original).hexdigest() == ready['sha256'], 'original changed')
step('thumbnail 256x160 JPEG (sha256 = метаданным), оригинал совпадает побайтно; варианты: %s'
% ', '.join('%s %dx%d' % (v['name'], v['width'], v['height']) for v in ready['variants']))
print('PASS: job accepted while worker was down survived API + broker restart and reached ready')
if __name__ == '__main__':
run(main)
+15
View File
@@ -0,0 +1,15 @@
{
"compilerOptions": {
"target": "esnext",
"module": "nodenext",
"moduleResolution": "nodenext",
"noEmit": true,
"strict": true,
"allowImportingTsExtensions": true,
"erasableSyntaxOnly": true,
"verbatimModuleSyntax": true,
"skipLibCheck": true,
"types": ["node"]
},
"include": ["src"]
}