ЛР 6 - БПИ2303 - Морару - на 5 #6
@@ -18,3 +18,6 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
research
|
||||
student-tests
|
||||
tests
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
@@ -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 }
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -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 мин до перезапуска
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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}
|
||||
@@ -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
@@ -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}]
|
||||
```
|
||||
@@ -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 |
@@ -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 |
@@ -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])))
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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"
|
||||
@@ -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"
|
||||
@@ -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: []
|
||||
@@ -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
|
||||
@@ -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 станет нулевым.
|
||||
@@ -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
|
||||
Generated
+2638
File diff suppressed because it is too large
Load Diff
@@ -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"
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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' };
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
Executable
+51
@@ -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
|
||||
Executable
+79
@@ -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)"
|
||||
Executable
+10
@@ -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
|
||||
Executable
+12
@@ -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
|
||||
Executable
+14
@@ -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
@@ -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 };
|
||||
}
|
||||
@@ -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(),
|
||||
};
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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) пишется синхронно
|
||||
}
|
||||
@@ -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>;
|
||||
@@ -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', 'Внутренняя ошибка');
|
||||
}
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -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] },
|
||||
});
|
||||
@@ -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),
|
||||
};
|
||||
}
|
||||
@@ -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'),
|
||||
};
|
||||
}
|
||||
@@ -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
@@ -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();
|
||||
}
|
||||
@@ -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"') $$;
|
||||
@@ -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);
|
||||
@@ -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)
|
||||
);
|
||||
@@ -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;
|
||||
@@ -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' }];
|
||||
}
|
||||
@@ -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]];
|
||||
}
|
||||
@@ -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: () => {},
|
||||
};
|
||||
}
|
||||
@@ -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), прикрепить нельзя');
|
||||
}
|
||||
@@ -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';
|
||||
@@ -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');
|
||||
@@ -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];
|
||||
}
|
||||
@@ -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
@@ -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)]);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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('Хранилище файлов недоступно');
|
||||
}
|
||||
@@ -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()));
|
||||
}
|
||||
@@ -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)
|
||||
@@ -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 |
Executable
+59
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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"]
|
||||
}
|
||||
Reference in New Issue
Block a user