docs(REPORT): stash squish lab6 write report

This commit is contained in:
Голиков Maximillian Антон
2026-11-21 12:35:12 +03:00
parent 1d591d77d0
commit e79b144cde
3 changed files with 529 additions and 19 deletions
+204 -19
View File
@@ -1,37 +1,222 @@
# Отчёт — лабораторная 6
# Отчёт — лабораторная 6. Наблюдаемость
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа** — Голиков Антон, БВТ2303.
- **Целевая оценка** — 4, уровни 3 и 4.
- **Ветка** — `solution/BVT2303-Golikov`. Ссылка на PR появится после публикации.
- **Источники и библиотеки** — [задание](README.md), [контракт наблюдаемости](contracts/observability.md), OpenTelemetry Go, Gin, pgx, go-redis, MinIO SDK и amqp091-go. Для настройки использованы документация OpenTelemetry Collector, Prometheus и Grafana и реализация предыдущих лабораторных.
- **Помощь ИИ** — ChatGPT использовался для создания скриптов экспериментов и отчёта. Результаты в отчёте взяты из сохранённых прогонов на моем пк.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Git, Docker с Compose v2, Bash, OpenSSL и Python 3.9+. Для команд `make` нужен GNU Make. В Docker приложение собирается на Go 1.26.1, финальный образ использует Alpine 3.20. На Windows команды ниже рассчитаны на Git Bash и запущенный Docker Desktop.
После клонирования своего fork перейти в корень репозитория и выполнить:
```bash
git checkout solution/BVT2303-Golikov
cp .env.example .env
mkdir -p secrets
umask 077
pg_pw=$(openssl rand -hex 16)
printf '%s' "$pg_pw" > secrets/postgres_password
printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$pg_pw" \
> secrets/database_url
printf '%s' 'redis://redis:6379/0' > secrets/cache_url
printf '%s' 'messenger-minio-root' > secrets/minio_root_user
printf '%s' "$(openssl rand -hex 24)" > secrets/minio_root_password
printf '%s' 'messenger-api' > secrets/s3_access_key_id
printf '%s' "$(openssl rand -hex 24)" > secrets/s3_secret_access_key
unset pg_pw
```
В локальном `.env` задать собственное значение `RABBITMQ_PASSWORD` в URL-совместимом формате, например случайную hex-строку. Compose использует это значение и для RabbitMQ, и для URL подключения API/worker. Если запускать приложение напрямую с переменными из `.env`, синхронизировать также `RABBITMQ_URL`. Задать `GRAFANA_ADMIN_PASSWORD`. Файл `.env` и каталог `secrets/` остаются локальными.
| Настройка | Значение по умолчанию и назначение |
| --- | --- |
| `LB_PORT`, `API_REPLICAS` | `8080`, две реплики API за nginx |
| `SESSION_STORE` | Compose задаёт API значение `redis`. |
| `S3_ENDPOINT`, `S3_BUCKET` | Compose задаёт endpoint `http://minio:9000`, имя bucket по умолчанию — `messenger-attachments`. |
| `OUTBOX_INTERVAL_MS`, `WORKER_CONCURRENCY`, `JOB_MAX_ATTEMPTS` | Опрос outbox раз в 1000 мс, параллельность worker 2, до 5 попыток |
| `RECONCILER_INTERVAL_SECONDS` | 60 секунд в примере конфигурации стенда |
| `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_METRIC_EXPORT_INTERVAL` | `http://otel-collector:4318`, отправка метрик SDK каждые 15 секунд |
| `GRAFANA_PORT` | `3000`, опубликован на localhost |
```bash
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose ps -a
curl -fsS http://localhost:8080/health/ready
make test PYTHON=python
```
При первом запуске дождаться HTTP 200 на `/health/ready`. Сервис `migrate` применяет миграции PostgreSQL, `mc-init` создаёт bucket и права сервисной учётной записи в MinIO. Для этих двух контейнеров ожидается завершение с кодом 0. Бизнес-запросы идут на `http://localhost:8080`. В Grafana на `http://localhost:3000` открывается провижининговый дашборд «Мессенджер — наблюдаемость». Prometheus, Jaeger, OpenSearch и OTLP доступны внутри Compose. Для чистой пересборки контейнеров используется `bash scripts/rebuild.sh`.
`docker compose stop` останавливает стенд с сохранением данных. `docker compose down` убирает контейнеры и сеть с сохранением именованных томов. Для намеренного удаления **учебных данных и истории наблюдаемости** используется `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```mermaid
flowchart TD
Client[Клиент] --> LB[nginx]
LB --> API[Реплики API]
API --> DB[(PostgreSQL и outbox)]
API --> S3[(MinIO)]
API --> Redis[(Redis)]
DB --> Publisher[Публикатор outbox]
Publisher --> Queue[RabbitMQ]
Queue --> Worker[Worker]
Worker --> DB
Worker --> S3
Reconciler[Reconciler] --> DB
```
Из lab5 перенесены бизнес-API, асинхронная обработка вложений, outbox, повторные попытки и восстановление задач по lease. PostgreSQL хранит состояние вложений и заданий. MinIO хранит оригиналы и варианты картинок. RabbitMQ доставляет задания. Redis используется для сессий при конфигурации по умолчанию. Reconciler работает отдельным процессом, получает лидерство и восстанавливает задачи с истёкшим lease.
API валидирует файл и пишет исходник в staging S3. Состояние вложения и событие outbox сохраняются в одной транзакции PostgreSQL. Публикатор отправляет событие в RabbitMQ с подтверждением публикации. Worker захватывает задание с учётом версии pipeline и lease, читает и обрабатывает изображение, записывает варианты в S3 и фиксирует результат в БД. Переход в `ready` происходит после записи вариантов. При временной ошибке сохраняется повторная попытка, исчерпание допустимых попыток фиксируется как `failed`. Транзакция БД не охватывает S3, поэтому несвязанные staging-объекты обрабатываются по правилам очистки.
### Путь сигналов
| Сигнал | Как поступает | Хранилище и просмотр |
| --- | --- | --- |
| Метрики | API, worker и Reconciler отправляют OTLP в Collector. Prometheus опрашивает Collector и RabbitMQ каждые 15 секунд. | Prometheus 3.16.0, дашборд и Explore в Grafana |
| Логи | Структурированный JSON в stdout и OTLP через Collector. | OpenSearch 2.19.7, индекс `messenger-logs*` и Explore |
| Трассы | OpenTelemetry SDK → OTLP → Collector → Jaeger. | Jaeger 1.76.0, источник Jaeger в Grafana |
| Интерфейс | Datasources и дашборд загружаются из файлов при запуске. | Grafana 13.3.0, [datasources](infra/grafana/provisioning/datasources/observability.yaml), [дашборд](infra/grafana/dashboards/messenger.json) |
Используется Collector Contrib 0.135.0 и OTel Go SDK 1.47.0. OTLP-приёмники Collector слушают 4317 (gRPC) и 4318 (HTTP) внутри сети Compose. По умолчанию трассы корневых запросов записываются, а дочерние наследуют решение родителя. Ресурсные атрибуты включают `service.name`, `service.version`, `service.instance.id` и `deployment.environment.name`. Метки HTTP используют метод, шаблон маршрута и класс статуса. Технические идентификаторы запросов и трасс остаются в логах и трассах. В инструментации нет записи тел сообщений, изображений и заголовка Authorization.
Проверка `/health/ready` выполняется внутри спана `health.ready`. Операции pgx, обращения к Redis и S3 создают отдельные спаны. При загрузке API сохраняет W3C `traceparent` и, при наличии, `tracestate` в заголовках outbox. Публикатор восстанавливает родительский контекст и передаёт его дальше в AMQP. Worker извлекает его из сообщения, создаёт consumer-спан и спаны `job.claim`, `job.s3.get`, `job.image.process`, `job.s3.put` и `job.db.complete`. Логи API и worker содержат `trace_id` и `span_id` при активном спане.
### Устойчивость OTel Collector
Во всех трёх конвейерах первым работает `memory_limiter`. Проверка выполняется раз в секунду. При превышении мягкого порога **192 МиБ** Collector начинает отклонять входящие данные с ошибкой для повторной отправки. При превышении **256 МиБ** инициирует сборку мусора. Порог относится к памяти кучи и измеряется периодически.
`batch` запускает отправку при накоплении 256 элементов или по таймауту 1 с, максимальный размер пакета — 512 элементов. У OpenSearch и Jaeger отдельные очереди в памяти на 64 запроса экспорта и по два отправителя. При длительной недоступности хранилища очередь может заполниться и часть телеметрии может потеряться. Бизнес-задания доставляются через RabbitMQ. Конфигурация находится в [infra/otel-collector.yaml](infra/otel-collector.yaml).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Критерий | Действие и наблюдение | Доказательство |
| --- | --- | --- |
| Публичный smoke | Публичный сценарий API завершился с `PASS` при поднятом стеке телеметрии. | [smoke.txt](evidence/runs/load-20261120T175343Z/smoke.txt) |
| Метрики API | Проведён 60-секундный тест записи сообщений. В JSON есть успешные RPS, ошибки и p50/p95/p99. | [load.json](evidence/runs/load-20261120T175343Z/load.json) |
| Дашборд и источники | Provisioning описывает все три источника. Графики очереди и доступности потребителей зафиксированы на учебном стенде. | [дашборд](infra/grafana/dashboards/messenger.json), [снимок Grafana](evidence/hand_alert.jpg) |
| Трасса API → RabbitMQ → worker | Одна трасса включает HTTP upload, `attachments publish`, `attachments.process process` и операции S3/DB до готовности. | [трасса 128a933e…](evidence/runs/minio-20261120T180401Z/trace-128a933e45668d7e2a5605ef63a115eb.json) |
| Корреляция логов и трасс | Для запросов теста MinIO сохранены события API и worker с идентификаторами трасс и спанов. | [logs.jsonl](evidence/runs/minio-20261120T180401Z/logs.jsonl) |
| Очередь и состояние правила | Есть измерения возраста и глубины очереди и переход `pending` → `firing` → исчезновение серии. | [возраст очереди](evidence/runs/worker-20261120T175536Z/queue-age.json), [серии алерта](evidence/runs/worker-20261120T175536Z/alerts.json) |
| Синтетические тесты правил | `promtool` на стенде вывел `SUCCESS`. Тесты проверяют срабатывание и выход из `firing` обоих правил. | [тестовые сценарии](infra/prometheus/tests/messenger.test.yml) |
| Недоступность хранилища телеметрии | Во время остановки OpenSearch API принимал вложения, worker продолжал их обрабатывать. Сохранены замеры памяти и CPU Collector. | [events.jsonl](evidence/runs/opensearch-20261120T180605Z/events.jsonl) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Метрики и запросы
| Сигнал | Выражение или смысл | Единица |
| --- | --- | --- |
| RPS API | `sum(rate(http_requests_total{service_name="messenger-api",http_route=~"/api/.*"}[5m]))` | запросы/с |
| Доля 5xx | Скорость роста HTTP-счётчика с `http_response_status_class="5xx"`, делённая на скорость роста общего счётчика бизнес-маршрутов. В Grafana результат умножен на 100. | % |
| Задержка API | `histogram_quantile(0.95, sum by (le) (rate(http_request_duration_seconds_bucket{service_name="messenger-api",http_route=~"/api/.*"}[5m])))`. Для p50/p99 используются 0.50 и 0.99. | с |
| Очередь RabbitMQ | `rabbitmq_detailed_queue_messages`, `rabbitmq_detailed_queue_messages_ready`, `rabbitmq_detailed_queue_messages_unacked` для `attachments.process`. | сообщения |
| Возраст первого задания | `clamp_min(time() - (rabbitmq_detailed_queue_head_message_timestamp{queue="attachments.process"} > 0), 0)`. Для пустой очереди ряд может отсутствовать. | с |
| Доступность потребителей | `100 * rabbitmq_detailed_queue_consumer_capacity{queue="attachments.process"}`. Вместе с backlog и unacked используется для диагностики насыщения. | % |
| Пул PostgreSQL | `db_pool_connections{state="used"}`, `state="idle"`, `state="max"`, `db_pool_waiting` и гистограмма `db_pool_acquire_duration_seconds`. | соединения / ожидающие / с |
| Попытки worker | `sum by (outcome) (rate(jobs_processed_total[5m]))`. Задержка попытки берётся из `job_processing_duration_seconds_bucket`. | попытки/с, с |
| Время до готовности | `histogram_quantile(0.95, sum by (le) (rate(end_to_end_ready_seconds_bucket[5m])))`. От принятия вложения до перехода в `ready`. | с |
| Reconciler | `reconciler_stale_leases_total`, `reconciler_recovered_jobs_total`, `reconciler_leader`. | задачи, 0/1 |
Перцентили вычисляются после сложения скоростей роста buckets по `le` со всех реплик. В дашборде окно для `rate` подбирает `$__rate_interval`.
### SLI и SLO для учебного стенда
SLI доступности API — доля ответов бизнес-маршрутов `/api/.*` без статуса 5xx среди всех наблюдаемых ответов за окно. Health, ответы балансировщика без спана API и запросы без зарегистрированного HTTP-ответа не входят в этот серверный SLI. Окно без трафика означает отсутствие измерения.
Учебная цель — **не менее 99% ответов без 5xx за 24 часа**. Это выбранный порог для стенда. Его можно проверить по счётчикам за сутки:
```promql
1 - (
sum(increase(http_requests_total{service_name="messenger-api",http_route=~"/api/.*",http_response_status_class="5xx"}[24h]))
or
0 * sum(increase(http_requests_total{service_name="messenger-api",http_route=~"/api/.*"}[24h]))
)
/
(sum(increase(http_requests_total{service_name="messenger-api",http_route=~"/api/.*"}[24h])) > 0)
```
Суточное достижение цели по одному 60-секундному прогону не оценивалось. Алерты ниже обнаруживают короткие деградации по своим порогам.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
В именах каталогов и событиях используется UTC. Зафиксированное окно нагрузки — **60,047 с**, четыре клиента, непрерывные синтетические POST-запросы записи сообщений. Следующий запрос клиента запускается после ответа на предыдущий. Выполнен один зачётный замер без отдельного замера прогрева.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Результат — **19 422 успешных запроса**, **4 ошибки**, **323,447 успешных запроса/с**. Доля ошибок по клиентскому тесту — **0,0206%**. p50/p95/p99 успешных запросов — **15/31/32 мс**. Перцентили включают задержку клиента и не включают неуспешные запросы. Compose задаёт по умолчанию лимиты API 0,5 CPU и 256 МиБ на реплику, PostgreSQL 1 CPU и 1 ГиБ, MinIO 0,5 CPU и 512 МиБ. Модель CPU, фактически применённые переопределения лимитов, размер БД и CPU/RAM приложения в нагрузочном прогоне не записаны.
```bash
bash student-tests/evidence_collect.sh load
bash student-tests/evidence_collect.sh worker
bash student-tests/evidence_collect.sh postgres
bash student-tests/evidence_collect.sh minio
bash student-tests/evidence_collect.sh opensearch
```
Сценарии запускались последовательно. Проверочные запросы выполнялись до остановки, во время отказа и после повторного запуска сервиса. Скрипт сохраняет результаты в `evidence/runs/`.
### Инцидент A — остановка worker
Отправили 18 вложений с интервалом 15 с при остановленном worker. Пока потребителей не было, `messages_ready` вырос до 18, возраст первого задания достиг **263 с**. Правило очереди перешло в `pending`, затем в `firing`. Последняя сохранённая точка `firing` — **18:00:21 UTC**. К последней точке выборки ожидающих заданий было **0**, активной серии правила больше не было. Из графика очереди нельзя определить итоговый статус каждого вложения.
Данные — [журнал отправки](evidence/runs/worker-20261120T175536Z/worker-run.txt), [глубина очереди](evidence/runs/worker-20261120T175536Z/queue.json), [потребители](evidence/runs/worker-20261120T175536Z/consumers.json).
### Инцидент B — остановка MinIO
Во время остановки MinIO с **18:04:04 до 18:05:23 UTC** API шесть раз вернул **503** на POST загрузки. Во всех шести попытках клиент дождался своего таймаута. HTTP 503 подтверждены по серверным логам с соответствующими `trace_id`. В Jaeger-сводке трассы `24c3a9d8…` ошибка зафиксирована в `s3.PUT`. До и после опыта загрузка получила **202** и дошла до `ready`. Это локализует отказ в S3 на приёме вложения.
Данные — [события](evidence/runs/minio-20261120T180401Z/events.jsonl), [логи](evidence/runs/minio-20261120T180401Z/logs.jsonl), [ошибочная трасса](evidence/runs/minio-20261120T180401Z/trace-24c3a9d8a31d7c474cfb76a98b00bb4c.json).
### Дополнительная проверка — остановка PostgreSQL
PostgreSQL остановили с **18:02:27 до 18:03:12 UTC**. До и после опыта `GET /api/v1/chats` вернул **200**, во время отказа все шесть запросов вернули **503**. Серверный спан и `postgresql.acquire` в трассе `ae890f79…` отмечены ошибкой. По дочернему спану причина локализуется на получении соединения с БД.
Данные — [события](evidence/runs/postgres-20261120T180223Z/events.jsonl), [логи](evidence/runs/postgres-20261120T180223Z/logs.jsonl), [ошибочная трасса](evidence/runs/postgres-20261120T180223Z/trace-ae890f79b569dbc98394a702f448e4c4.json).
### Дополнительная проверка — остановка OpenSearch
OpenSearch был выключен примерно **85 с**. За это время API принял **12 вложений** с HTTP 202. Для **11** скрипт подтвердил `ready`. Для оставшегося вложения один запрос проверки статуса получил **503**, поэтому его итог в этом прогоне не подтверждён. После запуска OpenSearch повторная загрузка и проверка готовности прошли. В 12 замерах Collector использовал **68,46–82,02 МиБ** памяти и **0,09–2,03% CPU** по `docker stats`. Точное число потерянных логов в опыте не измерялось.
Данные — [события и замеры Collector](evidence/runs/opensearch-20261120T180605Z/events.jsonl), [логи stdout API и worker](evidence/runs/opensearch-20261120T180605Z/logs.jsonl).
## Алерты Prometheus
[Правила](infra/prometheus/rules/messenger.yml) оцениваются каждые 15 с. В Grafana Explore с источником Prometheus состояние видно запросом `ALERTS{alertstate=~"pending|firing"}`.
| Алерт | Условие | Удержание |
| --- | --- | --- |
| `MessengerHighAPIErrorRate` | Доля 5xx на бизнес-маршрутах API выше 5%, при общем трафике не ниже 0,2 запроса/с за 5 минут. | 2 минуты |
| `MessengerGrowingAttachmentQueue` | В `attachments.process` как минимум 5 ожидающих сообщений и положительный наклон глубины за 5 минут. | 2 минуты |
### Высокая доля ошибок API
Установить интервал вокруг появления 5xx и посмотреть RPS и процент ошибок. Найти запись о завершении запроса с 5xx в OpenSearch, взять `trace_id` и открыть ту же трассу в Jaeger. Если ошибка на `postgresql.acquire`, проверить PostgreSQL и ожидание пула. Если ошибка на `s3.PUT`, проверить MinIO. После восстановления повторить бизнес-запрос и проверить уменьшение доли ошибок. Для этого правила подтверждён синтетический переход в `firing` и выход из него. Реальные 503 подтверждены опытами с PostgreSQL и MinIO, живой `firing` правила 5xx в этих опытах не зафиксирован.
### Растущая очередь вложений
Сравнить ожидающие сообщения, сообщения без подтверждения, возраст старейшего задания и доступность потребителей. При остановленном worker запустить `docker compose start worker`. При работающем worker проверить `jobs_processed_total` по `outcome` и открыть consumer-трассу задания. Сверить спаны чтения S3, обработки изображения, записи вариантов и завершения в PostgreSQL. После восстановления очередь должна уменьшаться, а активная серия алерта исчезнуть.
### Проверка на искусственном сбое
В Git Bash из корня репозитория:
```bash
MSYS2_ARG_CONV_EXCL='*' docker run --rm \
--mount "type=bind,source=$(pwd -W),target=/work,readonly" \
-w /work --entrypoint /bin/promtool prom/prometheus:v3.16.0 \
test rules infra/prometheus/tests/messenger.test.yml
```
Я получил `SUCCESS`. Для живой проверки использован `bash student-tests/hand_alert.sh` через скрипт сбора доказательств. На [снимке первого прогона](evidence/hand_alert.jpg) видно состояние `pending`. В повторном прогоне [сохранённые данные Prometheus](evidence/runs/worker-20261120T175536Z/alerts.json) показывают восемь точек `pending`, шесть точек `firing` и исчезновение активной серии после запуска worker.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Результаты нагрузки описывают один локальный прогон, четыре параллельных клиента и синтетические сообщения. Из них нельзя вывести максимальную производительность сервиса.
- Доступность потребителей RabbitMQ используется как индикатор насыщения вместе с глубиной очереди и исходами worker. Точная занятость слотов worker и постоянные ряды CPU/RAM всех контейнеров в дашборде отсутствуют. Для отказа OpenSearch CPU/RAM Collector измерены отдельно.
- Гистограмма времени до готовности получает наблюдение при переходе в `ready`. Задания, ещё ожидающие обработки или окончательно завершившиеся ошибкой, учитываются через очередь и исходы попыток.
- Сохранённая успешная трасса демонстрирует один проход от upload до результата. Отдельная трасса полного цикла job retry в приложенных материалах отсутствует.
- Память Collector измерялась во время короткого отказа OpenSearch. Размер потерь логов и поведение при длительном заполнении очереди отправки отдельно не измерялись.
+26
View File
@@ -0,0 +1,26 @@
#!/usr/bin/env bash
set -euo pipefail
cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.."
if [[ ${1:-} == status ]]; then
docker compose ps -a
exit
fi
docker compose config --quiet
docker compose build --no-cache
docker compose up -d --force-recreate
docker compose ps -a
base_url=${BASE_URL:-http://localhost:${LB_PORT:-8080}}
for ((i=0; i<60; i++)); do
if curl --max-time 3 --fail --silent "${base_url%/}/health/ready" >/dev/null; then
printf 'API готов. %s/health/ready\n' "${base_url%/}"
exit 0
fi
sleep 2
done
printf 'API не вышел в готовность.\n' >&2
docker compose logs --tail 20 api lb migrate >&2
exit 1
+299
View File
@@ -0,0 +1,299 @@
#!/usr/bin/env bash
set -euo pipefail
export PYTHONUTF8=1
cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.."
mode=${1:-}
case "$mode" in
load|worker|postgres|minio|opensearch) ;;
*)
printf 'Использование: bash student-tests/lab6-evidence.sh {load|worker|postgres|minio|opensearch}\n' >&2
exit 2
;;
esac
base_url=${BASE_URL:-http://localhost:${LB_PORT:-8080}}
if command -v python >/dev/null 2>&1; then
py=python
else
py=python3
fi
compose_running=$(docker compose ps --status running --services)
out="evidence/runs/$mode-$(date -u +%Y%m%dT%H%M%SZ)"
mkdir -p "$out"
printf 'Результаты: %s\n' "$out"
if [[ $mode == load ]]; then
printf 'Запускаю публичный smoke-тест.\n'
"$py" tests/smoke.py --base-url "$base_url" 2>&1 | tee "$out/smoke.txt"
printf 'Запускаю нагрузку на 60 секунд с четырьмя клиентами.\n'
"$py" tests/load.py --base-url "$base_url" --duration 60 --concurrency 4 \
--output "$out/load.json"
printf 'Smoke-тест и нагрузка завершены. Результаты в %s.\n' "$out"
exit
fi
if ! grep -qx "$mode" <<< "$compose_running"; then
printf 'Сервис %s должен быть запущен перед опытом.\n' "$mode" >&2
exit 1
fi
if [[ $mode == worker ]]; then
if [[ -f student-tests/hand_alert.sh ]]; then
hand_alert=student-tests/hand_alert.sh
elif [[ -f students-tests/hand_alert.sh ]]; then
hand_alert=students-tests/hand_alert.sh
else
printf 'Положи свой hand_alert.sh в student-tests/.\n' >&2
exit 1
fi
start=$(date -u +%s)
trap 'docker compose start worker >&2 || true' EXIT
BASE_URL="$base_url" bash "$hand_alert" 2>&1 | tee "$out/worker-run.txt"
docker compose start worker
trap - EXIT
printf 'Собираю точки за 90 секунд после запуска worker.\n'
sleep 45
sleep 45
"$py" - "$start" "$(date -u +%s)" "$out" <<'PY'
import json
import os
from pathlib import Path
import subprocess
import sys
from urllib.parse import urlencode
start, end, output = sys.argv[1:]
folder = Path(output)
queue = '{queue="attachments.process"}'
queries = {
"alerts": 'ALERTS{alertname="MessengerGrowingAttachmentQueue"}',
"queue": "rabbitmq_detailed_queue_messages_ready" + queue,
"queue-age": "clamp_min(time() - (rabbitmq_detailed_queue_head_message_timestamp" + queue + " > 0), 0)",
"consumers": "rabbitmq_detailed_queue_consumer_capacity" + queue,
}
for name, query in queries.items():
params = urlencode(dict(query=query, start=start, end=end, step=15))
url = "http://localhost:9090/api/v1/query_range?" + params
raw = subprocess.check_output(
["docker", "compose", "exec", "-T", "prometheus", "wget", "-qO-", url],
env=dict(os.environ, MSYS2_ARG_CONV_EXCL="*"),
)
result = json.loads(raw)
(folder / (name + ".json")).write_bytes(raw)
if result["status"] != "success":
sys.exit(f"Ошибка запроса Prometheus ({name}).")
print(f"{name}: сохранено рядов — {len(result['data']['result'])}.")
PY
exit
fi
"$py" - "$mode" "$base_url" "$out" <<'PY'
import datetime as dt
import json
import os
from pathlib import Path
import secrets
import subprocess
import sys
import time
sys.path.insert(0, "tests")
from client import Client, Failure
service, base, output = sys.argv[1:]
folder = Path(output)
client = Client(base, timeout=8)
actor, _, _, chat = client.bootstrap()
image = Path("tests/fixtures/sample.png").read_bytes()
path = f"/api/v1/chats/{chat['id']}/attachments?filename=sample.png"
started = dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
trace_ids = set()
trace_candidates = {}
collector = None
if service == "opensearch":
collector = subprocess.check_output(
["docker", "compose", "ps", "-q", "otel-collector"], text=True
).strip()
if not collector:
sys.exit("Запусти otel-collector перед экспериментом.")
def emit(event, **fields):
row = dict(utc=dt.datetime.now(dt.timezone.utc).isoformat(), event=event, **fields)
with (folder / "events.jsonl").open("a", encoding="utf-8") as log:
log.write(json.dumps(row) + "\n")
labels = {
"http": "Ответ API",
"ready": "Вложение готово",
"client_error": "Ошибка запроса",
"matching_logs": "Сохранены записи журнала",
"trace_unavailable": "Трасса недоступна",
"stopped": "Сервис остановлен",
"started": "Сервис запущен",
"collector_stats": "Ресурсы Collector",
}
field_labels = {
"phase": "этап",
"status": "код HTTP",
"elapsed_ms": "время, мс",
"count": "количество",
"service": "сервис",
"cpu_memory": "CPU и память",
"error": "детали",
}
phases = {
"before": "до отказа",
"during": "во время отказа",
"after": "после восстановления",
}
details = ", ".join(
f"{field_labels.get(key, key)}={phases.get(value, value) if key == 'phase' else value}"
for key, value in fields.items()
if value is not None
)
print(f"{row['utc']} {labels[event]}. {details}", flush=True)
def compose(action):
subprocess.run(["docker", "compose", action, service], check=True)
def probe(phase):
trace_id = secrets.token_hex(16)
trace_ids.add(trace_id)
headers = {"traceparent": f"00-{trace_id}-{secrets.token_hex(8)}-01"}
start = time.monotonic()
try:
expected = [200, 202, 500, 502, 503, 504]
if service == "postgres":
reply = client.call(
"GET", "/api/v1/chats", expected, actor=actor, headers=headers
)
else:
headers["Content-Type"] = "image/png"
reply = client.call(
"POST", path, expected, actor=actor, headers=headers, raw=image
)
trace_candidates[(phase, reply["status"])] = trace_id
emit(
"http",
phase=phase,
trace_id=trace_id,
status=reply["status"],
request_id=reply["headers"].get("X-Request-Id"),
elapsed_ms=round(1000 * (time.monotonic() - start)),
)
if reply["status"] == 202:
client.wait_ready(actor, json.loads(reply["bytes"]), wait_seconds=30)
emit("ready", phase=phase, trace_id=trace_id)
return reply["status"] in (200, 202)
except Failure as error:
trace_candidates[(phase, "client_error")] = trace_id
emit("client_error", phase=phase, trace_id=trace_id, error=str(error))
return False
def save_logs():
logs = subprocess.check_output(
["docker", "compose", "logs", "--since", started,
"--no-color", "--no-log-prefix", "api", "worker"]
)
keys = (
"time", "level", "event", "instance_id", "request_id", "trace_id",
"span_id", "http.route", "http.response.status_code", "outcome",
)
count = 0
with (folder / "logs.jsonl").open("w", encoding="utf-8") as out:
for line in logs.splitlines():
try:
row = json.loads(line)
except (ValueError, UnicodeError):
continue
if isinstance(row, dict) and row.get("trace_id") in trace_ids:
out.write(json.dumps({key: row[key] for key in keys if key in row}) + "\n")
count += 1
emit("matching_logs", count=count)
def save_traces():
for trace_id in sorted(set(trace_candidates.values())):
result = subprocess.run(
["docker", "compose", "exec", "-T", "prometheus", "wget", "-qO-",
"http://jaeger:16686/api/traces/" + trace_id],
capture_output=True,
env=dict(os.environ, MSYS2_ARG_CONV_EXCL="*"),
)
if result.returncode != 0:
emit("trace_unavailable", trace_id=trace_id)
continue
data = json.loads(result.stdout).get("data") or []
if not data:
emit("trace_unavailable", trace_id=trace_id)
continue
trace = data[0]
spans = []
for span in trace["spans"]:
tags = {tag["key"]: tag["value"] for tag in span.get("tags", [])}
spans.append(dict(
span_id=span["spanID"],
operation=span["operationName"].split("?")[0],
service=trace["processes"][span["processID"]]["serviceName"],
duration_us=span["duration"],
references=span.get("references", []),
error=tags.get("error"),
status=tags.get("otel.status_code"),
))
(folder / ("trace-" + trace_id + ".json")).write_text(
json.dumps(spans, indent=2) + "\n", encoding="utf-8"
)
if not probe("before"):
sys.exit("Проверочный запрос до остановки сервиса завершился ошибкой.")
try:
try:
compose("stop")
emit("stopped", service=service)
for _ in range(12 if collector else 6):
probe("during")
if collector:
sample = subprocess.check_output(
["docker", "stats", "--no-stream", "--format",
"{{.CPUPerc}} {{.MemUsage}}", collector],
text=True,
)
emit("collector_stats", cpu_memory=sample.strip())
time.sleep(5)
finally:
compose("start")
emit("started", service=service)
for _ in range(30):
try:
client.call("GET", "/health/ready", 200)
break
except Failure:
time.sleep(3)
else:
sys.exit("API не вернулся в состояние готовности после запуска сервиса.")
if not probe("after"):
sys.exit("Проверочный запрос после запуска сервиса завершился ошибкой.")
# Даём SDK и Collector время отправить данные последнего запроса.
time.sleep(15)
save_traces()
finally:
save_logs()
PY