feat: telemetry cost profile with head sampling, coarse buckets and balanced tail sampling
- [telemetry] trace_sample_ratio (ParentBased(TraceIdRatioBased), 1 keeps ParentBased(ALWAYS_ON)) and metric_buckets (default|coarse with SLO bounds), export interval <= 30 s; otel.sdk.span.started, span.live dropped; startup records name ratio, buckets and interval - bench: telemetry services on mtusi-bench, TELEMETRY=on switch for uploads and queue, make bench_telemetry[_quick] with off/full/full-aa/head/tail/ metrics/balanced, rare events, lookup from Tempo/Loki/Prometheus, cost sampler, verdicts H1-H8 and B1-B5; collector layers and lean Prometheus in bench/otel with preflight checks - REPORT: telemetry cost hypotheses and criteria before the label Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+82
-1
@@ -101,6 +101,7 @@ change `s3-storage`, решение 9): старт стенда перечисл
|
||||
| `run.py` (профили `uploads`, `uploads_quick`), `uploads.py`, `sampler.sh` (режим `peak`), `k6/uploads.js`, `k6/prepare.js` | `make bench_uploads [UPLOADS_LABEL=…]`, `make bench_uploads_quick` | память реплики при одновременных загрузках вложений (change `upload-memory`): одна реплика 1 CPU / 512 МБ без swap, S3 рабочего стенда, варианты «до» / «без лимита» / «с лимитом», тела PNG ~1 и ~10 MiB, 1 / 10 / 20 / 40 клиентов; пик `memory.peak` окна, OOM, ответы по кодам, загрузок/с и p50/p95/p99; результаты — `evidence/uploads/<метка>/` |
|
||||
| `run.py` (профили `reconcile`, `reconcile_quick`), `reconcile.py`, `fill_objects.py`, `sampler.sh` (режим `scan`), `k6/background.js`, `k6/prepare.js` | `make bench_reconcile [RECONCILE_LABEL=…]`, `make bench_reconcile_quick` | стоимость сверки bucket и БД (change `track2-reconcile-cost`): наполнение мимо API (`\copy` и PUT в S3), разовые проходы уборщика — стратегии `batch` и `head`, глубокая, CPU уборщика, предел скорости, фоновая нагрузка, отказ по пределу «до» и «после»; счёт сверки против метрик шлюза S3, CPU и память за окно прохода; результаты — `evidence/reconcile/<метка>/` |
|
||||
| `run.py` (профили `queue`, `queue_quick`), `overload.py`, `make_images.py`, `queue.compose.yml`, `rabbitmq/`, `sampler.sh` (режим `queue`), `k6/queue.js`, `k6/queue_sweep.js`, `k6/background.js`, `k6/prepare.js` | `make bench_queue [QUEUE_LABEL=…] [RESUME=1]`, `make bench_queue_quick` | очередь под перегрузкой (change `track1-queue-overload`): стенд с S3, брокером, relay, worker и уборщиком, настройки конкуренции и prefetch × классы изображений, блоки предела, приёма, второго worker и рестартов; результаты — `evidence/queue/<метка>/` |
|
||||
| `run.py` (профили `telemetry`, `telemetry_quick`), `telemetry_cost.py`, `telemetry_lookup.py`, `telemetry.compose.yml`, `otel/`, `make_images.py` (класс `bad`), `sampler.sh` (режим `cost`), `k6/telemetry.js`, `k6/queue.js`, `k6/queue_sweep.js`, `k6/prepare.js` | `make bench_telemetry [TELEMETRY_LABEL=…] [RESUME=1] [VARIANTS=…]`, `make bench_telemetry_quick`; `TELEMETRY=on` у `bench_uploads*` и `bench_queue*` | цена наблюдаемости (change `track1-telemetry-cost`): стенд очереди и сервисы телеметрии рабочего стенда, варианты `off`, `full`, `full-aa`, `head`, `tail`, `metrics`, `balanced` × 3 повтора, одинаковая открытая нагрузка с редкими событиями; задержки, CPU и память компонентов, приём, потери по звеньям, что сохраняет каждый вариант; результаты — `evidence/telemetry-cost/<метка>/` |
|
||||
| `run.py` (профили `scaling_*`), `scaling.py`, `sampler.sh`, `k6/mixed.js` | `make bench_scaling SERIES=a\|b\|pool\|ab\|db\|db4`, `make bench_scaling_quick`, `SERIES=db_quick` | серии трека 1: конфигурации реплик и лимитов, на каждую ячейку — свежий стенд, открытая модель, фиксированные уровни и поиск R* по SLO, посекундный сэмплер контейнеров, ВМ, LB и PostgreSQL; результаты — `evidence/bench/<метка>/` |
|
||||
| `plots.py` | `make bench_plots LABELS="…"` | графики SVG и сводка серий (R* от числа реплик, p95 от интенсивности, CPU по компонентам, точка насыщения) — `evidence/plots/<PLOTS>/` |
|
||||
| `compare.py` | `make bench_compare` | дельта двух меток стенда (ячейки матрицы или общие конфигурации серий), эффект или шум |
|
||||
@@ -183,7 +184,22 @@ change `s3-storage`, решение 9): старт стенда перечисл
|
||||
(решение 7) так же и у `relay`; при выключенной телеметрии модули SDK, экспортёра и
|
||||
`requests` процессы не загружают (ленивый импорт), поэтому память реплики в метках снова
|
||||
сравнима с кодом лабы 5, кроме модулей метрик SDK, которые грузит сам redis-py. Пул engine
|
||||
— `CountingQueuePool` (два счётчика вокруг `connect()`): поведение и цена выдачи прежние;
|
||||
— `CountingQueuePool` (два счётчика вокруг `connect()`): поведение и цена выдачи прежние.
|
||||
С design change `track1-telemetry-cost` (решения 1, 13) сервисы телеметрии описаны в
|
||||
`bench.compose.yml` (`mtusi-bench-<сервис>`, `restart: "no"`, лимиты `BENCH_COLLECTOR_*`,
|
||||
`BENCH_PROMETHEUS_*`, `BENCH_LOKI_*`, `BENCH_TEMPO_*` — поля `Profile`, рабочего стенда, без swap;
|
||||
сеть `mtusi-bench-telemetry`; у Grafana порт сброшен, она не запускается никогда). Запускают их
|
||||
только варианты профиля цены телеметрии и выключатель `TELEMETRY=on` профилей загрузок и
|
||||
очереди (ниже); без него — всё прежнее, `stand.telemetry.mode` в паспорте — `off`. С `on` второй
|
||||
`-f` — `bench/telemetry.compose.yml` (`TELEMETRY__ENABLED: "true"` и адрес Collector у `api`,
|
||||
`worker`, `relay`), свой override профиля — третьим (`Stand.telemetry_files` между базой и
|
||||
`extra_files`, его профили не перезаписывают). Режим — поле `Profile.telemetry`, а не
|
||||
`overrides`: `RESUME` требует тот же режим (`resume_problems`). Сумма лимитов CPU с
|
||||
телеметрией больше CPU ВМ (очередь — 12,25 при 12) — предупреждение `host_warnings` и строка
|
||||
сводки, а не код 2; без телеметрии правило очереди прежнее. Лимиты телеметрии в `Profile`
|
||||
сверяются с основным `docker-compose.yml` до стенда (`telemetry_preflight`, код 2). У очереди
|
||||
с `on` — столбцы `tel_<сервис>_cpu_over`, `_throttle_over`, `_peak_mib` в конце `cells.csv`;
|
||||
у загрузок вариант «до» — код без SDK, сводка называет сравнение смешанным;
|
||||
- **PostgreSQL `max_connections`:** 100, как у образа (`-c
|
||||
max_connections` в override); у серий — из конфигурации ячейки,
|
||||
лимиты конфигурации в паспорте (`limits.<конфигурация>`);
|
||||
@@ -587,6 +603,71 @@ design change `track2-reconcile-cost`, решения 1–3, 7–13. Метод
|
||||
- **Время:** полный профиль — 57 ячеек, ~2 ч 10 мин; `queue_quick` — `s` (2, 2), `lp` (4, 4),
|
||||
предел 40 и без него, `kill-worker`, `w2-p256`, ~11 мин. Рабочий стенд — `make stop`.
|
||||
|
||||
## Профиль цены телеметрии (`telemetry`, `telemetry_quick`)
|
||||
|
||||
Спек `load-benchmark`, «Профиль цены телеметрии», «Выключатель телеметрии стенда», «Цена телеметрии
|
||||
в отчёте»; design change `track1-telemetry-cost`, решения 1–14. Методика — поля `Profile`
|
||||
(`telemetry_*`, лимиты `collector_*`, `prometheus_*`, `loki_*`, `tempo_*`, `lookup_*`) в `run.py`;
|
||||
таблица вариантов, план, разбор, вердикты H1–H8 и B1–B5, сводка и проверки конфигураций без docker
|
||||
— `bench/telemetry_cost.py` (`--selftest`), выборка из хранилищ — `bench/telemetry_lookup.py`.
|
||||
|
||||
- **Стенд:** компоненты и лимиты профиля очереди (LB, две реплики, PostgreSQL, Valkey, S3, брокер,
|
||||
relay, один worker, уборщик; без `queue.compose.yml`: плагин метрик брокера и политика
|
||||
перезапуска worker вариантам не нужны), в вариантах с телеметрией — Collector, Prometheus, Loki и
|
||||
Tempo рабочего стенда (`bench/telemetry.compose.yml` вторым `-f`); Grafana — никогда. Порядок
|
||||
старта: PostgreSQL и Valkey → миграции → телеметрия (Prometheus `--wait`, затем Collector, Loki,
|
||||
Tempo, `wait-ready` контейнера выборки) → S3 и брокер → реплики и LB → relay, уборщик, worker.
|
||||
Каждый прогон — свежий стенд (`down -v` вместе с volume хранилищ телеметрии).
|
||||
- **Варианты** — `telemetry_cost.variants()`: окружение `TELEMETRY__*` трёх процессов, слой
|
||||
Collector (`bench/otel/tail-typical.yaml`, `tail-balanced.yaml` — второй `--config`) и
|
||||
конфигурация Prometheus (`bench/otel/prometheus-lean.yml` — bind на тот же путь) пишутся в
|
||||
`.work/variant.compose.yml` прогона. **До стенда** (`telemetry_preflight`, код 2 с именем файла):
|
||||
лимиты `Profile` против `docker compose config` основного файла; слои — `validate` и сравнение
|
||||
`print-config --format=json` со слоем и без него (только `processors.tail_sampling` и список
|
||||
процессоров pipeline трасс); копия Prometheus — построчно вне `# bench-lean` и `promtool check
|
||||
config`. **После** — записи «Started API/worker/relay» против варианта (`startup_problems`) и
|
||||
признаки слоёв в выборке (`layer_problems`): расхождение — отказ команды с прогоном.
|
||||
- **Нагрузка** — `k6/telemetry.js`: классы — сценарии `constant-arrival-rate` (`timeUnit` 10 с, VU
|
||||
заранее без прибавления, ответ не повторяется), строка `t,…` на запрос с `X-Request-Id`,
|
||||
`t-t0` в `setup()`; окна — разогрев, чистое (цена), отказов (блокировки `LOCK TABLE messages IN
|
||||
SHARE MODE` на `telemetry_locks` секундах, моменты `clock_timestamp()` — `meta.telemetry_cost.
|
||||
locks_at`). Перед нагрузкой — `prepare.js`, разогрев 12 файлов `s` до `ready` (готовые байты
|
||||
скачиваний, `queue_warm`), одна строка вложения `ready` без объекта (`\copy`, `reconcile.rows_csv`
|
||||
с `FORCE_MISSING` — класс `broken`). Регистрация — пароль из `crypto.randomUUID()` только в
|
||||
памяти итерации.
|
||||
- **Граница чёрного ящика** — новые исключения, только у этого профиля и только на свежем стенде:
|
||||
строка вложения без объекта; блокировка таблицы сообщений в своей сессии psql; счёт незавершённых
|
||||
заданий в PostgreSQL; чтение Prometheus, Loki, Tempo и метрик Collector по HTTP из контейнера
|
||||
`mtusi-bench-lookup` (образ стенда, stdlib, `bench/` на чтение, сеть `mtusi-bench-telemetry`,
|
||||
0,5 CPU / 256 МиБ); размер volume хранилищ — `mtusi-bench-du` (образ PostgreSQL, `--user 0`, без
|
||||
сети, volume на чтение); записи о старте процессов в журналах контейнеров. Оба контейнера — в
|
||||
остатках и уборке стенда.
|
||||
- **Выборка** (`telemetry_lookup.py collect`): трассы по `span.messenger.request_id` пачками по 40
|
||||
(регулярное выражение), цепочка загрузки — структурный TraceQL (`&& { kind = consumer && …outcome
|
||||
}` `&& { kind = producer }`), записи доступа по `request_id` и их `trace_id` → `/api/v2/traces`,
|
||||
счётчики приёма, потерь и событий (`query_range` с шагом 15 с по краям чистого окна, итог — в
|
||||
конце), ряды по `job`, `status/tsdb`, `status/config`, квантили из buckets против
|
||||
`quantile_over_time` Loki. Предел результатов — 4 × ожидаемого; равен пределу — отказ «lookup
|
||||
truncated». Повторы — только на обрыв соединения и 5xx (Tempo с 0,5 CPU под пулом запросов
|
||||
изредка закрывает соединение).
|
||||
- **Ожидание после нагрузки:** незавершённых заданий 0 (не дольше `telemetry_drain_s`, иначе
|
||||
`not_drained`), обход метаданных `queue_sweep.js` (без байтов), затем `telemetry_cost.wait_after`
|
||||
от конца нагрузки — последние отправки метрик и решения выбора трасс доходят до хранилищ.
|
||||
- **Сэмплер `cost`** — как `scan` (без сети), плюс строки `mp`; сторож — `check_observer`.
|
||||
- **Пометки:** `dropped`, `host_swap`, `storage_down`, `oom`, `not_drained`, `lost` (ненулевой код в
|
||||
конце метки), `telemetry_loss` (результат варианта), `saturated` (у `full` нарушена граница
|
||||
калибровки решения 8 — повод переснять).
|
||||
- **`RESUME=1`** — как у очереди: тот же commit и режим, готовая строка `runs.csv` — признак
|
||||
прогона. `VARIANTS=…` — отладка (`overrides`, продолжение с ними запрещено).
|
||||
- **Результаты:** `evidence/telemetry-cost/<метка>/` — `meta.json` (раздел `telemetry_cost`:
|
||||
варианты с SHA-256 слоёв, план, интенсивности, окна, блокировки, `app_env` по вариантам;
|
||||
`limits_by_mode`, `stand` и `stand_telemetry` с образами, лимитами и SHA-256 конфигураций),
|
||||
`runs.csv`, `components.csv`, `classes.csv` (новые столбцы — только в конец), `summary.md`, четыре
|
||||
SVG, `raw/` — итоги k6 и выборки (идентификаторы синтетические). `quick-telemetry-*` — в
|
||||
`.gitignore`.
|
||||
- **Время:** полный профиль — 21 прогон, ~1 ч 50 мин; быстрый — шесть вариантов, ~20 мин;
|
||||
`VARIANTS=off,full,tail` — ~10 мин (защита «для 5»). Рабочий стенд — `make stop`.
|
||||
|
||||
## Серии трека 1 (`scaling_*`)
|
||||
|
||||
Доказательство уровня «5», трек 1 «Цена масштабирования» (design change
|
||||
|
||||
@@ -420,6 +420,13 @@ Design change `otel-telemetry`, решения 1, 7, 14–20; правила к
|
||||
раньше сервера, тот падал на `eacces`. Стенд с нуля проверяет `driver.py stand-from-scratch`
|
||||
(свой проект, удаляет свои volumes сам).
|
||||
- **`restart.sh`** сервисы телеметрии не трогает (решение 6).
|
||||
- **Стенд `bench/`** (design change `track1-telemetry-cost`, решения 1, 13): те же сервисы и
|
||||
конфигурации под проектом `mtusi-bench` — `container_name` `mtusi-bench-<сервис>`, `restart:
|
||||
"no"`, лимиты `BENCH_*` (поля `Profile`, рабочего стенда, сверка с этим файлом до стенда), без
|
||||
swap и портов, сеть `telemetry` — имя `mtusi-bench-telemetry`; Grafana описана, порт сброшен, не
|
||||
запускается. Запускают их только профиль цены телеметрии и `TELEMETRY=on` (`bench.md`). Правка
|
||||
лимитов или образа сервиса телеметрии здесь — та же правка полей `Profile` в `bench/run.py`,
|
||||
иначе профили с телеметрией откажут до стенда (код 2).
|
||||
- **Суммы:** постоянные лимиты 11,5 CPU / 7296 МиБ, с одноразовыми 12,5 CPU / 7680 МиБ при ВМ
|
||||
12 CPU / 7934 МиБ; телеметрия — 2,5 CPU / 2304 МиБ (Collector 256, Prometheus 384, Loki 512,
|
||||
Tempo 640, Grafana 512); пики и правило «лимит ≥ 1,5 × пика» — `evidence/telemetry/budget.md`;
|
||||
|
||||
@@ -111,7 +111,12 @@ Design change `otel-telemetry`, решения 2 и 12; правило `telemetr
|
||||
без телеметрии хуков нет — записи прежние. `logger.py` SDK не импортирует. Записи логгеров
|
||||
`opentelemetry.*` не экспортируются, а handler пропускает в stdout не больше одной в минуту на
|
||||
логгер (`RateLimitFilter`, `TELEMETRY_SDK_LOG_WINDOW_SECONDS`). «Started API» и «Started worker»
|
||||
— `telemetry_enabled`, `telemetry_endpoint`, `telemetry_environment`; `warning` «Ignored
|
||||
— `telemetry_enabled`, `telemetry_endpoint`, `telemetry_environment`, с design change
|
||||
`track1-telemetry-cost` (решение 3) ещё `telemetry_trace_sample_ratio`, `telemetry_metric_buckets`,
|
||||
`telemetry_metric_export_interval_seconds` (при выключенной — `null`), у всех трёх процессов —
|
||||
одной функцией `telemetry.startup_fields`; профиль цены телеметрии сверяет по ним вариант. Запись
|
||||
невыбранного в голове запроса уходит в Loki с `trace_id` и флагами без бита выборки, а в stdout
|
||||
полей трассы нет (span не записывается); `warning` «Ignored
|
||||
OpenTelemetry environment variables» — `names` без значений. С design change
|
||||
`job-trace-propagation` (решения 2, 7, 12): то же у relay — его записи идут в Loki
|
||||
(`service_name` `messenger-relay`), «Started relay» называет телеметрию, «Stopped relay» — после
|
||||
|
||||
@@ -248,7 +248,11 @@ run_relay` — те же мосты. Имена skeleton: `BROKER_URL_FILE` →
|
||||
процессы API, worker и с design change `job-trace-propagation` (решение 7) relay; уборщик,
|
||||
миграции и команда replay — нет: `enabled` (`False`), `otlp_endpoint` (`http://127.0.0.1:4318`,
|
||||
валидатор: схема `http`/`https`, хост, порт, без пути, query и учётных данных),
|
||||
`environment` (`lab`, `^[a-z0-9._-]{1,32}$`), `metric_export_interval_seconds` (15),
|
||||
`environment` (`lab`, `^[a-z0-9._-]{1,32}$`), с design change `track1-telemetry-cost` (решения
|
||||
3–4) `trace_sample_ratio` (`float`, 0…1, 1 — все трассы, прежний `ParentBased(ALWAYS_ON)`) и
|
||||
`metric_buckets` (`MetricBucketsEnum`: `default` | `coarse`) — оба в `config_example.toml` со
|
||||
значениями по умолчанию, в `.env` их нет, вариант стенда `bench/` задаёт окружением;
|
||||
`metric_export_interval_seconds` (15, не больше 30 — половины срока рядов экспортёра Collector),
|
||||
`export_timeout_seconds` (2), `max_queue_size` (2048), `max_export_batch_size` (512, не больше
|
||||
очереди), `schedule_delay_seconds` (1); `float` — `allow_inf_nan=False`. Включает стенд
|
||||
compose у `api`, `worker` и `relay` (`x-telemetry-env`: `TELEMETRY__ENABLED`,
|
||||
@@ -263,7 +267,9 @@ TELEMETRY_SHUTDOWN_TIMEOUT_SECONDS` = 8 (валидатор поля `telemetry`
|
||||
«Уточнения apply», п. 13). Имена skeleton:
|
||||
`OTEL_SERVICE_NAME` → константы `TELEMETRY_SERVICE_API` / `_WORKER` / `_RELAY`,
|
||||
`OTEL_EXPORTER_OTLP_ENDPOINT` → `otlp_endpoint`, `OTEL_EXPORTER_OTLP_PROTOCOL` — постоянно
|
||||
`http/protobuf`, `OTEL_RESOURCE_ATTRIBUTES` → `environment` (`service.*` вычисляет код).
|
||||
`http/protobuf`, `OTEL_RESOURCE_ATTRIBUTES` → `environment` (`service.*` вычисляет код), `OTEL_TRACES_SAMPLER` —
|
||||
постоянно `parentbased_traceidratio` (при доле 1 — `parentbased_always_on`),
|
||||
`OTEL_TRACES_SAMPLER_ARG` → `trace_sample_ratio`.
|
||||
`GRAFANA_ADMIN_PASSWORD` (секрет, `ENV_SECRETS` и `ENV_FILLED` Makefile) и `GRAFANA_OUT_PORT`
|
||||
— переменные compose, приложение их не читает.
|
||||
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
paths:
|
||||
- "src/infra/telemetry/**"
|
||||
- "infra/otel/**"
|
||||
- "bench/otel/**"
|
||||
---
|
||||
|
||||
# Телеметрия (с лабы 6)
|
||||
@@ -24,8 +25,16 @@ paths:
|
||||
пакета — redis-py 8.1 сам грузит `opentelemetry.sdk.metrics` (проба «установлен ли SDK»):
|
||||
тест сравнивает с `import redis.asyncio` (design JTP, «Уточнения apply»).
|
||||
- **Настройки — только `[telemetry]`** (решение 8): ресурс конструктором без детекторов, sampler
|
||||
`ParentBased(ALWAYS_ON)` (JTP-5: корни выбираются всегда, удалённый родитель из задания
|
||||
передаёт свой флаг), лимиты span, очереди и сроки процессоров, `headers={}`, без сжатия,
|
||||
`ParentBased(ALWAYS_ON)` при `trace_sample_ratio` 1 (JTP-5: корни выбираются всегда, удалённый
|
||||
родитель из задания передаёт свой флаг), иначе `ParentBased(TraceIdRatioBased(доля))`
|
||||
(`sdk.sampler`, design change `track1-telemetry-cost`, «TC-n» ниже, TC-3); границы трёх histogram —
|
||||
набор `metric_buckets` (`default` / `coarse`, константы `*_BUCKETS_COARSE`, обе с границами SLO
|
||||
0,25 с и 30 с, TC-4); `metric_export_interval_seconds` ≤ 30 (половина срока рядов экспортёра
|
||||
Collector, `TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS`). Невыбранный span — валидный контекст
|
||||
без записи: дочерних span нет (`child_span`), запись журнала уходит в Loki с его `trace_id` и
|
||||
флагами без бита выборки, stdout — без полей трассы. Запись о старте трёх процессов —
|
||||
`telemetry.startup_fields` (доля, набор, интервал; при выключенной — `null`): по ней профиль цены
|
||||
телеметрии сверяет вариант. Лимиты span, очереди и сроки процессоров, `headers={}`, без сжатия,
|
||||
cumulative, exemplars выключены, `shutdown_on_exit=False`. Новый параметр SDK — поле секции, а
|
||||
не переменная `OTEL_*` и не значение по умолчанию SDK. `OTEL_*` удаляются из окружения до
|
||||
провайдеров (их читает конструктор: `OTEL_SDK_DISABLED`) и называются в `warning` без
|
||||
@@ -87,10 +96,15 @@ paths:
|
||||
с `meter_provider=` этого провайдера — внутри `_internal_metrics()`, который ставит
|
||||
`OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED` (`TELEMETRY_SDK_INTERNAL_METRICS_ENV`) только на время
|
||||
их конструирования: другого выключателя в SDK 1.45 нет, внешнее значение уже удалено
|
||||
`remove_otel_environment`. Читатель метрик и провайдеры строятся вне окна — своих метрик у них
|
||||
нет. Гистограммы SDK (`TELEMETRY_SDK_DROPPED_HISTOGRAMS`) — `DropAggregation`. Новый процессор
|
||||
или экспортёр — тоже в окне и с провайдером, иначе его потери не считаются. Быстрый тест SDK
|
||||
OTLP — `Exporters(spans=None, logs=None, …)` и подставная `requests.Session.send`.
|
||||
`remove_otel_environment`. Читатель метрик и `MeterProvider` строятся вне окна — своих метрик у
|
||||
них нет. С TC-3 в окне же `TracerProvider(meter_provider=…)` и `Tracer` (`Providers.tracer`, его
|
||||
конструктор читает переменную): `otel.sdk.span.started` по происхождению родителя и решению
|
||||
выборки (`DROP`, `RECORD_AND_SAMPLE`) — отброшенное выборкой отдельно от потерь, правило
|
||||
`telemetry:lost_items:total` его не берёт. Инструменты SDK, которые не отдаются
|
||||
(`TELEMETRY_SDK_DROPPED_INSTRUMENTS`: гистограммы SDK и `otel.sdk.span.live`), —
|
||||
`DropAggregation`. Новый процессор или экспортёр — тоже в окне и с провайдером, иначе его потери
|
||||
не считаются. Быстрый тест SDK OTLP — `Exporters(spans=None, logs=None, …)` и подставная
|
||||
`requests.Session.send`.
|
||||
|
||||
## Конфигурации (`infra/otel/`)
|
||||
|
||||
@@ -164,4 +178,20 @@ paths:
|
||||
`stand-from-scratch` (решение 21; `SKILL.md` скилла `run-mtusi-messenger`), быстрые тесты
|
||||
`service-tests/unit/test_telemetry.py`, `service-tests/db/test_telemetry_db.py`,
|
||||
`service-tests/db/test_pool_counts.py`. Консоль, `make test_isolated`, стенд отказов и `bench/` —
|
||||
без телеметрии у API, worker и relay (`TELEMETRY__ENABLED: "false"`, решение 20).
|
||||
без телеметрии у API, worker и relay (`TELEMETRY__ENABLED: "false"`, решение 20). На `bench/` её
|
||||
включают только вариант профиля цены телеметрии и выключатель `TELEMETRY=on` профилей загрузок и
|
||||
очереди (TC-1, TC-13; `bench.md`): сервисы и конфигурации `infra/otel/` рабочего стенда, SDK через
|
||||
`bench/telemetry.compose.yml`.
|
||||
|
||||
## Слои вариантов (`bench/otel/`, TC-5–7)
|
||||
|
||||
- Не `infra/otel/`: рабочий стенд остаётся со всеми трассами и всеми рядами (TC-5).
|
||||
- Слой Collector (`tail-typical.yaml`, `tail-balanced.yaml`) — только процессор `tail_sampling` и
|
||||
`service.pipelines.traces.processors` (`[memory_limiter, tail_sampling, batch]`): второй
|
||||
`--config` сливает карты и заменяет списки. Правка `collector.yaml` или слоя — `telemetry_preflight`
|
||||
(`bench/run.py`) до стенда: `validate` и сравнение `print-config --format=json` со слоем и без
|
||||
него; формат JSON помечен нестабильным — смена версии Collector повод проверить.
|
||||
- `prometheus-lean.yml` — копия `prometheus.yml` с блоками `metric_relabel_configs` (`action:
|
||||
keep`) у `loki`, `tempo`, `prometheus` между строками `# bench-lean: begin` / `end`. **Правка
|
||||
`prometheus.yml` — та же правка копии**: вне блоков файлы совпадают построчно, иначе профиль —
|
||||
код 2 (`telemetry_cost.lean_problems`, и в `--selftest`).
|
||||
|
||||
@@ -29,6 +29,9 @@
|
||||
# OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf — постоянно (установлен только
|
||||
# экспортёр OTLP/HTTP protobuf); OTEL_RESOURCE_ATTRIBUTES — [telemetry]
|
||||
# environment (deployment.environment.name), service.* вычисляет код.
|
||||
# Стандартные имена выбора трасс тоже не настройки: OTEL_TRACES_SAMPLER —
|
||||
# постоянно parentbased_traceidratio (при доле 1 — parentbased_always_on),
|
||||
# OTEL_TRACES_SAMPLER_ARG — [telemetry] trace_sample_ratio.
|
||||
# Включает телеметрию compose (TELEMETRY__ENABLED у api, worker и relay), в .env её
|
||||
# нет: консоль — без телеметрии.
|
||||
|
||||
|
||||
@@ -42,6 +42,8 @@ evidence/uploads/quick-*/
|
||||
evidence/reconcile/quick-reconcile-*/
|
||||
# make bench_queue_quick: то же для профиля очереди
|
||||
evidence/queue/quick-*/
|
||||
# make bench_telemetry_quick: то же для профиля цены телеметрии
|
||||
evidence/telemetry-cost/quick-*/
|
||||
# сравнения пробных меток
|
||||
evidence/compare/*quick-*
|
||||
# make bench_plots на пробных метках
|
||||
|
||||
@@ -59,8 +59,16 @@ SLI и SLO (доступность на LB 99,5 %, задержка «лёгки
|
||||
в проверках, pending на каждом шаге, сверка SLI одним окном) — commit `ef60b47`, на нём
|
||||
пересняты (2026-11-14) `rules-test.md`, `alerts/check.md` и `backend-outage.md`;
|
||||
`evidence/telemetry/check.md` — на `4a2f9c9` (тот же код и правила, драйвер ждёт в Loki все записи
|
||||
прохода relay). Активных changes нет; следующий по `PLAN.md` — `track1-telemetry-cost`
|
||||
(уровень 5, трек 1 «Цена наблюдаемости»).
|
||||
прохода relay). Четвёртое изменение лабы, уровень 5, трек 1 «Цена наблюдаемости» — change
|
||||
`track1-telemetry-cost` (активный, `openspec/changes/track1-telemetry-cost/`, изменяет
|
||||
`observability`, `service-configuration`, `load-benchmark`): выбор трасс в голове и наборы границ
|
||||
histogram — поля `[telemetry] trace_sample_ratio`, `metric_buckets` (по умолчанию прежнее
|
||||
поведение), счёт начатых span `otel.sdk.span.started`, запись о старте с долей, набором и
|
||||
интервалом; телеметрия на стенде `bench/` — профиль `make bench_telemetry` (варианты `off`,
|
||||
`full`, `full-aa`, `head`, `tail`, `metrics`, `balanced`, редкие события с известным счётом,
|
||||
`evidence/telemetry-cost/<метка>/`) и выключатель `TELEMETRY=on` у `bench_uploads` и
|
||||
`bench_queue`; сбалансированная конфигурация — `bench/otel/` (рабочий стенд остаётся со всеми
|
||||
трассами); гипотезы H1–H8 и критерии B1–B5 — `REPORT.md`, «Цена наблюдаемости (трек 1)».
|
||||
Код перенесён из лабы 5 (репозиторий
|
||||
`mtusi2026lab5-safronov`, ветка `solution/bvt2301-safronov`, commit
|
||||
`046ec9e`) по разделу «Переход в следующую лабу»; отчёт и evidence лабы 5
|
||||
@@ -591,7 +599,10 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
|
||||
| `make bench_uploads [UPLOADS_LABEL=...]` | уровень 4, память при одновременных загрузках (~50 мин, метка `baseline` по умолчанию; change `upload-memory`): стенд `mtusi-bench` с LB, одной репликой 1 CPU / 512 МБ без swap, PostgreSQL, Valkey и S3 рабочего стенда; варианты «до» (`Profile.uploads_before` — `9cc6c0c`, commit переноса лабы 5 в лабу 6: места загрузки уже есть, успех 202, `bench.md`; `git archive`; commit вне истории — код 2), «без лимита» (1000 мест, без очереди) и «с лимитом» (по умолчанию) × тела PNG ~1 и ~10 MiB × 1 / 10 / 20 / 40 клиентов × 3 повтора, на прогон — новые реплика и volume S3; пик `memory.peak` окна со сбросом (сэмплер `peak`), `anon`, `sock`, OOM, ответы по кодам, загрузок/с, p50/p95/p99, пики S3 и LB, H1–H4 в сводке — `evidence/uploads/<метка>/`. Перед запуском — проверка хоста (`bench.md`), рабочий стенд — `make stop`, гипотезы закоммичены раньше |
|
||||
| `make bench_uploads_quick` | то же короче (~4,5 мин): «без лимита» и «с лимитом», 10 MiB, 1 / 10 / 40 клиентов, один повтор, метка `quick-uploads-<время>`, в git не идёт |
|
||||
| `make bench_queue [QUEUE_LABEL=...] [RESUME=1]` | уровень 5, трек 1, очередь под перегрузкой (~2 ч 10 мин, метка `baseline` по умолчанию; заняты `baseline`…`baseline4`, основная — `baseline4`, новый прогон — со своей `QUEUE_LABEL`; change `track1-queue-overload`): стенд `mtusi-bench` с S3, брокером, relay, worker и уборщиком, настройки (1, 1), (2, 2), (4, 4), (2, 256) × классы `s`, `m`, `lj`, `lp` × 3 повтора и блоки предела, приёма, второго worker, KILL worker, рестарта брокера; на ячейку — свежий стенд, открытая модель, контрольный поток, разбор очереди, обход метаданных; `evidence/queue/<метка>/` (`meta.json`, `cells.csv`, `timeline.csv`, `summary.md` с H1–H9 и рекомендацией, SVG). Рабочий стенд — `make stop`, гипотезы закоммичены раньше метки |
|
||||
| `make bench_queue_quick` | то же короче (~11 мин): `s` (2, 2), `lp` (4, 4), предел 40 и без него, `kill-worker`, `w2-p256`, один повтор, метка `quick-queue-<время>`, в git не идёт; шаг защиты «для 5» |
|
||||
| `make bench_queue_quick` | то же короче (~11 мин): `s` (2, 2), `lp` (4, 4), предел 40 и без него, `kill-worker`, `w2-p256`, один повтор, метка `quick-queue-<время>`, в git не идёт; шаг защиты «для 5» лабы 5 |
|
||||
| `TELEMETRY=on` у `make bench_uploads`, `bench_uploads_quick`, `bench_queue`, `bench_queue_quick` | выключатель телеметрии стенда (change `track1-telemetry-cost`, по умолчанию `off` — методика прежняя): Collector, Prometheus, Loki и Tempo рабочего стенда (`bench/telemetry.compose.yml`, без Grafana) и SDK реплик, worker и relay с настройками рабочего стенда; режим — в паспорте и сводке, `RESUME=1` — только в том же режиме; у очереди — столбцы `tel_*` в конце `cells.csv` и предупреждение о сумме лимитов CPU (12,25 при 12 у ВМ) вместо кода 2; у других профилей `--telemetry on` — код 2 до стенда |
|
||||
| `make bench_telemetry [TELEMETRY_LABEL=...] [RESUME=1] [VARIANTS=...]` | уровень 5, трек 1 «Цена наблюдаемости» (~1 ч 50 мин, метка `baseline`; change `track1-telemetry-cost`): проверка конфигураций до стенда (лимиты телеметрии против `docker-compose.yml`, слои Collector `validate` и `print-config`, `prometheus-lean.yml` построчно и `promtool`) — иначе код 2; стенд `mtusi-bench` профиля очереди и, в вариантах с телеметрией, сервисы телеметрии рабочего стенда; варианты `off`, `full`, `full-aa`, `head` (доля 0,1), `tail` (типовой tail sampling), `metrics` (30 с, `coarse`, отбор рядов), `balanced` × 3 повтора кругами, свежий стенд на прогон; открытая нагрузка `k6/telemetry.js` (окна 30 + 90 + 30 с) и редкие события: 500 вложения без объекта, недекодируемый JPEG, регистрация, медленные записи под блокировкой; выборка из Tempo, Loki и Prometheus (`telemetry_lookup.py`), сэмплер `cost`, размер volume; вариант не применён (записи о старте, слои) — отказ; `evidence/telemetry-cost/<метка>/` (`meta.json`, `runs.csv`, `components.csv`, `classes.csv`, `summary.md` с H1–H8 и B1–B5, SVG, `raw/`); `VARIANTS` — отладка. Рабочий стенд — `make stop`, гипотезы закоммичены раньше метки |
|
||||
| `make bench_telemetry_quick [VARIANTS=...]` | то же короче (~20 мин): шесть вариантов без `full-aa`, один повтор, окна 10 + 30 + 15 с, метка `quick-telemetry-<время>`, в git не идёт; калибровка до гипотез; шаг защиты «для 5» — `VARIANTS=off,full,tail` (~10 мин) |
|
||||
| `make bench_plots LABELS="..." [PLOTS=scaling]` | графики SVG и сводка серий трека 1 из меток: R* от числа реплик, p95 от интенсивности, CPU по компонентам, эффективность и точка насыщения — `evidence/plots/<PLOTS>/` |
|
||||
| `make bench_ab BEFORE=... AFTER=... REAPPLY=<commit> [SERIES=...]` | «до» и «после» одного изменения подряд (два прогона `bench`): `bench` для `BEFORE`, commit доказательств, `git revert` commit отката `REAPPLY`, `bench` для `AFTER`; с `SERIES` — серия трека 1 вместо матрицы (`make bench_scaling`). Нужно чистое рабочее дерево; сама делает два коммита |
|
||||
| `make bench_compare BEFORE=... AFTER=... [AA=...] [CHANGE=...]` | дельта двух меток `make bench` по ячейкам матрицы, у серий трека 1 — по общим конфигурациям (R*, задержки на фиксированных уровнях, CPU на запрос) и таблица PostgreSQL на R* и первой нарушившей ступени (CPU на запрос, новые сессии, соединения); `CHANGE` — change в шапке сравнения серий (по умолчанию `scaling-bench`); метки с разной методикой не сравнивает (в том числе метку без LB с меткой стенда на LB и серию с матрицей); с `AA` (метка того же кода, что `BEFORE`) отделяет эффект от шума. Результат в `evidence/compare/<до>__<после>.md` |
|
||||
@@ -618,7 +629,7 @@ src/
|
||||
relay/main.py # relay: свои engine, SqlAlchemyUnitOfWork и издатель, цикл проходов с паузами, отказ брокера и PostgreSQL не роняет, SIGTERM — текущий шаг и выход 0; replay — разовая команда реестра, коды 0/3/1/2 (без SDK); с change job-trace-propagation — телеметрия messenger-relay после disarm, instrument_engine, QueueSnapshots и observe_queue (снимок после успешного прохода не чаще 5 с, отказ PostgreSQL — пропуск), закрытие SDK в окне gather 0,5 с
|
||||
cleaner/__main__.py # python -m src.cleaner [--once]: early_stop.install("cleaner") до импорта → main(); неверные настройки — запись без значений и код 2
|
||||
cleaner/main.py # уборщик незавершённых загрузок: проверка grace > 2 × request_timeout + s3 timeout (иначе код 2), свой engine, SqlAlchemyUnitOfWork на сервис и клиент S3, цикл с интервалом и плановой сверкой (при старте и раз в [reconciler] interval_seconds), SIGTERM — довести текущий шаг и выйти 0, --once — коды 0/1/2; reconcile [--apply] [--max-changes N] [--strategy batch|head] [--deep] [--max-objects-per-second R] — разовая сверка, коды 0/3/1/2; плановая — batch, поверхностная, предел скорости из настроек
|
||||
config/settings.py # Settings (pydantic-settings), экземпляр settings; [app] instance_id (пусто → hostname) и keep_alive_seconds, [database] pool_size 10 и max_overflow 0 (постоянный пул без переполнения), idle_in_transaction_timeout_ms, [s3] адрес, bucket (валидатор имени), ключи API, регион, сроки, пул и endpoint_url, [idempotency] ttl_seconds, [uploads] max_concurrent 4, max_waiting 16, wait_timeout_seconds 5, body_timeout_seconds 30 (места загрузок процесса API), max_unfinished_jobs 250 (предел незавершённых заданий стенда; 0 — без него), [cleaner] interval_seconds 60, pending_grace_seconds 900, batch_size 100, [reconciler] interval_seconds 3600, page_size 1000, max_changes 100, max_objects_per_second 2000 (предел скорости сверки; 0 — без него)
|
||||
config/settings.py # Settings (pydantic-settings), экземпляр settings; [app] instance_id (пусто → hostname) и keep_alive_seconds, [database] pool_size 10 и max_overflow 0 (постоянный пул без переполнения), idle_in_transaction_timeout_ms, [s3] адрес, bucket (валидатор имени), ключи API, регион, сроки, пул и endpoint_url, [idempotency] ttl_seconds, [uploads] max_concurrent 4, max_waiting 16, wait_timeout_seconds 5, body_timeout_seconds 30 (места загрузок процесса API), max_unfinished_jobs 250 (предел незавершённых заданий стенда; 0 — без него), [cleaner] interval_seconds 60, pending_grace_seconds 900, batch_size 100, [reconciler] interval_seconds 3600, page_size 1000, max_changes 100, max_objects_per_second 2000 (предел скорости сверки; 0 — без него); [telemetry] enabled, otlp_endpoint, environment, trace_sample_ratio 1 (доля корней в голове, change track1-telemetry-cost), metric_buckets default|coarse, metric_export_interval_seconds 15 (≤ 30), очереди и сроки SDK
|
||||
api/
|
||||
routers/health.py # /health/live, /health/ready: вне версии, без идентификации
|
||||
routers/v1/<domain>.py # ручки под /api/v1, сборка в routers/v1/__init__.py; Idempotency-Key — параметр POST сообщения (message.py); attachment.py — один роутер с двумя префиксами: загрузка (тело через request.stream(), схема — openapi_extra, строгий UTF-8 filename по scope["query_string"]), метаданные, байты StreamingResponse
|
||||
@@ -649,7 +660,7 @@ src/
|
||||
infra/
|
||||
early_stop.py # ранний обработчик SIGTERM/SIGINT (только stdlib): до старта сервера — запись «Stopped <процесс> before startup» (API, cleaner) и выход 0; disarm() — первая строка lifespan; write_record — запись мимо structlog
|
||||
logger.py # structlog, get_logger(), contextvar-ы request_id / user_id, instance_id в каждой записи; с лабы 6 — хуки телеметрии (export_to_telemetry, add_trace_fields: trace_id и span_id активного span) в обеих цепочках и RateLimitFilter записей opentelemetry.* (одна в минуту на логгер); SDK не импортирует
|
||||
telemetry/ # change otel-telemetry и job-trace-propagation (telemetry.md): core.py — только opentelemetry-api: start (SDK загружает модуль sdk.py, ресурс из четырёх атрибутов), remove_otel_environment, begin_shutdown / wait_closed / shutdown (daemon-потоки и срок), child_span (правило корня, ошибка — класс без текста), server_span / finish_request (span SERVER и histogram http.server.request.duration), PROPAGATOR (W3C без baggage), current_trace_context, remote_context, Exporters (in-memory для тестов); sdk.py — единственный импорт SDK, экспортёра и requests: провайдеры только из [telemetry], ParentBased(ALWAYS_ON), cumulative, View границ трёх histogram, без exemplars и atexit, otlp_metric_reader / otlp_span_exporter / otlp_log_exporter; с change slo-alerts — сначала MeterProvider, затем процессоры и экспортёры span и журнала с ним внутри _internal_metrics (внутренние метрики SDK otel.sdk.*, переменная SDK только на время сборки), гистограммы SDK — DropAggregation; messaging.py — producer_span (PRODUCER publish <очередь> под сохранённым контекстом, заголовки), consumer_span (CONSUMER дочерний к контексту сообщения с link, без него — корень) и JobObservation (итог доставки: атрибуты, messenger.job.duration и time_to_ready); metrics.py — observe_pool (db.client.connection.* по текущему пулу engine), WorkerLoad / observe_worker, observe_queue (gauge по последнему снимку, старше 30 с — ничего); container.py — cgroup v2 (cpu.stat, memory.current, cpu.max, memory.max); db.py — instrument_engine (слушатели before/after_cursor_execute, handle_error, метрики пула), commit_span; logs.py — экспорт записи structlog в логгер SDK и trace_ids, install_log_hooks; setup.py — start_process_telemetry(<service.name>, cgroup_root=…): OTEL_* с warning, провайдеры, метрики контейнера (нет cgroup — одна запись), хуки
|
||||
telemetry/ # change otel-telemetry и job-trace-propagation (telemetry.md): core.py — только opentelemetry-api: start (SDK загружает модуль sdk.py, ресурс из четырёх атрибутов), remove_otel_environment, begin_shutdown / wait_closed / shutdown (daemon-потоки и срок), child_span (правило корня, ошибка — класс без текста), server_span / finish_request (span SERVER и histogram http.server.request.duration), PROPAGATOR (W3C без baggage), current_trace_context, remote_context, Exporters (in-memory для тестов); sdk.py — единственный импорт SDK, экспортёра и requests: провайдеры только из [telemetry], ParentBased(ALWAYS_ON), cumulative, View границ трёх histogram, без exemplars и atexit, otlp_metric_reader / otlp_span_exporter / otlp_log_exporter; с change slo-alerts — сначала MeterProvider, затем процессоры и экспортёры span и журнала с ним внутри _internal_metrics (внутренние метрики SDK otel.sdk.*, переменная SDK только на время сборки), гистограммы SDK — DropAggregation; messaging.py — producer_span (PRODUCER publish <очередь> под сохранённым контекстом, заголовки), consumer_span (CONSUMER дочерний к контексту сообщения с link, без него — корень) и JobObservation (итог доставки: атрибуты, messenger.job.duration и time_to_ready); metrics.py — observe_pool (db.client.connection.* по текущему пулу engine), WorkerLoad / observe_worker, observe_queue (gauge по последнему снимку, старше 30 с — ничего); container.py — cgroup v2 (cpu.stat, memory.current, cpu.max, memory.max); db.py — instrument_engine (слушатели before/after_cursor_execute, handle_error, метрики пула), commit_span; logs.py — экспорт записи structlog в логгер SDK и trace_ids, install_log_hooks; setup.py — start_process_telemetry(<service.name>, cgroup_root=…): OTEL_* с warning, провайдеры, метрики контейнера (нет cgroup — одна запись), хуки; с change track1-telemetry-cost — sdk.sampler (доля 1 — ParentBased(ALWAYS_ON), иначе ParentBased(TraceIdRatioBased)), границы по набору metric_buckets, TracerProvider с meter_provider и Tracer в окне внутренних метрик (otel.sdk.span.started; otel.sdk.span.live — DropAggregation), setup.startup_fields — поля телеметрии записи о старте API, worker и relay
|
||||
password.py # Argon2id в потоке со своим лимитом, фиктивный хэш для неизвестного username
|
||||
broker/client.py # aio-pika: JobPublisher relay (соединение лениво, publish_many с confirm и общим сроком, ready_messages, сброс после любой ошибки), JobConsumer worker (своё соединение, prefetch), JobDelivery, queue_name <база>.attachment.process.v1; с change job-trace-propagation — span producer и заголовки traceparent / tracestate в _publish_one, JobDelivery.trace_context из заголовков (trace_context_from_headers)
|
||||
render/client.py # ImageRenderer: процесс обработки на задание, окружение без секретов, срок и kill в finally, разбор вывода, коды в ImageRejected / RenderInterrupted; span render attachment variants (размер входа, исход, код выхода, пик)
|
||||
@@ -702,20 +713,24 @@ bench/ # нагрузочный стенд на HAProxy +
|
||||
run.py # оркестратор: стенд compose, реплики и готовность по LB, фоновые чаты и расписание наполнения, матрица, обслуживание БД, планы и варианты, пробы записи, backup и восстановление во второе хранилище со сверкой, фазы профиля failover (события цели — поток docker events по контейнеру, а не буфер демона), профиль rollout (образ прежнего commit через git archive, scripts/rolling-update.sh против проекта стенда, поток событий Docker с exec_start), ресурсы профилей failover и rollout (Profile.sample_resources: сэмплер scan, карта контейнеров по меткам compose, окна, бюджет на пике, сторож), серии трека 1 (профили scaling_*, ячейки на свежем стенде, ступени k6 и поиск R*, сэмплер, продолжение RESUME, блокировка bench/.bench.lock), метрики (сумма по репликам), runs.csv / phases.csv / searches.csv / samples.csv / summary.md / meta.json; профиль uploads (S3 и bootstrap на стенде, на прогон — новый volume S3 и реплика с окружением варианта через .work/variant.compose.yml, образ «до» — тег bench-from, сэмплер peak), в паспорте всех профилей stand.api_tcp_rmem и docker.kernel; профиль reconcile (S3 с портом метрик через .work/s3-metrics.compose.yml, наполнение \copy и загрузчиком, разовые проходы mtusi-bench-reconcile-<n> с лимитом CPU варианта, «до» — .work/cleaner-before.compose.yml, метрики шлюза и pg_stat_database до и после, блок H4 с k6 background.js, отказ по пределу S4)
|
||||
scaling.py # серии трека 1 без docker: лестница и автомат поиска R*, разбор итога k6 и строк сэмплера, агрегаты окна, вердикт SLO и брака генератора, признаки узкого места (THRESHOLDS), предельный CPU на запрос, сводка серии; --selftest
|
||||
plots.py # make bench_plots: SVG на stdlib (R* от числа реплик, p95 от интенсивности, CPU по компонентам) и сводка с точкой насыщения; render_series — графики в каталоге метки
|
||||
sampler.sh # сэмплер (только в контейнере mtusi-bench-sampler на образе PostgreSQL, --cgroupns host): режим list (серии) — cpu.stat, память и PSI заданных контейнеров, /proc/stat и PSI ВМ, статистика HAProxy, psql \watch по pg_stat_activity / database / wal / io; режим scan (failover, rollout) — обход cgroup всех контейнеров и /proc/stat, без сети, psql и LB; режим peak (uploads) — сброс memory.peak реплики, S3 и LB через свой дескриптор (perl), чтение пика в конце окна, выборка current / anon / sock / oom_kill раз в 0,2 с (--user 0, cgroupfs rw, без сети)
|
||||
sampler.sh # сэмплер (только в контейнере mtusi-bench-sampler на образе PostgreSQL, --cgroupns host): режим list (серии) — cpu.stat, память и PSI заданных контейнеров, /proc/stat и PSI ВМ, статистика HAProxy, psql \watch по pg_stat_activity / database / wal / io; режим scan (failover, rollout) — обход cgroup всех контейнеров и /proc/stat, без сети, psql и LB; режим peak (uploads) — сброс memory.peak реплики, S3 и LB через свой дескриптор (perl), чтение пика в конце окна, выборка current / anon / sock / oom_kill раз в 0,2 с (--user 0, cgroupfs rw, без сети); режим queue — scan с mp, mq и psql \watch заданий; режим cost (telemetry) — scan и строки mp, без сети
|
||||
uploads.py # профиль uploads без docker: тела PNG из шума от зерна, план кругами, разбор строк k6 и сэмплера peak, строка runs.csv, пометки oom / host_swap / peak_sampled / s3_down, summary.md (медиана и min–max по ячейкам, сценарии спеков, H1–H4); --selftest
|
||||
reconcile.py # профиль reconcile без docker (change track2-reconcile-cost): модель набора (id, содержимое и класс по номеру и зерну, строки CSV для \copy, ожидаемое по классам), план кругами, разбор записей уборщика, метрик шлюза S3, строк bg k6 и сэмплера, окна и r / a H4, passes.csv и windows.csv, вердикты H1–H4 и S4, summary.md и SVG (plots.Svg); --selftest
|
||||
overload.py # профиль queue без docker (change track1-queue-overload): план кругами, разбор строк q/qs/qv, jobs, mq, mp и журналов, жизни контейнера, строка cells.csv и timeline.csv, пометки, вердикты H1–H9, правило рекомендации, summary.md и SVG; --selftest
|
||||
make_images.py # файлы классов s, m, lj, lp профиля queue: только в контейнере mtusi-bench-images на образе стенда (Pillow образа, --network none), зерно из аргумента, JSON с размерами и SHA-256, больше лимита контракта — код 1
|
||||
make_images.py # файлы классов s, m, lj, lp профиля queue и bad профиля telemetry (s с 12 битами точности в SOF: 202, затем failed): только в контейнере mtusi-bench-images на образе стенда (Pillow образа, --network none), зерно из аргумента, JSON с размерами и SHA-256, больше лимита контракта — код 1
|
||||
telemetry_cost.py # профиль telemetry без docker (change track1-telemetry-cost): таблица вариантов и override прогона, план кругами, ожидание отправок, проверки слоя Collector (print-config) и копии Prometheus (построчно вне bench-lean), записи о старте и слои, разбор строк k6 t и сэмплера cost, компоненты, строки runs.csv / components.csv / classes.csv, потери по звеньям, пометки, правило шума, биномиальный интервал, вердикты H1–H8 и B1–B5, summary.md и четыре SVG; --selftest
|
||||
telemetry_lookup.py # выборка профиля telemetry: только в контейнере mtusi-bench-lookup на образе стенда (stdlib urllib, сеть mtusi-bench-telemetry); wait-ready и collect — трассы по request_id и цепочки загрузок (TraceQL), записи журнала и переход к трассе, счётчики Prometheus, status/tsdb и config, квантили buckets против журнала; результат, равный пределу, — отказ
|
||||
telemetry.compose.yml # второй -f при включённой телеметрии стенда: TELEMETRY__ENABLED true и адрес Collector у api, worker, relay
|
||||
otel/ # слои вариантов профиля telemetry (не infra/otel/): tail-typical.yaml и tail-balanced.yaml — второй --config Collector (только tail_sampling и процессоры pipeline трасс), prometheus-lean.yml — копия prometheus.yml с блоками # bench-lean (отбор собственных рядов хранилищ)
|
||||
queue.compose.yml # третий -f только профиля queue: плагин метрик брокера и статистика в секунду (bench/rabbitmq/), restart: unless-stopped у worker
|
||||
rabbitmq/ # enabled_plugins и 91-bench.conf профиля queue
|
||||
fill_objects.py # загрузчик объектов профиля reconcile: только в контейнере mtusi-bench-fill на образе стенда (botocore образа, bench/ на чтение, ключи API из окружения), процессы × потоки PUT по модели reconcile.py
|
||||
resources.py # ресурсы профилей failover и rollout без docker: интервалы контейнеров (сброс при новой cgroup, заморозка, новые контейнеры с момента запуска), окна, CPU / троттлинг / память по компонентам и ВМ, CPU на запрос в установившихся окнах, resources.csv / samples.csv, разделы summary.md; --selftest
|
||||
failover.py # профиль failover без docker: строки k6 о запросах, статистика и журнал HAProxy, события Docker, посекундная шкала, величины фазы, summary.md
|
||||
rollout.py # профиль rollout без docker: строки скрипта замены, события контейнеров проекта, состояния слотов LB (UP, drain, maint, ready), шаги по репликам, шкала со старыми и новыми ответами, окна до / во время / после, summary.md
|
||||
bench.compose.yml # override стенда mtusi-bench: имена, BENCH_API_REPLICAS реплик api без container_name, haproxy с лимитами BENCH_LB_*, лимиты BENCH_* (deploy.resources), без портов и config.toml, auto_explain; s3 (лимиты BENCH_S3_*, swap = память) запускают профили uploads и reconcile, cleaner (mtusi-bench-cleaner, без порта, лимиты BENCH_CLEANER_* без swap) — только разовыми проходами профиля reconcile; буфер приёма реплики — sysctls основного compose
|
||||
bench.compose.yml # override стенда mtusi-bench: имена, BENCH_API_REPLICAS реплик api без container_name, haproxy с лимитами BENCH_LB_*, лимиты BENCH_* (deploy.resources), без портов и config.toml, auto_explain; s3 (лимиты BENCH_S3_*, swap = память) запускают профили uploads и reconcile, cleaner (mtusi-bench-cleaner, без порта, лимиты BENCH_CLEANER_* без swap) — только разовыми проходами профиля reconcile; буфер приёма реплики — sysctls основного compose; с change track1-telemetry-cost — otel-collector, prometheus, loki, tempo (mtusi-bench-<сервис>, лимиты BENCH_COLLECTOR_* / _PROMETHEUS_* / _LOKI_* / _TEMPO_* без swap, сеть mtusi-bench-telemetry; запускают профиль telemetry и TELEMETRY=on), grafana без порта и не запускается
|
||||
bench.env # подстановки compose стенда вместо .env рабочего стенда (без паролей и секретов S3: их генерирует run.py)
|
||||
k6/ # сценарии k6 (через LB http://haproxy:8080): prepare (вход по Basic, фоновые чаты), prefill (по расписанию), cursors, plan_cursors (страницы плана фоновых чатов), explain, read, tail, write, after_backup и restore_check (этап восстановления), failover (постоянная интенсивность записи и чтения, строка на запрос) и retry (повтор неуспешных записей с тем же ключом), mixed (ступень серии трека 1: ramping-arrival-rate 70/20/10, тег окна, распределение по X-Instance-Id, досрочный выход), uploads (constant-vus загрузок тела из /work, пауза Retry-After на 429 и 1 с на прочие ошибки, строка на запрос, WARMUP — одна загрузка), background (профили reconcile и queue: constant-arrival-rate скачиваний, записи и чтения истории, строка bg на запрос, остановка SIGINT), queue (окна constant-arrival-rate загрузок, VU заранее, ответ не повторяется, строка q на загрузку; WARM — разогрев) и queue_sweep (метаданные каждого принятого вложения, SHA-256 выборки, строки qs и qv); lib.js — Bearer, messageHeaders (новый или заданный Idempotency-Key) и хелперы
|
||||
k6/ # сценарии k6 (через LB http://haproxy:8080): prepare (вход по Basic, фоновые чаты), prefill (по расписанию), cursors, plan_cursors (страницы плана фоновых чатов), explain, read, tail, write, after_backup и restore_check (этап восстановления), failover (постоянная интенсивность записи и чтения, строка на запрос) и retry (повтор неуспешных записей с тем же ключом), mixed (ступень серии трека 1: ramping-arrival-rate 70/20/10, тег окна, распределение по X-Instance-Id, досрочный выход), uploads (constant-vus загрузок тела из /work, пауза Retry-After на 429 и 1 с на прочие ошибки, строка на запрос, WARMUP — одна загрузка), background (профили reconcile и queue: constant-arrival-rate скачиваний, записи и чтения истории, строка bg на запрос, остановка SIGINT), queue (окна constant-arrival-rate загрузок, VU заранее, ответ не повторяется, строка q на загрузку; WARM — разогрев) и queue_sweep (метаданные каждого принятого вложения, SHA-256 выборки, строки qs и qv), telemetry (профиль цены телеметрии: девять классов constant-arrival-rate — чтение, запись, /users/me, карточка, скачивание, загрузка s и bad, вложение без объекта, регистрация; строка t с X-Request-Id на запрос); lib.js — Bearer, messageHeaders (новый или заданный Idempotency-Key) и хелперы
|
||||
compare.py # make bench_compare: дельта двух меток (ячейки матрицы или общие конфигурации серий), уровень шума, эффект или шум; отказ при разной методике, в том числе метке без LB и серии против матрицы
|
||||
ab.py # make bench_ab: прогоны «до» и «после» одного изменения подряд, с --series — серии трека 1
|
||||
migrations/, alembic.ini # ревизии alembic, async env.py; применяет одноразовый сервис compose; 739b8f04d5fb — частичный индекс pending CONCURRENTLY в autocommit_block; 5c3e1f0a9b7d — attachments.lost_at (NULL, SET LOCAL lock_timeout); c7e2f1a04b56 — attempt_base и attachment_job_replays; d3f9a6b2c1e7 — индексы outbox, аренды и очистки staging CONCURRENTLY; e4b8c2d17f90 — attachment_jobs.traceparent и tracestate (NULL, CHECK NOT VALID, SET LOCAL lock_timeout)
|
||||
@@ -766,6 +781,7 @@ evidence/bench/scaling-*/ # серии трека 1 (a, b, pool, A/A scaling-
|
||||
evidence/plots/scaling/ # make bench_plots по сериям a и b: графики SVG и summary.md (R*, эффективность, точка насыщения, цена запроса, память)
|
||||
evidence/plots/scaling-db/ # make bench_plots по серии db: R* по лимитам PostgreSQL и раздел «Насыщение PostgreSQL»
|
||||
evidence/queue/<метка>/ # результаты make bench_queue (change track1-queue-overload): meta.json (классы, план, окна, app_env по конфигурациям), cells.csv, timeline.csv, summary.md (H1–H9, рекомендация), SVG, raw/ — итоги k6
|
||||
evidence/telemetry-cost/<метка>/ # результаты make bench_telemetry (change track1-telemetry-cost): meta.json (варианты с SHA-256 слоёв, план, интенсивности, окна, блокировки, app_env по вариантам, stand и stand_telemetry, limits_by_mode), runs.csv, components.csv, classes.csv, summary.md (H1–H8, B1–B5), cpu-by-group.svg, latency-light.svg, ingest.svg, traces-by-class.svg, raw/ — итоги k6 и выборки
|
||||
evidence/uploads/ # change upload-memory: <метка>/ — make bench_uploads (meta.json, runs.csv, summary.md, raw/), lb-timeouts.md — driver.py lb-upload-timeouts, rollout-upload.md — медленная загрузка во время make rolling_update
|
||||
evidence/bench/unit-of-work-*/ # change unit-of-work, профиль quick с именной меткой (идёт в git): before и aa на b2fb88f, after на 6ba74b1
|
||||
evidence/rollout/unit-of-work*/ # change unit-of-work: unit-of-work (замена с Profile.rollout_from), unit-of-work-previous (--from b2fb88f: CPU на запрос старых и новых реплик)
|
||||
|
||||
@@ -385,39 +385,64 @@ bench_rollout_quick:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile rollout_quick --label quick-rollout-$(shell date -u +%Y%m%dT%H%M%SZ)
|
||||
|
||||
UPLOADS_LABEL ?= baseline
|
||||
# выключатель телеметрии профилей загрузок и очереди (лаба 6, design change
|
||||
# track1-telemetry-cost, решение 13): on — Collector, Prometheus, Loki и Tempo
|
||||
# рабочего стенда и SDK реплик, worker и relay; по умолчанию off — методика
|
||||
# прежняя. Режим — в паспорте и сводке, продолжение RESUME=1 — в том же режиме
|
||||
TELEMETRY ?= off
|
||||
|
||||
# уровень 4 лабы 4: память реплики при одновременных загрузках на стенде
|
||||
# mtusi-bench (HAProxy, одна реплика 1 CPU / 512 МБ без swap, S3 рабочего
|
||||
# стенда): варианты «до» (Profile.uploads_before), «без лимита» и «с
|
||||
# лимитом» × тела 1 и 10 MiB × 1/10/20/40 клиентов × 3 повтора, на каждый
|
||||
# прогон — новые S3 и реплика; пик памяти окна, OOM, ответы по кодам,
|
||||
# загрузок/с; ~50 мин; результат — evidence/uploads/$(UPLOADS_LABEL)/
|
||||
# загрузок/с; ~50 мин; результат — evidence/uploads/$(UPLOADS_LABEL)/.
|
||||
# TELEMETRY=on|off — выключатель телеметрии стенда
|
||||
.PHONY: bench_uploads
|
||||
bench_uploads:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile uploads --label $(UPLOADS_LABEL)
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile uploads --label $(UPLOADS_LABEL) --telemetry $(TELEMETRY)
|
||||
|
||||
# то же коротко (самопроверка): «без лимита» и «с лимитом», 10 MiB, 1/10/40
|
||||
# клиентов, один повтор, ~5 мин; в git не идёт
|
||||
.PHONY: bench_uploads_quick
|
||||
bench_uploads_quick:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile uploads_quick --label quick-uploads-$(shell date -u +%Y%m%dT%H%M%SZ)
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile uploads_quick --label quick-uploads-$(shell date -u +%Y%m%dT%H%M%SZ) --telemetry $(TELEMETRY)
|
||||
|
||||
# Очередь под перегрузкой (лаба 5, трек 1; design change track1-queue-overload):
|
||||
# стенд mtusi-bench с S3, брокером, relay, worker и уборщиком, настройки
|
||||
# конкуренции и prefetch × классы изображений × 3 повтора и блоки предела, приёма,
|
||||
# второго worker и рестартов, на каждую ячейку — свежий стенд; ~2 ч 10 мин;
|
||||
# результат — evidence/queue/$(QUEUE_LABEL)/. RESUME=1 — продолжить прерванную метку
|
||||
# на том же commit
|
||||
# на том же commit; TELEMETRY=on|off — выключатель телеметрии стенда
|
||||
QUEUE_LABEL ?= baseline
|
||||
.PHONY: bench_queue
|
||||
bench_queue:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile queue --label $(QUEUE_LABEL) $(if $(RESUME),--resume)
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile queue --label $(QUEUE_LABEL) $(if $(RESUME),--resume) --telemetry $(TELEMETRY)
|
||||
|
||||
# то же коротко (самопроверка, защита): две настройки, предел с пределом 40 и без
|
||||
# него, рестарт worker, второй worker, окна короче, ~11 мин; в git не идёт
|
||||
.PHONY: bench_queue_quick
|
||||
bench_queue_quick:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile queue_quick --label quick-queue-$(shell date -u +%Y%m%dT%H%M%SZ)
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile queue_quick --label quick-queue-$(shell date -u +%Y%m%dT%H%M%SZ) --telemetry $(TELEMETRY)
|
||||
|
||||
# Цена наблюдаемости (лаба 6, трек 1; design change track1-telemetry-cost):
|
||||
# стенд mtusi-bench профиля очереди и, в вариантах с телеметрией, Collector,
|
||||
# Prometheus, Loki и Tempo рабочего стенда; варианты off, full, full-aa, head,
|
||||
# tail, metrics, balanced × 3 повтора кругами, свежий стенд на прогон, одинаковая
|
||||
# открытая нагрузка и редкие события; ~1 ч 50 мин; результат —
|
||||
# evidence/telemetry-cost/$(TELEMETRY_LABEL)/. RESUME=1 — продолжить прерванную
|
||||
# метку на том же commit; VARIANTS=a,b — отладка (переопределение в паспорте)
|
||||
TELEMETRY_LABEL ?= baseline
|
||||
.PHONY: bench_telemetry
|
||||
bench_telemetry:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile telemetry --label $(TELEMETRY_LABEL) $(if $(RESUME),--resume) $(if $(VARIANTS),--variants $(VARIANTS))
|
||||
|
||||
# то же коротко (калибровка, защита «для 5»): все варианты, кроме копии A/A, по
|
||||
# одному разу, окна 10 + 30 + 15 с, ~20 мин; VARIANTS=off,full,tail — ~10 мин;
|
||||
# в git не идёт
|
||||
.PHONY: bench_telemetry_quick
|
||||
bench_telemetry_quick:
|
||||
$(KEEP_AWAKE) uv run python bench/run.py --profile telemetry_quick --label quick-telemetry-$(shell date -u +%Y%m%dT%H%M%SZ) $(if $(VARIANTS),--variants $(VARIANTS))
|
||||
|
||||
RECONCILE_LABEL ?= baseline
|
||||
|
||||
|
||||
@@ -443,6 +443,23 @@ Change `openspec/changes/track1-telemetry-cost/` (propose 2026-11-14). Номе
|
||||
- Результаты — `evidence/telemetry-cost/<метка>/` (12); правило «если `balanced` не прошёл критерии» — заранее, по параметру на
|
||||
нарушение, новая метка целиком (12).
|
||||
|
||||
### Решения apply
|
||||
|
||||
Подробно — design, «Уточнения apply» (номера в скобках); всё — до коммита гипотез, пороги не менялись.
|
||||
|
||||
- Регистрация на стенде — ~85 мс, а не 0,3–1 с (Argon2id параметров кода): редкий **быстрый** маршрут. Правила выбора трасс
|
||||
решают по span, поэтому полнота в B1, H3 и H5 (`tail`, `balanced`) требуется у 500, записей, **медленных по серверу**
|
||||
(`duration_ms` записи доступа ≥ 0,25 с; из медленных по клиенту 20 из 25 — медленные и по серверу) и цепочек `bad`; у
|
||||
регистраций — доля справочно (что теряет выбор после завершения трассы). Правила «редкий маршрут — всегда» в `balanced` нет:
|
||||
подгонка под внесённое событие. Дельты спеков `load-benchmark` (B1) и `observability` (сценарий) поправлены (1).
|
||||
- Запись о старте — `telemetry.startup_fields` у трёх процессов; `Tracer` собирает `sdk.build` в окне внутренних метрик (2, 3).
|
||||
- Стенд профиля — компоненты и лимиты профиля очереди без её `queue.compose.yml`; разогрев — `queue_warm` (4, 5).
|
||||
- `bad`: Pillow его не открывает и для размеров — размеры из SOF (6).
|
||||
- Лимиты и паспорт — по режиму телеметрии (`limits_by_mode`, `stand`, `stand_telemetry`) (7).
|
||||
- Счёт в метрике — значение в конце прогона; у регистраций в нём ещё пользователи `prepare.js` (8).
|
||||
- Выборка — пачки по 40 id, повтор на обрыв соединения и 5xx (Tempo под пулом запросов закрывал соединение) (9).
|
||||
- `plots.py` самопроверки не имеет — в 9.1 проверяются шесть модулей (11).
|
||||
|
||||
### Вопросы
|
||||
|
||||
Не блокируют работу; ответ меняет только указанное место.
|
||||
@@ -459,3 +476,11 @@ Change `openspec/changes/track1-telemetry-cost/` (propose 2026-11-14). Номе
|
||||
сбалансированной конфигурации на одной нагрузке ниже насыщения? Иначе — вторая интенсивность (ещё одна метка ~1 ч 50 мин).
|
||||
5. Преподавателю: «известное число» редких ошибок и медленных запросов внесено строкой вложения без объекта (500), недекодируемым
|
||||
JPEG (`failed`), регистрацией (Argon2id) и короткой блокировкой таблицы сообщений — допустимы ли такие управляемые воздействия?
|
||||
6. Пользователю (apply): регистрация оказалась быстрой (~85 мс), и `balanced` по своим правилам её не сохраняет полностью —
|
||||
критерий B1 переформулирован до гипотез («медленные по серверу» записи, регистрация справочно). Устраивает? Иначе — либо
|
||||
правило «редкий маршрут POST /api/v1/users — всегда» в `balanced` (ценой подгонки под событие), либо другой медленный редкий
|
||||
маршрут (его в API нет без искусственной задержки).
|
||||
7. Пользователю (apply): хост во время пробных прогонов выгружал память в swap (swap занят 10,7 из 11 ГиБ, ВМ 11,6 из 18 ГиБ ОЗУ;
|
||||
`host_swap` у каждого пробного прогона). Быстрые метки калибровки это не портит (они не результат), но метку `baseline`
|
||||
(~1 ч 50 мин) стоит снимать на освобождённом хосте (закрыть лишние приложения, остановить посторонние `domains-*`), иначе
|
||||
пометки `host_swap` и пересъёмка (`bench.md`, «Результаты»).
|
||||
|
||||
@@ -89,6 +89,8 @@ scratch.md` ещё снят на рабочем дереве поверх `9b35c
|
||||
| `OTEL_EXPORTER_OTLP_ENDPOINT` | `[telemetry] otlp_endpoint`; на стенде — `TELEMETRY__OTLP_ENDPOINT=http://otel-collector:4318` у `api`, `worker` и `relay` |
|
||||
| `OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf` | постоянно: установлен только экспортёр OTLP/HTTP protobuf |
|
||||
| `OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab` | `[telemetry] environment`; `service.*` вычисляет код |
|
||||
| `OTEL_TRACES_SAMPLER` | постоянно `parentbased_traceidratio`, при доле 1 — тот же объект, что `parentbased_always_on` (change `track1-telemetry-cost`, решение 3) |
|
||||
| `OTEL_TRACES_SAMPLER_ARG` | `[telemetry] trace_sample_ratio` (0…1, по умолчанию 1 — все трассы); набор границ histogram — `[telemetry] metric_buckets` (`default` / `coarse`) |
|
||||
|
||||
Переменные `OTEL_*` настройками не являются: процесс с включённой телеметрией удаляет их из
|
||||
окружения и пишет `warning` с именами (проверка — разовый контейнер с `OTEL_SDK_DISABLED=true` и
|
||||
@@ -505,6 +507,133 @@ Collector без времени начала (их закрывает прави
|
||||
`make test_isolated` (+2,25 CPU / 1792 МиБ) — 9472 МиБ: помещается с запасом ~2,4 ГиБ на накладные
|
||||
ВМ. CPU больше не дать: сумма лимитов CPU больше 12 — конкуренция, а не отказ.
|
||||
|
||||
## Цена наблюдаемости (трек 1)
|
||||
|
||||
Change `track1-telemetry-cost` (design — `openspec/changes/track1-telemetry-cost/design.md`, номера решений в скобках).
|
||||
Раздел записан **до метки**: гипотезы и критерии с порогами, методика и правила вывода фиксируются commit раньше
|
||||
`evidence/telemetry-cost/baseline/`; числа метки, вывод по каждой гипотезе, рекомендация и ограничения добавляются после неё
|
||||
из `summary.md` метки, не пересчитываются вручную. Команда: `make stop`, затем `make bench_telemetry` (~1 ч 50 мин); защита —
|
||||
`make bench_telemetry_quick VARIANTS=off,full,tail` (~10 мин).
|
||||
|
||||
### Методика
|
||||
|
||||
**Стенд** (1) — свой проект compose `mtusi-bench`, свежий на каждый прогон (`down -v`, хранилища телеметрии тоже начинают
|
||||
пустыми): HAProxy, две реплики API 1 CPU / 512 МиБ, PostgreSQL 2 / 1 ГиБ, Valkey 0,5 / 128 МиБ, S3 1 / 512 МиБ, брокер
|
||||
1 / 512 МиБ, relay 0,25 / 256 МиБ, worker 1 / 1 ГиБ, уборщик 0,25 / 256 МиБ — лимиты рабочего стенда, без swap; в вариантах с
|
||||
телеметрией — Collector 0,5 / 256 МиБ, Prometheus 0,5 / 384 МиБ, Loki 0,5 / 512 МиБ, Tempo 0,5 / 640 МиБ с образами и
|
||||
конфигурациями рабочего стенда (`infra/otel/`), Grafana не запускается (в пути данных её нет). Сумма лимитов на пике —
|
||||
11,25 CPU / 6912 МиБ при ВМ 12 CPU / 11 902 МиБ. Генератор k6 — в сети стенда, без лимита, через LB.
|
||||
|
||||
**Варианты** (2) — различаются только телеметрией:
|
||||
|
||||
| Вариант | SDK реплик, worker, relay | Collector | Prometheus | Проверяет |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| `off` | выключен, сервисов телеметрии нет | — | — | база |
|
||||
| `full` | все трассы, границы `default`, метрики раз в 15 с | `infra/otel/collector.yaml` | `infra/otel/prometheus/prometheus.yml` | рабочий стенд |
|
||||
| `full-aa` | = `full` | = `full` | = `full` | шум метода (A/A в той же метке) |
|
||||
| `head` | доля корней 0,1 (`[telemetry] trace_sample_ratio`) | = `full` | = `full` | выбор в голове (H2) |
|
||||
| `tail` | = `full` | + `bench/otel/tail-typical.yaml`: ошибки, трассы ≥ 0,25 с, 10 % остальных, ожидание 30 с | = `full` | типовой tail sampling (H3) |
|
||||
| `metrics` | метрики раз в 30 с, границы `coarse` | = `full` | `bench/otel/prometheus-lean.yml` (собственные ряды хранилищ — только приём, отказы, объём) | агрегация (H4) |
|
||||
| `balanced` | = `full` | + `bench/otel/tail-balanced.yaml` | `bench/otel/prometheus-lean.yml` | сбалансированная (H7) |
|
||||
|
||||
Слои Collector — второй `--config` (меняют только процессор `tail_sampling` и список процессоров pipeline трасс), копия
|
||||
Prometheus совпадает с рабочей вне размеченных блоков: до первого прогона это проверяют `validate` и `print-config` Collector,
|
||||
построчная сверка и `promtool` — иначе код 2. Каждый прогон проверяется применённым: записи «Started API / worker / relay»
|
||||
называют долю, набор границ и интервал варианта, выборка видит ряды `tail_sampling` и отбор рядов ровно у своих вариантов —
|
||||
иначе отказ команды. План — 7 вариантов × 3 повтора кругами с перестановкой от зерна, вариант подряд не повторяется.
|
||||
|
||||
**Нагрузка** (8) — открытая модель (`k6/telemetry.js`, `constant-arrival-rate`, VU заранее, ответ не повторяется), одинаковая
|
||||
во всех вариантах, ниже насыщения (калибровка до гипотез: в `full` реплика занята 30–60 % CPU, Collector, Tempo и worker —
|
||||
меньше 70 %, недосланных нет, p95 времени до `ready` < 5 с):
|
||||
|
||||
| Класс | Запрос | В секунду |
|
||||
| --- | --- | --- |
|
||||
| `read` | первая страница истории чата записи (50) | 110 |
|
||||
| `write` | сообщение с новым `Idempotency-Key` | 20 |
|
||||
| `me` | `GET /users/me` | 30 |
|
||||
| `card` | карточка чата (кэш Valkey) | 30 |
|
||||
| `download` | оригинал готового вложения | 10 |
|
||||
| `upload` | JPEG 1600 × 1200, 0,48 МиБ → `ready` (API → relay → worker) | 1 |
|
||||
| `upload_bad` | тот же JPEG с 12 битами точности в SOF: 202, затем `failed` `invalid_image` | 0,1 |
|
||||
| `broken` | оригинал вложения без объекта в S3 — 500 API | 0,2 |
|
||||
| `register` | регистрация (Argon2id) — редкий маршрут | 0,2 |
|
||||
|
||||
Окна — разогрев 30 с, **чистое окно 90 с (по нему считается цена)**, окно отказов 30 с: в нём трижды (на 5, 15 и 25 с) таблица
|
||||
сообщений блокируется `LOCK TABLE messages IN SHARE MODE` на 0,6 с в своей сессии PostgreSQL — запись ждёт, чтение идёт.
|
||||
|
||||
**Редкие события с известным счётом:** строка вложения `ready` без объекта (`\copy` в базу свежего стенда) — 500; JPEG,
|
||||
который проходит проверку структуры, но не декодируется, — неудачное задание без статуса ошибки span (исход, а не
|
||||
исключение); медленные записи под блокировкой — медленные запросы быстрого маршрута; регистрация — редкий маршрут: на стенде
|
||||
она быстрая (~85 мс, а не 0,3–1 с, как ожидалось), поэтому в критериях tail sampling она — справочный «редкий быстрый маршрут»,
|
||||
а «медленные записи» считаются **по серверу** (длительность записи доступа — та же величина, что server span, ≥ 0,25 с): правила
|
||||
выбора трасс видят span, а не ожидание клиента в LB (design, «Уточнения apply», п. 1).
|
||||
|
||||
**Источники измерений** (9): задержки и ошибки по классам — строки k6 чистого окна (истина клиента); CPU, троттлинг, память
|
||||
(наибольшая, `memory.peak`, `anon`) каждого контейнера — сэмплер cgroup (режим `cost`); CPU реплик на запрос — CPU реплик за
|
||||
чистое окно / ответов реплик в нём; время до `ready` — `updated_at` метаданных минус ответ 202; приём — метрики Collector
|
||||
(`otelcol_receiver_accepted_*`, `otelcol_exporter_sent_*`), Tempo и Loki (`*_distributor_*_received_total`), Prometheus
|
||||
(`prometheus_tsdb_head_series`, `…_samples_appended_total`) по краям чистого окна; рост на диске — `du` volume хранилищ в конце
|
||||
(за минуты прогона — журнал предзаписи, без сжатых блоков); потери по звеньям — внутренние метрики SDK (`otel.sdk.span.started`
|
||||
по решению выборки, `otel.sdk.processor.*.processed` и `otel.sdk.exporter.*.exported` с `error.type`) → Collector (отказ
|
||||
приёма, ошибки и отказы очереди экспорта, решения tail sampling, `dropped_too_early`) → хранилище; редкие события — поиск
|
||||
трассы по `span.messenger.request_id` (у загрузки — вся цепочка до consumer span итога), записи журнала по `request_id` и её
|
||||
`trace_id` → трасса, счёт в метрике; нормальные запросы — выборка 200 `GET /users/me`; точность квантилей — `histogram_quantile`
|
||||
по buckets маршрутов `read` и `write` за чистое окно против `quantile_over_time` той же длительности из журнала.
|
||||
Отброшенное выборкой потерей не считается.
|
||||
|
||||
**Правило шума** (12): для величины m шум — |медиана `full` − медиана `full-aa`|; изменение варианта — эффект, только если
|
||||
разбросы трёх повторов не пересекаются и |Δ медианы| больше шума; порог гипотезы проверяется только у эффекта, «в пределах
|
||||
шума» — когда эффекта нет. Доли редких событий — по сумме повторов, интервал — точный биномиальный 95 %. Вердикты — «подтверждено»,
|
||||
«нет», «нет данных».
|
||||
|
||||
### Гипотезы
|
||||
|
||||
| | Утверждение | «Подтверждено», если |
|
||||
| --- | --- | --- |
|
||||
| H1 | полная телеметрия дорога для реплик и хвоста | `full` против `off`: CPU реплик на запрос ≥ +10 % (эффект); p50 лёгких — не больше +1 мс; p99 лёгких ≥ +2 мс и его относительный рост больше роста p50 |
|
||||
| H2 | выбор в голове снимает большую часть цены приложения, но не журнал | `head`: надбавка CPU реплик на запрос против `off` ≤ половины надбавки `full`; приём Tempo ≤ 15 % `full`; доля трасс 500, медленных записей, регистраций и неудачных загрузок — в биномиальном интервале около 0,1; записи журнала — 100 %, счёт в метрике — не меньше клиента |
|
||||
| H3 | типовой tail экономит хранилище, но не приложение, и платит памятью Collector | `tail`: CPU реплик на запрос — в пределах шума от `full`; пик памяти Collector ≥ `full` + 15 МиБ, CPU Collector — не выше `full` больше чем на 20 %; приём Tempo ≤ 30 % `full`; трассы 500 и медленных по серверу записей и цепочки неудачных загрузок — 100 %; цепочки обычных загрузок ≥ 90 %; отказов `memory_limiter` и `dropped_too_early` нет |
|
||||
| H4 | агрегация почти не меняет CPU, но сокращает ряды; грубые границы теряют точность квантилей | `metrics`: рядов Prometheus ≤ 40 % `full`, отсчётов в секунду ≤ 40 %; CPU реплик и Collector — в пределах шума; ошибка p95 или p99 из buckets против журнала у `coarse` ≥ 2 × ошибки `default` хотя бы на одном из маршрутов `read`, `write` |
|
||||
| H5 | переход от журнала к трассе ломается вместе с выборкой | доля записей редких классов, чей `trace_id` ведёт на трассу: `full` — 100 %; `head` — в биномиальном интервале около 0,1; `tail` и `balanced` — 100 % у сохраняемых классов (500, медленные по серверу записи, неудачные загрузки) |
|
||||
| H6 | непреднамеренных потерь при этой нагрузке нет | во всех вариантах потери SDK и Collector — 0, `dropped_too_early` — 0; span SDK → Collector и Collector → Tempo сходятся с точностью 1 % (решения выбора — отдельно) |
|
||||
| H7 | сбалансированная конфигурация проходит B1–B5 | все пять критериев ниже |
|
||||
| H8 | самое дорогое хранилище — Tempo | у `full` CPU Tempo больше, чем Loki и Prometheus вместе, и его рост на диске больше их суммы; у `head`, `tail`, `balanced` CPU Tempo — не больше половины `full` |
|
||||
|
||||
### Сбалансированная конфигурация и критерии
|
||||
|
||||
`bench/otel/tail-balanced.yaml` + `bench/otel/prometheus-lean.yml` (5): SDK отправляет все трассы, Collector держит трассу до
|
||||
решения 10 с (цепочка загрузки ниже насыщения — до ~3 с), карта трасс 20 000 при ~300 новых в секунду, кэш решений — только
|
||||
сохранённых трасс (поздние span сохранённой трассы остаются с ней). Сохраняются: трассы со span `ERROR` (5xx, исключения,
|
||||
отказ хранилища); consumer span с неуспешным исходом задания (`failed`, `retry`, `error`, `requeued`, `dropped` — у `failed`
|
||||
статуса ошибки нет); server span ≥ 0,25 с (порог SLO на запрос, а не длительность трассы: у каждой асинхронной загрузки трасса
|
||||
длиннее 0,25 с) или consumer span ≥ 5 с; 10 % остальных. Prometheus забирает у Loki, Tempo и у себя только ряды приёма,
|
||||
отказов и объёма, `up` — всегда; ряды приложения и Collector — все. Журнал и метрики приложения не выбираются.
|
||||
|
||||
| | Критерий |
|
||||
| --- | --- |
|
||||
| B1 | сохранены трассы всех внесённых 500 API и всех медленных по серверу записей и цепочки всех неудачных загрузок (регистрации — доля справочно) |
|
||||
| B2 | приём Tempo не больше 25 % `full` и меньше, чем у `tail`; рядов Prometheus не больше 40 % `full` |
|
||||
| B3 | потерь нет, трассы не отброшены до решения, пик памяти Collector не больше двух третей лимита (170 из 256 МиБ) |
|
||||
| B4 | надбавка против `off`: CPU реплик на запрос не больше +25 %, p95 лёгких — не больше +3 мс, p99 — не больше +10 мс |
|
||||
| B5 | у сохраняемых классов каждая запись журнала с идентификатором трассы ведёт на трассу в Tempo |
|
||||
|
||||
**Если `balanced` не прошёл критерии** — правка задана заранее, по одному параметру на нарушение: B1 — `decision_wait` 20 с;
|
||||
B2 — `probabilistic` 5 %; B3 — `decision_wait` 5 с и `num_traces` 10 000; правка — новый commit и новая метка того же профиля
|
||||
целиком (`baseline-balanced2`), первая остаётся записью. B4 правилами Collector не лечится: тогда отчёт называет цену
|
||||
`balanced` в приложении равной `full` и рекомендует выбор в голове с долей из данных `head` для большей нагрузки — без
|
||||
пересъёмки. B5 следует из B1.
|
||||
|
||||
**Рабочий стенд остаётся со 100 % трасс** и полным набором рядов: проверки уровней 3–4 (`telemetry-check`, `trace-chain`,
|
||||
`alerts-check`) ищут свой запрос и задание по сохранённым наблюдениям; сбалансированная конфигурация — проверяемая
|
||||
рекомендация (вопрос пользователю — `QUESTIONS.md`, `## track1-telemetry-cost`, вопрос 1).
|
||||
|
||||
### Открытые вопросы преподавателю (трек 1)
|
||||
|
||||
1. Достаточно ли трёх настроек (выбор в голове 10 %, типовой tail sampling, агрегация метрик) и проверенной сбалансированной
|
||||
конфигурации на одной нагрузке ниже насыщения? Иначе — вторая интенсивность (ещё одна метка ~1 ч 50 мин).
|
||||
2. «Известное число» редких ошибок и медленных запросов внесено строкой вложения без объекта (500), недекодируемым JPEG
|
||||
(`failed`), регистрацией и короткой блокировкой таблицы сообщений — допустимы ли такие управляемые воздействия?
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
|
||||
@@ -177,7 +177,63 @@ services:
|
||||
memory: ${BENCH_LB_MEMORY:?run make bench}
|
||||
memswap_limit: ${BENCH_LB_MEMORY:?run make bench}
|
||||
|
||||
# сервисы телеметрии (design change track1-telemetry-cost, решения 1 и 13):
|
||||
# образы, конфигурации infra/otel/ и лимиты рабочего стенда (BENCH_* — поля
|
||||
# Profile, сверка с основным файлом до стенда), без swap, без перезапуска и
|
||||
# без портов. Запускают их только варианты профиля цены телеметрии и
|
||||
# выключатель TELEMETRY=on профилей загрузок и очереди: старт стенда
|
||||
# перечисляет сервисы. Grafana описана основным файлом и не запускается —
|
||||
# её порт сброшен, чтобы разбор стенда не занимал порт рабочего
|
||||
otel-collector:
|
||||
container_name: mtusi-bench-otel-collector
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: ${BENCH_COLLECTOR_CPUS:?run make bench}
|
||||
memory: ${BENCH_COLLECTOR_MEMORY:?run make bench}
|
||||
memswap_limit: ${BENCH_COLLECTOR_MEMORY:?run make bench}
|
||||
|
||||
prometheus:
|
||||
container_name: mtusi-bench-prometheus
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: ${BENCH_PROMETHEUS_CPUS:?run make bench}
|
||||
memory: ${BENCH_PROMETHEUS_MEMORY:?run make bench}
|
||||
memswap_limit: ${BENCH_PROMETHEUS_MEMORY:?run make bench}
|
||||
|
||||
loki:
|
||||
container_name: mtusi-bench-loki
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: ${BENCH_LOKI_CPUS:?run make bench}
|
||||
memory: ${BENCH_LOKI_MEMORY:?run make bench}
|
||||
memswap_limit: ${BENCH_LOKI_MEMORY:?run make bench}
|
||||
|
||||
tempo:
|
||||
container_name: mtusi-bench-tempo
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: ${BENCH_TEMPO_CPUS:?run make bench}
|
||||
memory: ${BENCH_TEMPO_MEMORY:?run make bench}
|
||||
memswap_limit: ${BENCH_TEMPO_MEMORY:?run make bench}
|
||||
|
||||
grafana:
|
||||
container_name: mtusi-bench-grafana
|
||||
restart: "no"
|
||||
ports: !reset []
|
||||
|
||||
networks:
|
||||
default:
|
||||
# k6 подключается к сети стенда по имени (docker run --network)
|
||||
name: mtusi-bench
|
||||
telemetry:
|
||||
# хранилища телеметрии; контейнер выборки (telemetry_lookup.py)
|
||||
# подключается к ней по имени
|
||||
name: mtusi-bench-telemetry
|
||||
|
||||
@@ -0,0 +1,229 @@
|
||||
// Профиль цены телеметрии (design change track1-telemetry-cost, решение 8):
|
||||
// одинаковая открытая нагрузка ниже насыщения через LB во всех вариантах.
|
||||
// Классы — сценарии constant-arrival-rate с одним startTime на всю длину
|
||||
// прогона (разогрев + чистое окно + окно отказов), timeUnit 10 с для дробной
|
||||
// интенсивности; деление на окна — по времени отправки от t0 (setup пишет
|
||||
// «t-t0,<мс>», часы ВМ). VU заранее и без прибавления, ответ не повторяется:
|
||||
// недосланные итерации — dropped_iterations. Строка на запрос в файл консоли:
|
||||
// «t,<класс>,<отправка мс>,<длительность мс>,<статус>,<X-Request-Id>,
|
||||
// <X-Instance-Id>,<id вложения|->». Входы оркестратора: fixture.json
|
||||
// (prepare.js), downloads.json (готовые вложения разогрева), broken.json (id
|
||||
// вложения без объекта), тела s.jpg и bad.jpg (make_images.py).
|
||||
// RATES — «класс:в секунду,…» (Profile.telemetry_rates)
|
||||
// DURATION — секунды всех окон
|
||||
// NAME — имя итога в raw/
|
||||
// Регистрация: пароль — crypto.randomUUID() только в памяти итерации, в строки,
|
||||
// итог и файлы не попадает; токен ответа не читается.
|
||||
import exec from "k6/execution";
|
||||
import http from "k6/http";
|
||||
import { SharedArray } from "k6/data";
|
||||
|
||||
import {
|
||||
API,
|
||||
PAGE_LIMIT,
|
||||
SUMMARY_THRESHOLDS,
|
||||
SUMMARY_TREND_STATS,
|
||||
WORK_DIR,
|
||||
authHeaders,
|
||||
messageHeaders,
|
||||
summaryFiles,
|
||||
syntheticText,
|
||||
} from "./lib.js";
|
||||
|
||||
const fixture = JSON.parse(open(`${WORK_DIR}/fixture.json`));
|
||||
const downloads = new SharedArray(
|
||||
"downloads",
|
||||
() => JSON.parse(open(`${WORK_DIR}/downloads.json`)),
|
||||
);
|
||||
const BROKEN = JSON.parse(open(`${WORK_DIR}/broken.json`));
|
||||
const GOOD_BODY = open(`${WORK_DIR}/s.jpg`, "b");
|
||||
const BAD_BODY = open(`${WORK_DIR}/bad.jpg`, "b");
|
||||
const DURATION = Number(__ENV.DURATION);
|
||||
const RATES = Object.fromEntries(
|
||||
(__ENV.RATES || "")
|
||||
.split(",")
|
||||
.filter((item) => item !== "")
|
||||
.map((item) => {
|
||||
const [name, rate] = item.split(":");
|
||||
return [name, Number(rate)];
|
||||
}),
|
||||
);
|
||||
// больше timeout server LB (10 с, у загрузки 30 с): клиент видит ответ LB
|
||||
const TIMEOUT = "40s";
|
||||
const READER = authHeaders(fixture.tokens[fixture.readerId]);
|
||||
const WRITE_URL = `${API}/chats/${fixture.writeChatId}/messages`;
|
||||
const UPLOAD_URL = `${API}/chats/${fixture.readChatId}/attachments`;
|
||||
|
||||
// VU заранее: интенсивность × запас на медленные ответы (запись под
|
||||
// блокировкой до 0,6 с, регистрация с Argon2id до 1 с) + постоянная часть
|
||||
function vus(rate) {
|
||||
return Math.max(4, Math.ceil(rate * 2) + 4);
|
||||
}
|
||||
|
||||
function scenarios() {
|
||||
const out = {};
|
||||
for (const [name, rate] of Object.entries(RATES)) {
|
||||
if (!(rate > 0)) {
|
||||
continue;
|
||||
}
|
||||
out[name] = {
|
||||
executor: "constant-arrival-rate",
|
||||
exec: name,
|
||||
rate: Math.max(1, Math.round(rate * 10)),
|
||||
timeUnit: "10s",
|
||||
startTime: "0s",
|
||||
duration: `${DURATION}s`,
|
||||
preAllocatedVUs: vus(rate),
|
||||
maxVUs: vus(rate),
|
||||
gracefulStop: "45s",
|
||||
};
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
const iterationThresholds = Object.fromEntries(
|
||||
Object.keys(RATES).map((name) => [
|
||||
`iterations{scenario:${name}}`,
|
||||
["count>=0"],
|
||||
]),
|
||||
);
|
||||
|
||||
export const options = {
|
||||
scenarios: scenarios(),
|
||||
summaryTrendStats: SUMMARY_TREND_STATS,
|
||||
// пороги всегда выполняются: итерации по сценариям и недосланные попадают
|
||||
// в итог, run.py сверяет с ними число строк
|
||||
thresholds: {
|
||||
...SUMMARY_THRESHOLDS,
|
||||
...iterationThresholds,
|
||||
iterations: ["count>=0"],
|
||||
dropped_iterations: ["count>=0"],
|
||||
},
|
||||
};
|
||||
|
||||
export function setup() {
|
||||
const t0 = Date.now();
|
||||
console.log(`t-t0,${t0}`);
|
||||
return { t0 };
|
||||
}
|
||||
|
||||
// длительность — монотонные тайминги k6 с точностью 0,01 мс, без ответа —
|
||||
// разность часов
|
||||
function report(kind, start, res, id = "-") {
|
||||
const t = res.timings;
|
||||
const measured = t.blocked + t.connecting + t.tls_handshaking + t.duration;
|
||||
const duration = Math.max(
|
||||
0,
|
||||
Math.round((res.status === 0 ? Date.now() - start : measured) * 100) / 100,
|
||||
);
|
||||
const requestId = res.headers["X-Request-Id"] || "-";
|
||||
const instance = res.headers["X-Instance-Id"] || "-";
|
||||
console.log(
|
||||
`t,${kind},${start},${duration},${res.status},${requestId},${instance},` +
|
||||
`${id}`,
|
||||
);
|
||||
}
|
||||
|
||||
function get(kind, url, expected) {
|
||||
const start = Date.now();
|
||||
const res = http.get(url, {
|
||||
headers: READER,
|
||||
responseType: "none",
|
||||
timeout: TIMEOUT,
|
||||
responseCallback: http.expectedStatuses(expected),
|
||||
});
|
||||
report(kind, start, res);
|
||||
}
|
||||
|
||||
export function read() {
|
||||
get("read", `${WRITE_URL}?limit=${PAGE_LIMIT}`, 200);
|
||||
}
|
||||
|
||||
export function me() {
|
||||
get("me", `${API}/users/me`, 200);
|
||||
}
|
||||
|
||||
export function card() {
|
||||
get("card", `${API}/chats/${fixture.writeChatId}`, 200);
|
||||
}
|
||||
|
||||
export function download() {
|
||||
const id = downloads[exec.scenario.iterationInTest % downloads.length];
|
||||
get("download", `${API}/attachments/${id}/content`, 200);
|
||||
}
|
||||
|
||||
// вложение без объекта: 500 AttachmentContentMissing — ожидаемый ответ класса
|
||||
export function broken() {
|
||||
get("broken", `${API}/attachments/${BROKEN}/content`, 500);
|
||||
}
|
||||
|
||||
export function write() {
|
||||
const n = exec.scenario.iterationInTest;
|
||||
const sender = fixture.memberIds[n % fixture.memberIds.length];
|
||||
const start = Date.now();
|
||||
const res = http.post(
|
||||
WRITE_URL,
|
||||
JSON.stringify({ text: syntheticText("tc", n) }),
|
||||
{
|
||||
headers: messageHeaders(fixture.tokens[sender]),
|
||||
responseType: "none",
|
||||
timeout: TIMEOUT,
|
||||
responseCallback: http.expectedStatuses(201),
|
||||
},
|
||||
);
|
||||
report("write", start, res);
|
||||
}
|
||||
|
||||
function postUpload(kind, body) {
|
||||
const start = Date.now();
|
||||
const res = http.post(`${UPLOAD_URL}?filename=bench`, body, {
|
||||
headers: {
|
||||
Authorization: `Bearer ${fixture.tokens[fixture.readerId]}`,
|
||||
"Content-Type": "image/jpeg",
|
||||
},
|
||||
timeout: TIMEOUT,
|
||||
responseCallback: http.expectedStatuses(202),
|
||||
});
|
||||
let id = "-";
|
||||
if (res.status === 202) {
|
||||
id = res.json("id");
|
||||
}
|
||||
report(kind, start, res, id);
|
||||
}
|
||||
|
||||
// имя сценария — имя класса и экспортируемой функции (exec)
|
||||
export function upload() {
|
||||
postUpload("upload", GOOD_BODY);
|
||||
}
|
||||
|
||||
export function upload_bad() {
|
||||
postUpload("upload_bad", BAD_BODY);
|
||||
}
|
||||
|
||||
// регистрация — редкий медленный маршрут (Argon2id): имя из UUID без
|
||||
// дефисов (шаблон контракта ^[a-z0-9_]{3,32}$), пароль сразу выбрасывается
|
||||
export function register() {
|
||||
const name = `t${crypto.randomUUID().split("-").join("").slice(0, 30)}`;
|
||||
const start = Date.now();
|
||||
const res = http.post(
|
||||
`${API}/users`,
|
||||
JSON.stringify({
|
||||
username: name,
|
||||
display_name: "Bench telemetry",
|
||||
password: crypto.randomUUID(),
|
||||
}),
|
||||
{
|
||||
headers: { "Content-Type": "application/json" },
|
||||
responseType: "none",
|
||||
timeout: TIMEOUT,
|
||||
responseCallback: http.expectedStatuses(201),
|
||||
},
|
||||
);
|
||||
report("register", start, res);
|
||||
}
|
||||
|
||||
export function handleSummary(data) {
|
||||
// t0 — в строке t-t0, итог без данных setup
|
||||
delete data.setup_data;
|
||||
return summaryFiles(data);
|
||||
}
|
||||
+31
-4
@@ -1,5 +1,6 @@
|
||||
"""Файлы классов профиля очереди (design change `track1-queue-overload`,
|
||||
решение 5): `s`, `m`, `lj`, `lp`, детерминированно от зерна.
|
||||
решение 5): `s`, `m`, `lj`, `lp`, детерминированно от зерна; класс `bad` —
|
||||
профиль цены телеметрии (design change `track1-telemetry-cost`, решение 8).
|
||||
|
||||
Только в контейнере `mtusi-bench-images` на образе стенда: Pillow образа и та же
|
||||
его версия, что у процесса обработки; `src` не импортируется. На stdout — JSON с
|
||||
@@ -15,7 +16,7 @@ import random
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
from PIL import Image, ImageChops
|
||||
from PIL import Image, ImageChops, UnidentifiedImageError
|
||||
from uploads import png_noise
|
||||
|
||||
MAX_BYTES = 10_485_760
|
||||
@@ -29,6 +30,8 @@ FINE_DIVISOR = 6
|
||||
TILE = 512
|
||||
AMPLITUDE = 24
|
||||
POSTERIZE_MASK = 0xF0
|
||||
# точность в SOF, которую Pillow не декодирует
|
||||
PRECISION_12 = 12
|
||||
|
||||
|
||||
def noise_l(width: int, height: int, seed: int) -> Image.Image:
|
||||
@@ -125,11 +128,36 @@ def build_m(seed: int) -> bytes:
|
||||
return png_noise(NOISE_HEIGHT, seed + NOISE_HEIGHT)
|
||||
|
||||
|
||||
def build_bad(seed: int) -> bytes:
|
||||
"""Класс `bad` профиля цены телеметрии (design change
|
||||
`track1-telemetry-cost`, решение 8): байты `s` с 12 битами точности в
|
||||
SOF — структура верна (202), Pillow не декодирует (`failed`,
|
||||
`invalid_image`), как `images.jpeg_precision_12()` тестов."""
|
||||
data = bytearray(build_s(seed))
|
||||
sof = data.index(b"\xff\xc0")
|
||||
data[sof + 4] = PRECISION_12
|
||||
return bytes(data)
|
||||
|
||||
|
||||
def image_size(data: bytes) -> tuple[int, int]:
|
||||
"""Ширина и высота: Pillow, а у `bad`, который Pillow не открывает, —
|
||||
поля SOF (высота и ширина после точности)."""
|
||||
try:
|
||||
with Image.open(io.BytesIO(data)) as image:
|
||||
return image.size
|
||||
except UnidentifiedImageError:
|
||||
sof = data.index(b"\xff\xc0")
|
||||
height = int.from_bytes(data[sof + 5 : sof + 7], "big")
|
||||
width = int.from_bytes(data[sof + 7 : sof + 9], "big")
|
||||
return width, height
|
||||
|
||||
|
||||
BUILDERS = {
|
||||
"s": (build_s, "s.jpg", "image/jpeg"),
|
||||
"m": (build_m, "m.png", "image/png"),
|
||||
"lj": (build_lj, "lj.jpg", "image/jpeg"),
|
||||
"lp": (build_lp, "lp.png", "image/png"),
|
||||
"bad": (build_bad, "bad.jpg", "image/jpeg"),
|
||||
}
|
||||
|
||||
|
||||
@@ -139,8 +167,7 @@ def main() -> int:
|
||||
code = 0
|
||||
for name, (build, filename, media) in BUILDERS.items():
|
||||
data = build(seed)
|
||||
with Image.open(io.BytesIO(data)) as image:
|
||||
width, height = image.size
|
||||
width, height = image_size(data)
|
||||
(directory / filename).write_bytes(data)
|
||||
report[name] = {
|
||||
"file": filename,
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
# bench-lean: begin
|
||||
# Конфигурация Prometheus вариантов `metrics` и `balanced` профиля цены
|
||||
# телеметрии (design change track1-telemetry-cost, решение 7): копия
|
||||
# infra/otel/prometheus/prometheus.yml плюс размеченные блоки отбора рядов у
|
||||
# целей loki, tempo и prometheus. Prometheus конфигурации не сливает, поэтому
|
||||
# копия; вне строк `bench-lean` файл обязан совпадать с рабочим построчно —
|
||||
# это проверяют run.py до стенда и `telemetry_cost.py --selftest`. Остаются
|
||||
# ряды приёма, отказов и объёма хранения (их же читает профиль) и `up`
|
||||
# (синтетический, отбор его не касается); ряды приложения и Collector — все.
|
||||
# Рабочий стенд забирает все ряды (решение 5).
|
||||
# bench-lean: end
|
||||
# Prometheus v3.15.1 — хранилище метрик (design change otel-telemetry,
|
||||
# решения 3 и 15). Метрики приложения — scrape экспортёра prometheus
|
||||
# Collector (honor_labels: job = service.name, instance = service.instance.id
|
||||
# из OTLP; там же метрики LB с job = haproxy), плюс собственные метрики
|
||||
# Collector, Loki, Tempo и самого Prometheus: по ним видно, жив ли конвейер.
|
||||
# Срок и предел объёма хранения, путь данных и время начала рядов — флаги
|
||||
# команды в docker-compose.yml. Приёмников remote write и OTLP, admin API и
|
||||
# lifecycle нет; порт не публикуется. Правила записи и оповещения — rules.yml
|
||||
# (design change slo-alerts, решения 1, 3, 4, 9); блока alerting нет:
|
||||
# доставки наружу нет, состояние firing / resolved — API правил, ряды ALERTS и
|
||||
# Grafana.
|
||||
global:
|
||||
scrape_interval: 15s
|
||||
scrape_timeout: 10s
|
||||
evaluation_interval: 15s
|
||||
# явно прежний текстовый список Prometheus 3 по умолчанию: флаг
|
||||
# created-timestamp-zero-ingestion иначе переводит на protobuf все цели, а
|
||||
# время начала нужно только экспортёру Collector (решение 6)
|
||||
scrape_protocols:
|
||||
- OpenMetricsText1.0.0
|
||||
- OpenMetricsText0.0.1
|
||||
- PrometheusText1.0.0
|
||||
- PrometheusText0.0.4
|
||||
|
||||
rule_files:
|
||||
- /etc/prometheus/rules.yml
|
||||
|
||||
scrape_configs:
|
||||
# метрики API, worker и relay, пришедшие в Collector по OTLP, и метрики LB
|
||||
# с приёмника prometheus/haproxy. Protobuf первым: время начала
|
||||
# cumulative-ряда экспортёр Collector отдаёт только в нём, и Prometheus
|
||||
# пишет ноль в момент старта нового процесса (решение 6)
|
||||
- job_name: otel-collector-exporter
|
||||
honor_labels: true
|
||||
scrape_protocols:
|
||||
- PrometheusProto
|
||||
- OpenMetricsText1.0.0
|
||||
- PrometheusText0.0.4
|
||||
static_configs:
|
||||
- targets: ["otel-collector:8889"]
|
||||
- job_name: otel-collector
|
||||
static_configs:
|
||||
- targets: ["otel-collector:8888"]
|
||||
- job_name: loki
|
||||
static_configs:
|
||||
- targets: ["loki:3100"]
|
||||
# bench-lean: begin
|
||||
# приём (байты, строки, структурированные метаданные), объём чанков,
|
||||
# отказы записи и отброшенное
|
||||
metric_relabel_configs:
|
||||
- source_labels: [__name__]
|
||||
action: keep
|
||||
regex: loki_distributor_(bytes|lines|structured_metadata_bytes)_received_total|loki_ingester_chunk_stored_bytes_total|loki_ingester_(chunks_flush_failures|wal_disk_full_failures)_total|loki_discarded_.*
|
||||
# bench-lean: end
|
||||
- job_name: tempo
|
||||
static_configs:
|
||||
- targets: ["tempo:3200"]
|
||||
# bench-lean: begin
|
||||
# приём (байты, span), приём live-store, его отказы и отброшенные span
|
||||
metric_relabel_configs:
|
||||
- source_labels: [__name__]
|
||||
action: keep
|
||||
regex: tempo_distributor_(bytes|spans)_received_total|tempo_live_store_bytes_received_total|tempo_live_store_.*failed.*|tempo_discarded_spans_total
|
||||
# bench-lean: end
|
||||
- job_name: prometheus
|
||||
static_configs:
|
||||
- targets: ["127.0.0.1:9090"]
|
||||
# bench-lean: begin
|
||||
# ряды и отсчёты головы, отказы правил, компакций и журнала предзаписи
|
||||
metric_relabel_configs:
|
||||
- source_labels: [__name__]
|
||||
action: keep
|
||||
regex: prometheus_tsdb_head_(series|samples_appended_total)|prometheus_rule_evaluation_failures_total|prometheus_tsdb_(compactions_failed|wal_corruptions)_total
|
||||
# bench-lean: end
|
||||
@@ -0,0 +1,59 @@
|
||||
# Слой Collector варианта `balanced` профиля цены телеметрии — предложенная
|
||||
# сбалансированная конфигурация (design change track1-telemetry-cost,
|
||||
# решение 5; спек observability, «Сбалансированная конфигурация телеметрии»).
|
||||
# SDK отправляет все трассы, решение — после завершения трассы, по правилам
|
||||
# этой системы; журнал и метрики не выбираются. Вместе с ним —
|
||||
# bench/otel/prometheus-lean.yml. Рабочий стенд остаётся со всеми трассами.
|
||||
#
|
||||
# Запуск — вторым `--config` после infra/otel/collector.yaml; слой меняет
|
||||
# только процессор выбора трасс и список процессоров pipeline трасс
|
||||
# (проверка run.py до стенда, решение 6). Если метка не подтвердит B1–B3,
|
||||
# правило правки — design, решение 12: один параметр на нарушение.
|
||||
processors:
|
||||
tail_sampling:
|
||||
# цепочка загрузки ниже насыщения — до ~3 с (relay раз в 0,25 с,
|
||||
# обработка 0,3–1 с, пакет SDK 1 с): запас втрое; память Collector
|
||||
# пропорциональна сроку
|
||||
decision_wait: 10s
|
||||
# ~250 трасс/с × 10 с = 2500: восьмикратный запас без роста карт
|
||||
num_traces: 20000
|
||||
expected_new_traces_per_sec: 300
|
||||
# поздние span сохранённой трассы (повтор, replay) остаются с ней;
|
||||
# поздние span несохранённой — заново через правила: ошибка worker после
|
||||
# решения по API сохраняется хотя бы частичной трассой
|
||||
decision_cache:
|
||||
sampled_cache_size: 100000
|
||||
non_sampled_cache_size: 0
|
||||
policies:
|
||||
# 5xx API, исключения, отказ хранилища в span
|
||||
- name: errors
|
||||
type: status_code
|
||||
status_code:
|
||||
status_codes: [ERROR]
|
||||
# неуспешный исход задания: у `failed` нет статуса ошибки span (исход, а
|
||||
# не исключение, otel-telemetry OT-11)
|
||||
- name: job-outcome
|
||||
type: string_attribute
|
||||
string_attribute:
|
||||
key: messenger.job.outcome
|
||||
values: [failed, retry, error, requeued, dropped]
|
||||
# порог SLO на запрос, а не на трассу: длительность трассы загрузки
|
||||
# больше 0,25 с у каждой загрузки; 5 с — больше пути обработки без
|
||||
# повторов (0,3–1 с)
|
||||
- name: slow-spans
|
||||
type: ottl_condition
|
||||
ottl_condition:
|
||||
error_mode: ignore
|
||||
span:
|
||||
- kind == SPAN_KIND_SERVER and end_time_unix_nano - start_time_unix_nano >= 250000000
|
||||
- kind == SPAN_KIND_CONSUMER and end_time_unix_nano - start_time_unix_nano >= 5000000000
|
||||
# остальные трассы — как вариант `head`
|
||||
- name: rest
|
||||
type: probabilistic
|
||||
probabilistic:
|
||||
sampling_percentage: 10
|
||||
|
||||
service:
|
||||
pipelines:
|
||||
traces:
|
||||
processors: [memory_limiter, tail_sampling, batch]
|
||||
@@ -0,0 +1,33 @@
|
||||
# Слой Collector варианта `tail` профиля цены телеметрии (design change
|
||||
# track1-telemetry-cost, решения 2 и 6): типовой tail sampling, каким его
|
||||
# включают по документации, — трассы со span в статусе ошибки, трассы не
|
||||
# короче 0,25 с (граница SLO задержки, slo-alerts SA-1) и 10 % остальных.
|
||||
# Остальное по умолчанию: decision_wait 30 с, num_traces 50 000, кэшей решений
|
||||
# нет. Только для стенда bench/: рабочий стенд — со всеми трассами (решение 5).
|
||||
#
|
||||
# Запуск — вторым `--config` после infra/otel/collector.yaml: карты сливаются,
|
||||
# списки заменяются. Слой меняет только процессор выбора трасс и список
|
||||
# процессоров pipeline трасс; это проверяет run.py до стенда (validate и
|
||||
# сравнение print-config со слоем и без него, решение 6).
|
||||
processors:
|
||||
tail_sampling:
|
||||
policies:
|
||||
- name: errors
|
||||
type: status_code
|
||||
status_code:
|
||||
status_codes: [ERROR]
|
||||
# длительность трассы целиком: у асинхронной цепочки загрузки
|
||||
# (API → relay → worker) она больше 0,25 с всегда
|
||||
- name: slow-traces
|
||||
type: latency
|
||||
latency:
|
||||
threshold_ms: 250
|
||||
- name: rest
|
||||
type: probabilistic
|
||||
probabilistic:
|
||||
sampling_percentage: 10
|
||||
|
||||
service:
|
||||
pipelines:
|
||||
traces:
|
||||
processors: [memory_limiter, tail_sampling, batch]
|
||||
@@ -33,6 +33,9 @@ ROLES = (
|
||||
"cleaner",
|
||||
"haproxy",
|
||||
)
|
||||
# сервисы телеметрии стенда при выключателе TELEMETRY=on (design change
|
||||
# track1-telemetry-cost, решение 13)
|
||||
TELEMETRY_ROLES = ("otel-collector", "prometheus", "loki", "tempo")
|
||||
# условие H6, записанное до метки: состав не меняется
|
||||
H6_FLAGS = ("lost", "stuck", "duplicate", "sha_mismatch")
|
||||
# пометки, при которых метка не зелёная: система потеряла работу (решение 11) или
|
||||
@@ -177,6 +180,14 @@ CELL_FIELDS = [
|
||||
"worker_exit_codes",
|
||||
"worker_oom_events",
|
||||
"lb_up_min",
|
||||
# выключатель телеметрии (design change track1-telemetry-cost, решение
|
||||
# 13): CPU и троттлинг окна over и пик памяти сервисов телеметрии; без
|
||||
# телеметрии — пусто
|
||||
*[
|
||||
f"tel_{role.replace('-', '_')}_{key}"
|
||||
for role in TELEMETRY_ROLES
|
||||
for key in ("cpu_over", "throttle_over", "peak_mib")
|
||||
],
|
||||
]
|
||||
TIMELINE_FIELDS = [
|
||||
"cell",
|
||||
@@ -983,6 +994,20 @@ def cell_row(cell: Mapping[str, Any], src: Sources) -> dict[str, Any]:
|
||||
sum(1 for i in both_ready if done_at(i) > recovery_end),
|
||||
)
|
||||
row.update(control_columns(src.control, bounds))
|
||||
for role in TELEMETRY_ROLES:
|
||||
lives = src.cg.get(role, [])
|
||||
prefix = f"tel_{role.replace('-', '_')}"
|
||||
flat = [life for each in lives for life in each]
|
||||
peaks = [p[1] for each in src.mp.get(role, []) for p in each]
|
||||
row[f"{prefix}_cpu_over"] = (
|
||||
role_cores(lives, over_start, over_end) if lives else None
|
||||
)
|
||||
row[f"{prefix}_throttle_over"] = (
|
||||
throttle_share(flat, over_start, over_end) if flat else None
|
||||
)
|
||||
row[f"{prefix}_peak_mib"] = (
|
||||
round(max(peaks) / 2**20, 1) if peaks else None
|
||||
)
|
||||
row["flags"] = " ".join(
|
||||
cell_flags(row, zero_at is None, src.storage_down),
|
||||
)
|
||||
@@ -1854,6 +1879,29 @@ def block_table(rows: list[Mapping[str, Any]]) -> list[str]:
|
||||
return lines
|
||||
|
||||
|
||||
def telemetry_line(meta: Mapping[str, Any]) -> str:
|
||||
"""Режим телеметрии метки (design change `track1-telemetry-cost`, решение
|
||||
13) и предупреждение о сумме лимитов CPU больше ВМ."""
|
||||
mode = meta.get("profile", {}).get("telemetry") or "off"
|
||||
if mode != "on":
|
||||
return (
|
||||
"Телеметрия стенда выключена (TELEMETRY=off): SDK реплик, worker и "
|
||||
"relay выключен, сервисов телеметрии нет."
|
||||
)
|
||||
budget = meta.get("resources", {}).get("budget", {})
|
||||
text = (
|
||||
"Телеметрия стенда включена (TELEMETRY=on): SDK реплик, worker и relay "
|
||||
"с настройками рабочего стенда, Collector, Prometheus, Loki и Tempo "
|
||||
"рабочего стенда; столбцы `tel_*` в конце `cells.csv`."
|
||||
)
|
||||
if budget.get("cpus", 0) > budget.get("vm_cpus", 0) > 0:
|
||||
text += (
|
||||
f" Сумма лимитов CPU {budget['cpus']:g} больше CPU ВМ "
|
||||
f"{budget['vm_cpus']}: лимиты делят время, а не резервируют ядра."
|
||||
)
|
||||
return text
|
||||
|
||||
|
||||
def render_summary(
|
||||
meta: Mapping[str, Any],
|
||||
rows: list[Mapping[str, Any]],
|
||||
@@ -1868,6 +1916,8 @@ def render_summary(
|
||||
f"dirty {meta.get('git', {}).get('dirty')}, статус "
|
||||
f"{meta.get('status')}, ячеек {len(rows)} из {plan_total}.",
|
||||
"",
|
||||
telemetry_line(meta),
|
||||
"",
|
||||
]
|
||||
fatal = [
|
||||
f"`{row['cell']}`: {row['flags']}"
|
||||
|
||||
+1206
-27
File diff suppressed because it is too large
Load Diff
+10
-2
@@ -42,6 +42,11 @@
|
||||
# `mq <нс> missing`). В фоне psql с \watch пишет /work/jobs.log (одно
|
||||
# соединение): jobs|<мс>|outbox|waiting|published|processing|oldest_s|
|
||||
# staging_ready. Разбор — bench/overload.py.
|
||||
# cost (профиль цены телеметрии, design change track1-telemetry-cost,
|
||||
# решение 10): <интервал, с> cost
|
||||
# Контейнер без сети, как scan: строки `cg` всех контейнеров ВМ, `vm` и
|
||||
# `mp` каждого контейнера (memory.peak, anon, oom_kill), как у queue. Ни
|
||||
# psql, ни опроса LB и брокера. Разбор — bench/telemetry_cost.py.
|
||||
set -u
|
||||
|
||||
interval=$1
|
||||
@@ -50,6 +55,9 @@ mode=list
|
||||
if [[ ${1:-} == scan ]]; then
|
||||
mode=scan
|
||||
shift
|
||||
elif [[ ${1:-} == cost ]]; then
|
||||
mode=cost
|
||||
shift
|
||||
elif [[ ${1:-} == queue ]]; then
|
||||
mode=queue
|
||||
queue_name=$2
|
||||
@@ -290,13 +298,13 @@ hex64='^[0-9a-f]{64}$'
|
||||
while :; do
|
||||
# EPOCHREALTIME bash 5 — часы ВМ без запуска date
|
||||
ns=${EPOCHREALTIME/./}000
|
||||
if [[ $mode == scan || $mode == queue ]]; then
|
||||
if [[ $mode == scan || $mode == queue || $mode == cost ]]; then
|
||||
for dir in /sys/fs/cgroup/docker/*/; do
|
||||
dir=${dir%/}
|
||||
id=${dir##*/}
|
||||
if [[ $id =~ $hex64 ]]; then
|
||||
cg_line - "$id"
|
||||
[[ $mode == queue ]] && mp_line "$id"
|
||||
[[ $mode == queue || $mode == cost ]] && mp_line "$id"
|
||||
fi
|
||||
done
|
||||
else
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
# Override включённой телеметрии стенда bench/ (design change
|
||||
# track1-telemetry-cost, решения 1 и 13): второй -f после bench.compose.yml —
|
||||
# у вариантов профиля цены телеметрии с телеметрией и у профилей загрузок и
|
||||
# очереди с TELEMETRY=on. SDK реплик, worker и relay включён и отправляет в
|
||||
# Collector стенда; доля выбора трасс, набор границ и интервал — значения по
|
||||
# умолчанию (рабочий стенд), вариант профиля задаёт их своим override
|
||||
# (.work/variant.compose.yml). Без этого файла телеметрия стенда выключена
|
||||
# (TELEMETRY__ENABLED: "false" в bench.compose.yml)
|
||||
services:
|
||||
api:
|
||||
environment:
|
||||
TELEMETRY__ENABLED: "true"
|
||||
TELEMETRY__OTLP_ENDPOINT: http://otel-collector:4318
|
||||
|
||||
worker:
|
||||
environment:
|
||||
TELEMETRY__ENABLED: "true"
|
||||
TELEMETRY__OTLP_ENDPOINT: http://otel-collector:4318
|
||||
|
||||
relay:
|
||||
environment:
|
||||
TELEMETRY__ENABLED: "true"
|
||||
TELEMETRY__OTLP_ENDPOINT: http://otel-collector:4318
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,625 @@
|
||||
"""Выборка из хранилищ телеметрии профиля цены телеметрии.
|
||||
|
||||
Design change `track1-telemetry-cost`, решение 9. Только в контейнере
|
||||
`mtusi-bench-lookup` на образе стенда, в сети хранилищ `mtusi-bench-telemetry`;
|
||||
только stdlib (`urllib`), `src` не импортирует, `bench/` — на чтение. Запросы
|
||||
— HTTP API Tempo, Loki, Prometheus и метрики Collector, пулом из восьми
|
||||
потоков.
|
||||
|
||||
python telemetry_lookup.py wait-ready [--timeout 90]
|
||||
python telemetry_lookup.py collect <события.json> <итог.json>
|
||||
|
||||
`wait-ready` — `/-/ready` Prometheus, `/ready` Loki и Tempo, `:8888/metrics`
|
||||
Collector; код 0 — все готовы, 1 — срок вышел. `collect` — по событиям прогона
|
||||
(id запросов редких классов, выборка нормальных, окна) ищет трассы по
|
||||
`span.messenger.request_id` (и цельные цепочки загрузок), записи журнала по
|
||||
`request_id` и их переход к трассе, счётчики Prometheus (приём, потери,
|
||||
события), ряды по `job`, `status/tsdb`, признаки слоёв Collector и
|
||||
Prometheus, квантили из buckets против журнала. Результат поиска, равный
|
||||
пределу числа результатов, — отказ «lookup truncated» (код 1): неполный счёт
|
||||
не выдаётся за полный.
|
||||
"""
|
||||
|
||||
import json
|
||||
import math
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from typing import Any
|
||||
|
||||
PROMETHEUS = "http://prometheus:9090"
|
||||
LOKI = "http://loki:3100"
|
||||
TEMPO = "http://tempo:3200"
|
||||
COLLECTOR = "http://otel-collector:8888"
|
||||
READY = (
|
||||
f"{PROMETHEUS}/-/ready",
|
||||
f"{LOKI}/ready",
|
||||
f"{TEMPO}/ready",
|
||||
f"{COLLECTOR}/metrics",
|
||||
)
|
||||
THREADS = 8
|
||||
# переходы журнал → трасса: потоков на класс (классы идут параллельно)
|
||||
LINK_THREADS = 2
|
||||
TIMEOUT_S = 60
|
||||
ATTEMPTS = 4
|
||||
RETRY_PAUSE_S = 1.0
|
||||
# счётчики по краям окна: шаг — интервал scrape, взгляд назад — был ли ряд
|
||||
# до окна
|
||||
STEP_S = 15
|
||||
LOOKBACK_S = 60
|
||||
# id в одном поиске Tempo и Loki: регулярное выражение в query string
|
||||
BATCH = 40
|
||||
# предел результатов — не меньше 4 × ожидаемого (решение 9)
|
||||
LIMIT_FACTOR = 4
|
||||
API_SERVICE = "messenger-api"
|
||||
REQUEST_ATTR = "span.messenger.request_id"
|
||||
# у загрузки цепочка — server span API, span producer relay, consumer span
|
||||
# worker с итогом задания
|
||||
CHAIN_OUTCOME = {"upload": "ready", "upload_bad": "failed"}
|
||||
# имена Collector — без суффикса _total у собственных метрик (rule
|
||||
# telemetry.md); на всякий случай оба варианта
|
||||
TOTALS = {
|
||||
"sdk_span_started_sampled": (
|
||||
'sum(otel_sdk_span_started_total{otel_span_sampling_result='
|
||||
'"RECORD_AND_SAMPLE"})'
|
||||
),
|
||||
"sdk_span_started_dropped": (
|
||||
'sum(otel_sdk_span_started_total{otel_span_sampling_result="DROP"})'
|
||||
),
|
||||
"sdk_span_processed_ok": (
|
||||
'sum(otel_sdk_processor_span_processed_total{error_type=""})'
|
||||
),
|
||||
"sdk_span_processed_lost": (
|
||||
'sum(otel_sdk_processor_span_processed_total{error_type!=""})'
|
||||
),
|
||||
"sdk_span_exported_ok": (
|
||||
'sum(otel_sdk_exporter_span_exported_total{error_type=""})'
|
||||
),
|
||||
"sdk_span_export_failed": (
|
||||
'sum(otel_sdk_exporter_span_exported_total{error_type!=""})'
|
||||
),
|
||||
"sdk_log_processed_ok": (
|
||||
'sum(otel_sdk_processor_log_processed_total{error_type=""})'
|
||||
),
|
||||
"sdk_log_processed_lost": (
|
||||
'sum(otel_sdk_processor_log_processed_total{error_type!=""})'
|
||||
),
|
||||
"sdk_log_exported_ok": (
|
||||
'sum(otel_sdk_exporter_log_exported_total{error_type=""})'
|
||||
),
|
||||
"sdk_log_export_failed": (
|
||||
'sum(otel_sdk_exporter_log_exported_total{error_type!=""})'
|
||||
),
|
||||
"col_accepted_spans": "otelcol_receiver_accepted_spans",
|
||||
"col_refused_spans": "otelcol_receiver_refused_spans",
|
||||
"col_failed_spans": "otelcol_receiver_failed_spans",
|
||||
"col_accepted_logs": "otelcol_receiver_accepted_log_records",
|
||||
"col_refused_logs": "otelcol_receiver_refused_log_records",
|
||||
"col_failed_logs": "otelcol_receiver_failed_log_records",
|
||||
"col_accepted_points": "otelcol_receiver_accepted_metric_points",
|
||||
"col_refused_points": "otelcol_receiver_refused_metric_points",
|
||||
"col_sent_spans": "otelcol_exporter_sent_spans",
|
||||
"col_send_failed_spans": "otelcol_exporter_send_failed_spans",
|
||||
"col_enqueue_failed_spans": "otelcol_exporter_enqueue_failed_spans",
|
||||
"col_sent_logs": "otelcol_exporter_sent_log_records",
|
||||
"col_send_failed_logs": "otelcol_exporter_send_failed_log_records",
|
||||
"col_enqueue_failed_logs": "otelcol_exporter_enqueue_failed_log_records",
|
||||
"col_sent_points": "otelcol_exporter_sent_metric_points",
|
||||
"tail_sampled": (
|
||||
"otelcol_processor_tail_sampling_global_count_traces_sampled"
|
||||
'{sampled="true"}'
|
||||
),
|
||||
"tail_not_sampled": (
|
||||
"otelcol_processor_tail_sampling_global_count_traces_sampled"
|
||||
'{sampled="false"}'
|
||||
),
|
||||
"tail_dropped_too_early": (
|
||||
"otelcol_processor_tail_sampling_sampling_trace_dropped_too_early"
|
||||
),
|
||||
"tail_new_traces": (
|
||||
"otelcol_processor_tail_sampling_new_trace_id_received"
|
||||
),
|
||||
"tail_policy_errors": (
|
||||
"otelcol_processor_tail_sampling_sampling_policy_evaluation_error"
|
||||
),
|
||||
"tempo_spans": "sum(tempo_distributor_spans_received_total)",
|
||||
"tempo_bytes": "sum(tempo_distributor_bytes_received_total)",
|
||||
"loki_lines": "sum(loki_distributor_lines_received_total)",
|
||||
"loki_bytes": "sum(loki_distributor_bytes_received_total)",
|
||||
"loki_sm_bytes": (
|
||||
"sum(loki_distributor_structured_metadata_bytes_received_total)"
|
||||
),
|
||||
"prom_series": "max(prometheus_tsdb_head_series)",
|
||||
"prom_samples": "sum(prometheus_tsdb_head_samples_appended_total)",
|
||||
}
|
||||
# счётчики, приращение которых нужно за чистое окно (приём, решение 9)
|
||||
CLEAN = (
|
||||
"col_accepted_spans",
|
||||
"col_accepted_logs",
|
||||
"col_accepted_points",
|
||||
"tempo_spans",
|
||||
"tempo_bytes",
|
||||
"loki_lines",
|
||||
"loki_bytes",
|
||||
"loki_sm_bytes",
|
||||
"prom_samples",
|
||||
"prom_series",
|
||||
)
|
||||
GAUGES = frozenset({"prom_series"})
|
||||
CONTENT_ROUTE = "/api/v1/attachments/{attachment_id}/content"
|
||||
MESSAGES_ROUTE = "/api/v1/chats/{chat_id}/messages"
|
||||
HTTP_COUNT = "http_server_request_duration_seconds_count"
|
||||
HTTP_BUCKET = "http_server_request_duration_seconds_bucket"
|
||||
RARE_METRICS = {
|
||||
"broken": (
|
||||
f'sum({HTTP_COUNT}{{http_route="{CONTENT_ROUTE}",'
|
||||
'http_response_status_code="500"})'
|
||||
),
|
||||
"register": (
|
||||
f'sum({HTTP_COUNT}{{http_route="/api/v1/users",'
|
||||
'http_request_method="POST",http_response_status_code="201"})'
|
||||
),
|
||||
"write_slow": (
|
||||
f'sum({HTTP_COUNT}{{http_route="{MESSAGES_ROUTE}",'
|
||||
'http_request_method="POST"}) - '
|
||||
f'sum({HTTP_BUCKET}{{http_route="{MESSAGES_ROUTE}",'
|
||||
'http_request_method="POST",le="0.25"})'
|
||||
),
|
||||
"upload_bad": (
|
||||
'sum(messenger_job_duration_seconds_count{messenger_job_outcome='
|
||||
'"failed"})'
|
||||
),
|
||||
"upload": "sum(messenger_job_time_to_ready_seconds_count)",
|
||||
}
|
||||
QUANTILES = (0.95, 0.99)
|
||||
|
||||
|
||||
class TruncatedError(Exception):
|
||||
"""Поиск упёрся в предел числа результатов."""
|
||||
|
||||
|
||||
def collector_name(expr: str) -> str:
|
||||
"""Имя Collector с и без `_total`: `sum({__name__=~"имя(_total)?", …})`."""
|
||||
if expr.startswith(("sum(", "max(")):
|
||||
return expr
|
||||
name, _, labels = expr.partition("{")
|
||||
labels = labels.rstrip("}")
|
||||
matcher = f'__name__=~"{name}(_total)?"'
|
||||
if labels:
|
||||
matcher += f",{labels}"
|
||||
return f"sum({{{matcher}}})"
|
||||
|
||||
|
||||
def fetch(url: str) -> bytes:
|
||||
"""GET с повтором на обрыв соединения и 5xx: хранилище с 0,5 CPU под
|
||||
пулом запросов изредка закрывает соединение без ответа. 4xx — сразу."""
|
||||
for attempt in range(1, ATTEMPTS + 1):
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=TIMEOUT_S) as response:
|
||||
return response.read()
|
||||
except urllib.error.HTTPError as exc:
|
||||
if exc.code < 500 or attempt == ATTEMPTS:
|
||||
raise
|
||||
except (OSError, urllib.error.URLError):
|
||||
if attempt == ATTEMPTS:
|
||||
raise
|
||||
time.sleep(RETRY_PAUSE_S * attempt)
|
||||
raise AssertionError("unreachable")
|
||||
|
||||
|
||||
def get(url: str, params: dict[str, Any] | None = None) -> Any:
|
||||
if params:
|
||||
url = f"{url}?{urllib.parse.urlencode(params)}"
|
||||
body = fetch(url)
|
||||
return json.loads(body) if body[:1] in (b"{", b"[") else body
|
||||
|
||||
|
||||
def exists(url: str) -> bool:
|
||||
try:
|
||||
fetch(url)
|
||||
except urllib.error.HTTPError as exc:
|
||||
if exc.code == 404:
|
||||
return False
|
||||
raise
|
||||
return True
|
||||
|
||||
|
||||
def wait_ready(timeout: float) -> int:
|
||||
deadline = time.monotonic() + timeout
|
||||
pending = list(READY)
|
||||
while time.monotonic() < deadline:
|
||||
left = []
|
||||
for url in pending:
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=3) as response:
|
||||
response.read()
|
||||
if response.status != 200:
|
||||
left.append(url)
|
||||
except (OSError, urllib.error.URLError):
|
||||
left.append(url)
|
||||
pending = left
|
||||
if not pending:
|
||||
print("telemetry storages ready", flush=True)
|
||||
return 0
|
||||
time.sleep(1)
|
||||
print(f"not ready in {timeout:.0f}s: {pending}", flush=True)
|
||||
return 1
|
||||
|
||||
|
||||
def batches(items: list[str]) -> list[list[str]]:
|
||||
return [items[i : i + BATCH] for i in range(0, len(items), BATCH)]
|
||||
|
||||
|
||||
def tempo_search(query: str, window: dict[str, float], expected: int) -> Any:
|
||||
limit = max(20, LIMIT_FACTOR * expected)
|
||||
data = get(
|
||||
f"{TEMPO}/api/search",
|
||||
{
|
||||
"q": query,
|
||||
"start": int(window["start"]),
|
||||
"end": int(window["end"]) + 1,
|
||||
"limit": limit,
|
||||
"spss": 10,
|
||||
},
|
||||
)
|
||||
traces = data.get("traces") or []
|
||||
if len(traces) >= limit:
|
||||
raise TruncatedError(
|
||||
f"lookup truncated: tempo {len(traces)} = {limit}",
|
||||
)
|
||||
return traces
|
||||
|
||||
|
||||
def request_ids_in(traces: list[dict[str, Any]]) -> set[str]:
|
||||
found = set()
|
||||
for item in traces:
|
||||
for spanset in item.get("spanSets") or [item.get("spanSet") or {}]:
|
||||
for span in spanset.get("spans") or []:
|
||||
for attr in span.get("attributes") or []:
|
||||
if attr.get("key") == "messenger.request_id":
|
||||
found.add(attr["value"].get("stringValue", ""))
|
||||
return found
|
||||
|
||||
|
||||
def traces_of(
|
||||
ids: list[str],
|
||||
window: dict[str, float],
|
||||
outcome: str | None = None,
|
||||
) -> set[str]:
|
||||
"""Id запросов, у которых в Tempo есть трасса (у `outcome` — цельная
|
||||
цепочка загрузки с consumer span этого итога и span producer)."""
|
||||
found: set[str] = set()
|
||||
for part in batches(ids):
|
||||
pattern = "|".join(part)
|
||||
query = f'{{ {REQUEST_ATTR} =~ "{pattern}" }}'
|
||||
if outcome is not None:
|
||||
query += (
|
||||
" && { kind = consumer && span.messenger.job.outcome = "
|
||||
f'"{outcome}" }} && {{ kind = producer }}'
|
||||
)
|
||||
query += f" | select({REQUEST_ATTR})"
|
||||
found |= request_ids_in(tempo_search(query, window, len(part)))
|
||||
return found & set(ids)
|
||||
|
||||
|
||||
def loki_records(
|
||||
ids: list[str],
|
||||
window: dict[str, float],
|
||||
) -> dict[str, dict[str, str]]:
|
||||
"""Запись доступа API по `request_id`: метки потока (поля записи)."""
|
||||
out: dict[str, dict[str, str]] = {}
|
||||
for part in batches(ids):
|
||||
limit = LIMIT_FACTOR * len(part) + 10
|
||||
query = (
|
||||
f'{{service_name="{API_SERVICE}"}} | middleware="http" | '
|
||||
f'request_id=~"{"|".join(part)}"'
|
||||
)
|
||||
data = get(
|
||||
f"{LOKI}/loki/api/v1/query_range",
|
||||
{
|
||||
"query": query,
|
||||
"start": int(window["start"] * 1e9),
|
||||
"end": int((window["end"] + 1) * 1e9),
|
||||
"limit": limit,
|
||||
"direction": "forward",
|
||||
},
|
||||
)
|
||||
streams = data["data"]["result"]
|
||||
lines = sum(len(stream["values"]) for stream in streams)
|
||||
if lines >= limit:
|
||||
raise TruncatedError(f"lookup truncated: loki {lines} = {limit}")
|
||||
for stream in streams:
|
||||
labels = stream["stream"]
|
||||
out[labels.get("request_id", "")] = labels
|
||||
return {key: value for key, value in out.items() if key in set(ids)}
|
||||
|
||||
|
||||
def trace_exists(trace_id: str) -> bool:
|
||||
"""Трасса есть и в ней есть span: на неизвестный id Tempo может ответить
|
||||
и пустым телом (пробный прогон `head` — 12 «найденных» трасс из 12
|
||||
невыбранных)."""
|
||||
try:
|
||||
body = fetch(f"{TEMPO}/api/v2/traces/{trace_id}")
|
||||
except urllib.error.HTTPError as exc:
|
||||
if exc.code == 404:
|
||||
return False
|
||||
raise
|
||||
if not body.strip():
|
||||
return False
|
||||
data = json.loads(body)
|
||||
trace = data.get("trace", data)
|
||||
return bool(trace.get("resourceSpans") or trace.get("batches"))
|
||||
|
||||
|
||||
def class_result(
|
||||
name: str,
|
||||
ids: list[str],
|
||||
window: dict[str, float],
|
||||
slow_ms: float,
|
||||
) -> dict[str, Any]:
|
||||
traced = traces_of(ids, window)
|
||||
chains = None
|
||||
if name in CHAIN_OUTCOME and ids:
|
||||
chains = len(traces_of(ids, window, CHAIN_OUTCOME[name]))
|
||||
records = loki_records(ids, window) if ids else {}
|
||||
with_trace = {
|
||||
rid: labels["trace_id"]
|
||||
for rid, labels in records.items()
|
||||
if labels.get("trace_id")
|
||||
}
|
||||
sampled = sum(
|
||||
1
|
||||
for labels in records.values()
|
||||
if labels.get("flags", "").isdigit() and int(labels["flags"]) & 1
|
||||
)
|
||||
# свой пул: задачи классов уже заняли потоки общего
|
||||
with ThreadPoolExecutor(LINK_THREADS) as links:
|
||||
linked_by = dict(
|
||||
zip(
|
||||
with_trace,
|
||||
links.map(trace_exists, with_trace.values()),
|
||||
strict=True,
|
||||
),
|
||||
)
|
||||
linked = sum(linked_by.values())
|
||||
# медленные по серверу: длительность записи доступа (та же величина, что
|
||||
# server span) не меньше порога; по ней решает правило выбора трасс
|
||||
server_slow = {
|
||||
rid
|
||||
for rid, labels in records.items()
|
||||
if float(labels.get("duration_ms") or 0) >= slow_ms
|
||||
}
|
||||
return {
|
||||
"ids": len(ids),
|
||||
"traces": len(traced),
|
||||
"server_slow": len(server_slow),
|
||||
"server_slow_traces": len(server_slow & traced),
|
||||
"server_slow_linked": sum(
|
||||
1 for rid in server_slow if linked_by.get(rid)
|
||||
),
|
||||
"chains": chains,
|
||||
"logs": len(records),
|
||||
"logs_with_trace": len(with_trace),
|
||||
"logs_sampled_flag": sampled,
|
||||
"log_to_trace": linked,
|
||||
"missing_traces": sorted(set(ids) - traced)[:5],
|
||||
}
|
||||
|
||||
|
||||
def prom_value(expr: str, at: float) -> float | None:
|
||||
data = get(f"{PROMETHEUS}/api/v1/query", {"query": expr, "time": at})
|
||||
result = data["data"]["result"]
|
||||
if not result:
|
||||
return None
|
||||
value = float(result[0]["value"][1])
|
||||
# histogram_quantile без отсчётов — NaN: в JSON это не число
|
||||
return None if math.isnan(value) else value
|
||||
|
||||
|
||||
def prom_delta(
|
||||
expr: str,
|
||||
start: float,
|
||||
end: float,
|
||||
*,
|
||||
gauge: bool,
|
||||
) -> dict[str, float | None]:
|
||||
"""Разность первого отсчёта не раньше начала окна и последнего не позже
|
||||
конца (шаг 15 с, решение 9); у gauge — последнее значение."""
|
||||
data = get(
|
||||
f"{PROMETHEUS}/api/v1/query_range",
|
||||
{
|
||||
"query": expr,
|
||||
"start": start - LOOKBACK_S,
|
||||
"end": end,
|
||||
"step": STEP_S,
|
||||
},
|
||||
)
|
||||
result = data["data"]["result"]
|
||||
if not result:
|
||||
return {"delta": None, "seconds": None, "last": None}
|
||||
series = [(float(t), float(v)) for t, v in result[0]["values"]]
|
||||
inside = [(t, v) for t, v in series if start <= t <= end]
|
||||
if not inside:
|
||||
return {"delta": None, "seconds": None, "last": None}
|
||||
t1, v1 = inside[-1]
|
||||
if gauge:
|
||||
return {"delta": None, "seconds": t1 - inside[0][0], "last": v1}
|
||||
# ряд счётчика, которого до окна не было (Tempo заводит его на первый
|
||||
# принятый span — у tail через срок решения), начинается с нуля: база —
|
||||
# ноль в начале окна, а не первый отсчёт внутри (иначе приёма «нет»)
|
||||
if any(t < start for t, _ in series) and len(inside) >= 2:
|
||||
t0, v0 = inside[0]
|
||||
else:
|
||||
t0, v0 = start, 0.0
|
||||
if t1 <= t0:
|
||||
return {"delta": None, "seconds": None, "last": v1}
|
||||
return {"delta": v1 - v0, "seconds": t1 - t0, "last": v1}
|
||||
|
||||
|
||||
def quantiles(
|
||||
method: str,
|
||||
route: str,
|
||||
window: dict[str, float],
|
||||
) -> dict[str, float | None]:
|
||||
seconds = max(1, int(window["end"] - window["start"]))
|
||||
out: dict[str, float | None] = {}
|
||||
for q in QUANTILES:
|
||||
key = f"p{int(q * 100)}"
|
||||
out[f"{key}_buckets"] = prom_value(
|
||||
f"histogram_quantile({q}, sum by (le) (increase({HTTP_BUCKET}"
|
||||
f'{{http_route="{route}",http_request_method="{method}"}}'
|
||||
f"[{seconds}s])))",
|
||||
window["end"],
|
||||
)
|
||||
data = get(
|
||||
f"{LOKI}/loki/api/v1/query",
|
||||
{
|
||||
"query": (
|
||||
f"quantile_over_time({q}, "
|
||||
f'{{service_name="{API_SERVICE}"}} | middleware="http" '
|
||||
f'| method="{method}" | path="{route}" '
|
||||
f"| unwrap duration_ms [{seconds}s]) by ()"
|
||||
),
|
||||
"time": int(window["end"] * 1e9),
|
||||
},
|
||||
)
|
||||
result = data["data"]["result"]
|
||||
value = float(result[0]["value"][1]) / 1000 if result else None
|
||||
out[f"{key}_log"] = (
|
||||
None if value is None or math.isnan(value) else value
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def loki_counts(window: dict[str, float]) -> dict[str, int]:
|
||||
seconds = max(1, int(window["end"] - window["start"]))
|
||||
data = get(
|
||||
f"{LOKI}/loki/api/v1/query",
|
||||
{
|
||||
"query": (
|
||||
"sum by (method, path) (count_over_time("
|
||||
f'{{service_name="{API_SERVICE}"}} | middleware="http" '
|
||||
f"[{seconds}s]))"
|
||||
),
|
||||
"time": int(window["end"] * 1e9),
|
||||
},
|
||||
)
|
||||
return {
|
||||
f"{item['metric'].get('method', '')} {item['metric'].get('path', '')}": (
|
||||
int(float(item["value"][1]))
|
||||
)
|
||||
for item in data["data"]["result"]
|
||||
}
|
||||
|
||||
|
||||
def collect(events: dict[str, Any]) -> dict[str, Any]:
|
||||
started = time.monotonic()
|
||||
search = events["search"]
|
||||
run = events["run"]
|
||||
clean = events["clean"]
|
||||
out: dict[str, Any] = {"classes": {}}
|
||||
with ThreadPoolExecutor(THREADS) as pool:
|
||||
futures = {
|
||||
name: pool.submit(
|
||||
class_result,
|
||||
name,
|
||||
ids,
|
||||
search,
|
||||
float(events.get("slow_ms", 250)),
|
||||
)
|
||||
for name, ids in events["classes"].items()
|
||||
}
|
||||
sample = events.get("sample_me") or []
|
||||
sample_future = pool.submit(traces_of, sample, search)
|
||||
for name, future in futures.items():
|
||||
out["classes"][name] = future.result()
|
||||
out["sample_me"] = {
|
||||
"ids": len(sample),
|
||||
"traces": len(sample_future.result()),
|
||||
}
|
||||
at = search["end"]
|
||||
names = list(TOTALS)
|
||||
values = pool.map(
|
||||
lambda key: prom_value(collector_name(TOTALS[key]), at),
|
||||
names,
|
||||
)
|
||||
out["totals"] = dict(zip(names, values, strict=True))
|
||||
rare = list(RARE_METRICS)
|
||||
out["rare_metrics"] = dict(
|
||||
zip(
|
||||
rare,
|
||||
pool.map(lambda key: prom_value(RARE_METRICS[key], at), rare),
|
||||
strict=True,
|
||||
),
|
||||
)
|
||||
out["clean"] = dict(
|
||||
zip(
|
||||
CLEAN,
|
||||
pool.map(
|
||||
lambda key: prom_delta(
|
||||
collector_name(TOTALS[key]),
|
||||
clean["start"],
|
||||
clean["end"],
|
||||
gauge=key in GAUGES,
|
||||
),
|
||||
CLEAN,
|
||||
),
|
||||
strict=True,
|
||||
),
|
||||
)
|
||||
out["quantiles"] = {
|
||||
name: quantiles(method, route, clean)
|
||||
for name, (method, route) in events["routes"].items()
|
||||
}
|
||||
out["loki_counts"] = loki_counts(run)
|
||||
jobs = get(
|
||||
f"{PROMETHEUS}/api/v1/query",
|
||||
{"query": 'count by (job) ({__name__=~".+"})', "time": at},
|
||||
)
|
||||
out["series_by_job"] = {
|
||||
item["metric"].get("job", ""): int(float(item["value"][1]))
|
||||
for item in jobs["data"]["result"]
|
||||
}
|
||||
tsdb = get(f"{PROMETHEUS}/api/v1/status/tsdb")["data"]
|
||||
out["tsdb"] = {
|
||||
"num_series": tsdb.get("headStats", {}).get("numSeries"),
|
||||
"top_metrics": tsdb.get("seriesCountByMetricName", [])[:10],
|
||||
}
|
||||
config = get(f"{PROMETHEUS}/api/v1/status/config")["data"]["yaml"]
|
||||
tail = prom_value(
|
||||
'count({__name__=~"otelcol_processor_tail_sampling_.*"})',
|
||||
at,
|
||||
)
|
||||
out["layers"] = {
|
||||
"tail_sampling": bool(tail),
|
||||
"lean_prometheus": "loki_distributor_" in config,
|
||||
}
|
||||
out["seconds"] = round(time.monotonic() - started, 1)
|
||||
return out
|
||||
|
||||
|
||||
def main(argv: list[str]) -> int:
|
||||
if argv[:1] == ["wait-ready"]:
|
||||
timeout = float(argv[2]) if argv[1:2] == ["--timeout"] else 90.0
|
||||
return wait_ready(timeout)
|
||||
if argv[:1] == ["collect"] and len(argv) == 3:
|
||||
with open(argv[1], encoding="utf-8") as file:
|
||||
events = json.load(file)
|
||||
try:
|
||||
result = collect(events)
|
||||
except TruncatedError as exc:
|
||||
print(str(exc), flush=True)
|
||||
return 1
|
||||
with open(argv[2], "w", encoding="utf-8") as file:
|
||||
json.dump(result, file, ensure_ascii=False, indent=1)
|
||||
print(f"lookup done in {result['seconds']}s", flush=True)
|
||||
return 0
|
||||
print(__doc__, flush=True)
|
||||
return 2
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -648,6 +648,23 @@ def fmt(value: float | None, digits: int = 1) -> str:
|
||||
return "—" if value is None else f"{value:.{digits}f}"
|
||||
|
||||
|
||||
def telemetry_line(profile: dict[str, Any]) -> str:
|
||||
"""Режим телеметрии метки (design change `track1-telemetry-cost`, решение
|
||||
13): у варианта «до» SDK в коде нет — с `on` сравнение смешанное."""
|
||||
if profile.get("telemetry") != "on":
|
||||
return "Телеметрия стенда выключена (TELEMETRY=off)"
|
||||
text = (
|
||||
"Телеметрия стенда включена (TELEMETRY=on): SDK реплики с настройками "
|
||||
"рабочего стенда, Collector, Prometheus, Loki и Tempo рабочего стенда"
|
||||
)
|
||||
if "before" in profile.get("uploads_variants", ()):
|
||||
text += (
|
||||
"; вариант «до» — образ кода без SDK, его сравнение с остальными "
|
||||
"вариантами смешанное (с телеметрией против без неё)"
|
||||
)
|
||||
return text
|
||||
|
||||
|
||||
def render_summary(meta: dict[str, Any], rows: list[dict[str, Any]]) -> str:
|
||||
"""`summary.md` метки: паспорт кратко, таблица ячеек (медиана и
|
||||
min–max повторов), сценарии спеков и гипотезы."""
|
||||
@@ -710,6 +727,7 @@ def render_summary(meta: dict[str, Any], rows: list[dict[str, Any]]) -> str:
|
||||
"Значения — медиана (min–max) повторов",
|
||||
"- Посторонние контейнеры в VM во время замера: "
|
||||
+ (", ".join(meta.get("other_containers") or []) or "нет"),
|
||||
"- " + telemetry_line(profile),
|
||||
"",
|
||||
"## Ячейки",
|
||||
"",
|
||||
|
||||
+9
-1
@@ -193,7 +193,15 @@ failure_pause_seconds = 2
|
||||
# применяют. Переменные OTEL_* настройками не являются.
|
||||
# deployment.environment.name ресурса
|
||||
environment = "lab"
|
||||
# секунды между отправками метрик
|
||||
# доля корней трасс, выбранных в голове по trace_id: 0…1, 1 — все трассы;
|
||||
# span с родителем (в том числе worker из задания) следует его флагу, журнал и
|
||||
# метрики не выбираются (OTEL_TRACES_SAMPLER_ARG skeleton)
|
||||
trace_sample_ratio = 1.0
|
||||
# набор границ histogram: "default" или "coarse" (меньше границ, те же
|
||||
# границы SLO 0,25 с и 30 с)
|
||||
metric_buckets = "default"
|
||||
# секунды между отправками метрик; не больше 30 — половины срока рядов
|
||||
# экспортёра Collector
|
||||
metric_export_interval_seconds = 15
|
||||
# секунды на одну отправку пакета
|
||||
export_timeout_seconds = 2
|
||||
|
||||
@@ -287,7 +287,7 @@ Prometheus не сливает конфигурации, поэтому файл
|
||||
| `upload` | класс `s` (JPEG 1600 × 1200, 0,48 MiB) | 1 | цепочка API → relay → worker |
|
||||
| `upload_bad` | класс `bad`: `s` с точностью 12 бит в SOF — структура верна, Pillow не декодирует | 0,1 | неудачное задание, `failed`, `invalid_image` |
|
||||
| `broken` | оригинал вложения без объекта | 0,2 | 500 API, span S3 и server span с ошибкой |
|
||||
| `register` | регистрация с паролем из `crypto.randomUUID()`, сразу выброшенным | 0,2 | редкий медленный маршрут (Argon2id, 0,3–1 с) |
|
||||
| `register` | регистрация с паролем из `crypto.randomUUID()`, сразу выброшенным | 0,2 | редкий маршрут; ждали медленный (Argon2id, 0,3–1 с), на стенде ~85 мс — редкий быстрый («Уточнения apply», п. 1) |
|
||||
|
||||
- **Чат записи читается с первой страницы**, как в `background.js`: страница из 50 полна уже в разогреве (20 записей/с).
|
||||
- **Регистрация, а не вход:** вход требует пароля, а пароли стенда живут только в памяти `prepare.js` (`bench.md`); регистрация
|
||||
@@ -389,7 +389,7 @@ p99 лёгких запросов, приём по сигналам, сохра
|
||||
|---|---|---|
|
||||
| H1 | полная телеметрия дорога для реплик и хвоста | `full` против `off`: CPU реплик на запрос ≥ +10 %; p50 лёгких — не больше +1 мс; p99 лёгких ≥ +2 мс, и его относительный рост больше роста p50 (поток экспорта держит GIL на кодировании пакета) |
|
||||
| H2 | выбор в голове снимает большую часть цены приложения, но не журнал | `head`: надбавка CPU реплик на запрос против `off` ≤ половины надбавки `full`; приём Tempo ≤ 15 % `full`; доля сохранённых трасс каждого класса редких событий — в биномиальном интервале около 0,1; счёт в метрике и записи журнала — 100 % |
|
||||
| H3 | типовой tail экономит хранилище, но не приложение, и платит памятью Collector | `tail`: CPU реплик на запрос — в пределах шума от `full`; наибольшая память Collector ≥ `full` + 15 МиБ, CPU Collector — не выше `full` больше чем на 20 %; приём Tempo ≤ 30 % `full`; трассы 500, медленных записей, регистраций и цепочки `bad` — 100 %; цепочки обычных загрузок ≥ 90 % (правило длительности трассы ловит асинхронную цепочку); отказов `memory_limiter` и `dropped_too_early` нет |
|
||||
| H3 | типовой tail экономит хранилище, но не приложение, и платит памятью Collector | `tail`: CPU реплик на запрос — в пределах шума от `full`; наибольшая память Collector ≥ `full` + 15 МиБ, CPU Collector — не выше `full` больше чем на 20 %; приём Tempo ≤ 30 % `full`; трассы 500, медленных по серверу записей и цепочки `bad` — 100 % («Уточнения apply», п. 1); цепочки обычных загрузок ≥ 90 % (правило длительности трассы ловит асинхронную цепочку); отказов `memory_limiter` и `dropped_too_early` нет |
|
||||
| H4 | агрегация почти не меняет CPU, но сокращает ряды; грубые границы теряют точность квантилей | `metrics`: рядов Prometheus ≤ 40 % `full`, отсчётов в секунду ≤ 40 %; CPU реплик и Collector — в пределах шума; ошибка p95 или p99 из buckets против журнала у `coarse` ≥ 2 × ошибки у `default` хотя бы на одном из маршрутов `read`, `write` |
|
||||
| H5 | переход от журнала к трассе ломается вместе с выборкой | доля записей редких классов с `trace_id`, ведущих на трассу: `full` — 100 %; `head` — в биномиальном интервале около 0,1; `tail` и `balanced` — 100 % у сохранённых классов |
|
||||
| H6 | непреднамеренных потерь при этой нагрузке нет | во всех вариантах счётчики потерь SDK и Collector — 0, `dropped_too_early` — 0; отброшенное выборкой (`DROP` в голове, `not_sampled` в Collector) объясняет разницу span SDK → Tempo с точностью 1 % |
|
||||
@@ -486,3 +486,52 @@ commit кода; файлы `bench/` от рабочего стенда не з
|
||||
решение пользователя; по умолчанию — нет (решение 5).
|
||||
- Достаточно ли преподавателю трёх настроек (выбор в голове, типовой tail, агрегация) и сбалансированной, проверенных на одной
|
||||
нагрузке, или нужна вторая интенсивность — ответ меняет только число меток.
|
||||
|
||||
## Уточнения apply
|
||||
|
||||
Решения, принятые в apply без пользователя (дублируются в `QUESTIONS.md`, `## track1-telemetry-cost`, «Решения apply»), —
|
||||
до коммита гипотез; пороги H1–H8 и B2–B5 не менялись.
|
||||
|
||||
1. **Регистрация — редкий быстрый маршрут, медленные записи — по серверу.** Пробные прогоны (`quick-telemetry-debug1/2`, в git
|
||||
не идут): регистрация на стенде — p50 ~85 мс, p95 ~90 мс (Argon2id параметров кода, 1 CPU реплики), а не 0,3–1 с, как ждал
|
||||
раздел 8; из записей, медленных по клиенту (≥ 0,25 с под блокировкой), 20 из 25 — медленные и по серверу: остальное —
|
||||
ожидание в LB и очереди uvicorn, которого server span не видит. Правила выбора трасс решают по span, поэтому B1, условия
|
||||
H3 и H5 у `tail` и `balanced` и сценарий `observability` «Ошибки и медленные запросы сохраняются» требуют полноты у 500,
|
||||
**медленных по серверу записей** (`duration_ms` записи доступа — та же величина, что server span, ≥ 0,25 с; выборка считает
|
||||
`server_slow`, `server_slow_traces`, `server_slow_linked`) и цепочек `bad`. Регистрация остаётся классом: у `full` — 100 %,
|
||||
у `head` — около 0,1, у `tail` и `balanced` — показывается долей (справочно): это и есть «что теряет выбор после
|
||||
завершения трассы» — редкий быстрый маршрут без ошибки. Правило «редкий маршрут — всегда» в `balanced` не добавлено: оно
|
||||
подгоняло бы конфигурацию под внесённое событие. Дельты спеков `load-benchmark` (B1, список редких событий) и `observability`
|
||||
(сценарий) поправлены вместе с design.
|
||||
2. **Запись о старте — одна функция** `telemetry.startup_fields(enabled)` для API, worker и relay (решение 3): три копии
|
||||
разошлись бы.
|
||||
3. **`Tracer` собирает `sdk.build`** в окне `_internal_metrics` и отдаёт `Providers.tracer`; `core.start` больше не зовёт
|
||||
`get_tracer` сам.
|
||||
4. **Стенд профиля — без `queue.compose.yml`**: плагин метрик брокера и статистика в секунду добавляли бы CPU брокера, политика
|
||||
перезапуска worker вариантам не нужна (пометка `storage_down` и так ловит гибель). Компоненты и лимиты — профиля очереди.
|
||||
5. **Разогрев** — тот же `queue_warm` профиля очереди (12 файлов `s` до `ready`, их id — готовые байты скачиваний).
|
||||
6. **`bad` открыть Pillow нельзя** даже для размеров (`UnidentifiedImageError`): `make_images.py` берёт ширину и высоту из SOF.
|
||||
Класс появился и в паспорте профиля очереди (файл создаётся, но не грузится).
|
||||
7. **Лимиты — по режиму**: `meta.limits_by_mode` (`off` и `on`), `stand` — паспорт без телеметрии, `stand_telemetry` — с ней
|
||||
(образы, лимиты и SHA-256 конфигураций): у вариантов разный состав контейнеров, а сверка «одинаковы во всех прогонах» — внутри
|
||||
режима.
|
||||
8. **Счёт в метрике** редких классов — значение счётчика в конце прогона (процессы и Prometheus свежие): у регистраций в него
|
||||
входят и пользователи `prepare.js` (2), поэтому условие H2 — «не меньше счёта клиента»; у медленных записей server span и
|
||||
клиент меряют разное — в H2 не сравниваются.
|
||||
9. **Выборка** ищет трассы пачками по 40 id одним регулярным выражением (`=~`), цепочку загрузки — структурным TraceQL; переход
|
||||
журнал → трасса — `GET /api/v2/traces/<id>` (2 потока на класс). Tempo с 0,5 CPU под ~30 параллельными запросами закрыл
|
||||
соединение без ответа (debug1): повтор только на обрыв и 5xx, до 4 раз с паузой.
|
||||
10. **VU заранее** — `2 × интенсивность + 4` на класс (запись под блокировкой до 0,6 с, при 20/с — до 12 в полёте).
|
||||
11. **`plots.py` без `--selftest`** — задача 9.1 его называет, но у модуля самопроверки нет и не было; проверяются остальные шесть.
|
||||
12. **Ожидание отправок — от последнего трафика и со scrape после решения** (раздел 9): калибровочная `tail` показала
|
||||
расхождение span Collector → Tempo 8 % — решения по трассам обхода метаданных (`queue_sweep.js` после нагрузки) приходили
|
||||
позже выборки, а счётчик Tempo доходит до Prometheus через scrape. Отсчёт — от конца обхода, срок —
|
||||
`max(интервал + 15 + 5; decision_wait + 2 + 15 + 5)`: `full`, `head`, `balanced` — 35 с, `metrics` — 50 с, `tail` — 52 с.
|
||||
13. **Приём по краям окна при ряде, которого до окна не было**: Tempo заводит `tempo_distributor_*` на первый принятый span —
|
||||
у `tail` через 30 с ожидания решения, внутри чистого окна быстрого профиля, и приём выходил «нет данных». Если ряда до окна
|
||||
не было (взгляд назад 60 с), база — ноль в начале окна.
|
||||
14. **Переход журнал → трасса** проверяет, что в ответе `/api/v2/traces/<id>` есть span: калибровочный `head` «нашёл» 12 из 12
|
||||
невыбранных трасс по одному коду ответа.
|
||||
15. **Калибровка (10.1)**: у `full` реплики заняты ~37 % CPU (граница 30–60 %), Collector и Tempo — 3–4 % своего лимита,
|
||||
worker ~41 %, недосланных нет, p95 времени до `ready` 0,8 с — интенсивности не меняются, множитель 1. Хост во время
|
||||
калибровки выгружал память в swap (`host_swap` у прогонов с телеметрией) — числа быстрой метки только проверяют стенд.
|
||||
|
||||
@@ -234,7 +234,7 @@ SHALL это называть. У профиля очереди CPU, тротт
|
||||
вложений и загрузка настоящего изображения. Рядом идут **редкие события с известным счётом**:
|
||||
- скачивание вложения, у которого нет объекта в S3, — 500 API со статусом ошибки span;
|
||||
- загрузка изображения, которое проходит проверку структуры и не декодируется, — 202, затем `failed` worker;
|
||||
- регистрация пользователя с Argon2id — редкий медленный маршрут;
|
||||
- регистрация пользователя с Argon2id — редкий маршрут (сохраняется ли он, если он не медленный);
|
||||
- в окне отказов — запись в чат под короткой блокировкой таблицы сообщений: медленные запросы быстрого маршрута.
|
||||
|
||||
Окна прогона: разогрев, чистое окно — по нему считается цена, — окно отказов. Ответ не повторяется. Каждый запрос — строка с
|
||||
@@ -321,7 +321,9 @@ Tempo и метрики Collector по HTTP из вспомогательног
|
||||
- что теряет каждый вариант: по классам редких событий — трассу, цельную цепочку загрузки, запись журнала, счёт в метрике и
|
||||
переход от журнала к трассе; точность квантилей из buckets; свежесть метрик при редкой отправке; объяснение причин потерь;
|
||||
- сбалансированную конфигурацию: состав, почему каждое правило, критерии и вывод по каждому из них:
|
||||
- B1 — сохранены трассы всех внесённых 500 API, медленных записей и регистраций и цепочки всех неудачных загрузок;
|
||||
- B1 — сохранены трассы всех внесённых 500 API и всех медленных по серверу записей (длительность записи доступа — та
|
||||
же величина, что server span, — не меньше 0,25 с) и цепочки всех неудачных загрузок; регистрация — редкий, но быстрый
|
||||
маршрут, у неё называется доля сохранённых трасс;
|
||||
- B2 — приём Tempo не больше 25 % варианта `full` и меньше, чем у `tail`; рядов Prometheus не больше 40 % `full`;
|
||||
- B3 — непреднамеренных потерь нет, трассы не отброшены до решения, пик памяти Collector не больше двух третей его лимита;
|
||||
- B4 — надбавка против `off`: CPU реплик на запрос не больше 25 %, p95 лёгких запросов — не больше 3 мс, p99 — не больше
|
||||
|
||||
@@ -126,10 +126,10 @@ SDK SHALL считать начатые span по решению выборки
|
||||
|
||||
#### Scenario: Ошибки и медленные запросы сохраняются
|
||||
|
||||
- **WHEN** под нагрузкой профиля со сбалансированной конфигурацией внесены 500 API, неудачные задания, медленные записи и
|
||||
регистрации
|
||||
- **THEN** в Tempo есть трасса каждого из них по `X-Request-Id`, у неудачного задания — вся цепочка от server span загрузки
|
||||
до consumer span исхода `failed`, а из остальных запросов сохранена заданная доля в биномиальном интервале
|
||||
- **WHEN** под нагрузкой профиля со сбалансированной конфигурацией внесены 500 API, неудачные задания и медленные записи
|
||||
- **THEN** в Tempo есть трасса каждого 500 и каждой записи, медленной по серверу (server span не короче 0,25 с), по
|
||||
`X-Request-Id`, у неудачного задания — вся цепочка от server span загрузки до consumer span исхода `failed`, а из
|
||||
остальных запросов, в том числе быстрых регистраций, сохранена заданная доля в биномиальном интервале
|
||||
|
||||
#### Scenario: Слой Collector меняет только выбор трасс
|
||||
|
||||
|
||||
@@ -13,81 +13,81 @@
|
||||
|
||||
## 1. Правила
|
||||
|
||||
- [ ] 1.1 Прочитать (Read) правила `telemetry.md`, `settings.md`, `logging.md`, `bench.md`, `docker.md`, `service-tests.md`,
|
||||
- [x] 1.1 Прочитать (Read) правила `telemetry.md`, `settings.md`, `logging.md`, `bench.md`, `docker.md`, `service-tests.md`,
|
||||
`run-modes.md`, `infra.md` — до правок файлов их слоёв. Проверка: каждое прочитано через Read в этой сессии.
|
||||
|
||||
## 2. Настройки и константы (3, 4)
|
||||
|
||||
- [ ] 2.1 `src/utils/constants.py`: наборы `coarse` трёх histogram (таблица решения 4), срок рядов экспортёра Collector (60 с) и
|
||||
- [x] 2.1 `src/utils/constants.py`: наборы `coarse` трёх histogram (таблица решения 4), срок рядов экспортёра Collector (60 с) и
|
||||
наибольший интервал отправки метрик (30 с), общее имя константы отбрасываемых инструментов SDK и в ней `otel.sdk.span.live`;
|
||||
перечисление набора границ (`default`, `coarse`) — `src/schemas/enums/`. Проверка: `make lint`.
|
||||
- [ ] 2.2 `src/config/settings.py`, `Telemetry`: `trace_sample_ratio` (0…1, `allow_inf_nan=False`, по умолчанию 1),
|
||||
- [x] 2.2 `src/config/settings.py`, `Telemetry`: `trace_sample_ratio` (0…1, `allow_inf_nan=False`, по умолчанию 1),
|
||||
`metric_buckets` (по умолчанию `default`), `metric_export_interval_seconds` — ещё не больше 30; докстринги со ссылками на
|
||||
решения. Проверка: тесты 2.3.
|
||||
- [ ] 2.3 `service-tests/unit/test_settings.py`: допустимые значения и отказ с именем поля на долю 1.5, −0.1 и `nan`, набор
|
||||
- [x] 2.3 `service-tests/unit/test_settings.py`: допустимые значения и отказ с именем поля на долю 1.5, −0.1 и `nan`, набор
|
||||
`fine`, интервал 60; подмена окружением `TELEMETRY__TRACE_SAMPLE_RATIO`, `TELEMETRY__METRIC_BUCKETS`. Проверка: `make
|
||||
service_test`; новые тесты красные на коде до 2.2 (вывод в отчёте apply).
|
||||
- [ ] 2.4 `config_example.toml` (`[telemetry]`: оба поля с комментарием, значения по умолчанию) и шапка `.env.example`
|
||||
- [x] 2.4 `config_example.toml` (`[telemetry]`: оба поля с комментарием, значения по умолчанию) и шапка `.env.example`
|
||||
(`OTEL_TRACES_SAMPLER`, `OTEL_TRACES_SAMPLER_ARG` → `trace_sample_ratio`; настройками не являются). Проверка: настройки читают
|
||||
`config_example.toml` как `config.toml` без ошибок (быстрый тест или разовый запуск с подменой пути), `make lint`.
|
||||
|
||||
## 3. SDK: выбор трасс, наборы границ, счёт начатых span (3, 4)
|
||||
|
||||
- [ ] 3.1 `src/infra/telemetry/sdk.py` и `core.py`: сэмплер по доле — 1 → `ParentBased(ALWAYS_ON)`, иначе
|
||||
- [x] 3.1 `src/infra/telemetry/sdk.py` и `core.py`: сэмплер по доле — 1 → `ParentBased(ALWAYS_ON)`, иначе
|
||||
`ParentBased(TraceIdRatioBased(доля))`; границы View — из набора `metric_buckets`; `TracerProvider(meter_provider=…)`, а
|
||||
`Tracer` — внутри `_internal_metrics()`; `DropAggregation` у `otel.sdk.span.live`. Модуль `sdk.py` по-прежнему единственный
|
||||
импорт SDK (ленивый импорт, JTP-7). Проверка: тесты 3.2; прежние тесты `test_telemetry.py` зелёные (те, что перечисляют метрики
|
||||
провайдера, — с `otel.sdk.span.started`).
|
||||
- [ ] 3.2 Быстрые тесты `service-tests/unit/test_telemetry.py` (получатели в памяти, без сети): доля 1 — у каждого запроса трасса;
|
||||
- [x] 3.2 Быстрые тесты `service-tests/unit/test_telemetry.py` (получатели в памяти, без сети): доля 1 — у каждого запроса трасса;
|
||||
доля 0 — server span не записан, дочерних span нет, histogram учёл запрос, запись журнала ушла с `trace_id` и флагами без бита
|
||||
выборки, а в stdout полей трассы нет; доля 0,5 с подставным генератором идентификаторов — решение по границе `trace_id`;
|
||||
удалённый выбранный родитель записывается и при доле 0, невыбранный не записывается при доле 1 (consumer span и span producer);
|
||||
`coarse` — границы histogram в экспорте равны набору, среди них 0,25 и 30; `otel.sdk.span.started` с `DROP` и
|
||||
`RECORD_AND_SAMPLE`; `otel.sdk.span.live` нет; при выключенной телеметрии — ничего. Проверка: `make service_test`; новые тесты
|
||||
красные на коде до 3.1 (вывод в отчёте apply).
|
||||
- [ ] 3.3 Записи о старте API (`src/main.py`), worker и relay — `telemetry_trace_sample_ratio`, `telemetry_metric_buckets`,
|
||||
- [x] 3.3 Записи о старте API (`src/main.py`), worker и relay — `telemetry_trace_sample_ratio`, `telemetry_metric_buckets`,
|
||||
`telemetry_metric_export_interval_seconds` (при выключенной телеметрии `null`). Проверка: быстрый тест записи о старте (или
|
||||
разбор записи `make run_dev` с `TELEMETRY__*`), `make lint`.
|
||||
|
||||
## 4. Конфигурации вариантов `bench/otel/` (5, 6, 7)
|
||||
|
||||
- [ ] 4.1 `bench/otel/tail-typical.yaml` — слой типового tail (решение 2: `status_code` `ERROR`, `latency` 250 мс, `probabilistic`
|
||||
- [x] 4.1 `bench/otel/tail-typical.yaml` — слой типового tail (решение 2: `status_code` `ERROR`, `latency` 250 мс, `probabilistic`
|
||||
10, остальное по умолчанию) и pipeline трасс `[memory_limiter, tail_sampling, batch]`; комментарии со ссылками на решения.
|
||||
Проверка: `validate` закреплённого образа Collector с рабочей конфигурацией и слоем (`--network none`) — код 0.
|
||||
- [ ] 4.2 `bench/otel/tail-balanced.yaml` — правила и параметры таблицы решения 5. Проверка: `validate` — код 0; сравнение
|
||||
- [x] 4.2 `bench/otel/tail-balanced.yaml` — правила и параметры таблицы решения 5. Проверка: `validate` — код 0; сравнение
|
||||
`print-config --format=json` без слоя и со слоем (4.4) — только процессор и список pipeline трасс.
|
||||
- [ ] 4.3 `bench/otel/prometheus-lean.yml` — копия `infra/otel/prometheus/prometheus.yml` и размеченные блоки отбора у `loki`,
|
||||
- [x] 4.3 `bench/otel/prometheus-lean.yml` — копия `infra/otel/prometheus/prometheus.yml` и размеченные блоки отбора у `loki`,
|
||||
`tempo`, `prometheus` (решение 7). Проверка: `promtool check config` в одноразовом контейнере образа Prometheus — код 0; файл без
|
||||
блоков совпадает с рабочим построчно.
|
||||
- [ ] 4.4 Проверка до стенда (`preflight` в `bench/run.py`, сравнения — в `bench/telemetry_cost.py`): оба слоя Collector —
|
||||
- [x] 4.4 Проверка до стенда (`preflight` в `bench/run.py`, сравнения — в `bench/telemetry_cost.py`): оба слоя Collector —
|
||||
`validate` и правило сравнения `print-config`; `prometheus-lean.yml` — построчная сверка вне блоков и `promtool`; поля `Profile`
|
||||
лимитов телеметрии — против `docker compose config` основного файла. Проверка: временная правка слоя (лишний процессор в pipeline
|
||||
логов) и временная правка рабочего `prometheus.yml` дают код 2 с именем файла (правки откатываются, вывод в отчёте apply).
|
||||
|
||||
## 5. Стенд `bench/`: compose, сэмплер, классы (1, 8, 10, 13)
|
||||
|
||||
- [ ] 5.1 `bench/bench.compose.yml`: `otel-collector`, `prometheus`, `loki`, `tempo`, `grafana` — `container_name`
|
||||
- [x] 5.1 `bench/bench.compose.yml`: `otel-collector`, `prometheus`, `loki`, `tempo`, `grafana` — `container_name`
|
||||
`mtusi-bench-<сервис>`, `restart: "no"`, лимиты `BENCH_COLLECTOR_*`, `BENCH_PROMETHEUS_*`, `BENCH_LOKI_*`, `BENCH_TEMPO_*` без
|
||||
swap, у Grafana — `ports: !reset []`; сеть `telemetry` — имя `mtusi-bench-telemetry`. `bench/telemetry.compose.yml` —
|
||||
`TELEMETRY__ENABLED: "true"` и адрес Collector у `api`, `worker`, `relay`. Проверка: `docker compose … config --quiet` стенда с
|
||||
третьим `-f` и без него — код 0; без него у `api`, `worker`, `relay` — `TELEMETRY__ENABLED: "false"`, как раньше.
|
||||
- [ ] 5.2 `bench/sampler.sh`: режим `cost` (решение 10) — `cg` всех контейнеров, `vm`, `mp`; без сети. Проверка: разбор строк в
|
||||
- [x] 5.2 `bench/sampler.sh`: режим `cost` (решение 10) — `cg` всех контейнеров, `vm`, `mp`; без сети. Проверка: разбор строк в
|
||||
`telemetry_cost.py --selftest`; в быстром прогоне (10.1) есть строки всех контейнеров стенда.
|
||||
- [ ] 5.3 `bench/make_images.py`: класс `bad` — байты `s` с `12` в поле точности SOF, размер и SHA-256 в JSON. Проверка: JSON
|
||||
- [x] 5.3 `bench/make_images.py`: класс `bad` — байты `s` с `12` в поле точности SOF, размер и SHA-256 в JSON. Проверка: JSON
|
||||
называет `bad`; в быстром прогоне каждая загрузка `bad` — 202, затем `failed` с `invalid_image`.
|
||||
|
||||
## 6. Нагрузка, выборка, разбор (8, 9, 11, 12)
|
||||
|
||||
- [ ] 6.1 `bench/k6/telemetry.js`: сценарии таблицы решения 8 (интенсивности — окружение), VU заранее, без повторов, строка на
|
||||
- [x] 6.1 `bench/k6/telemetry.js`: сценарии таблицы решения 8 (интенсивности — окружение), VU заранее, без повторов, строка на
|
||||
запрос `t,…` с `X-Request-Id`, `t-t0` в `setup()`; регистрация — пароль из `crypto.randomUUID()` только в памяти итерации; итог —
|
||||
`summaryFiles` без `setup_data`. Проверка: в быстром прогоне строк столько же, сколько итераций; в `raw/` нет паролей и токенов
|
||||
(`grep` по `Bearer`, `password`).
|
||||
- [ ] 6.2 `bench/telemetry_lookup.py` (только stdlib, `src` не импортирует; решение 9): `wait-ready` и `collect` — Tempo (TraceQL по
|
||||
- [x] 6.2 `bench/telemetry_lookup.py` (только stdlib, `src` не импортирует; решение 9): `wait-ready` и `collect` — Tempo (TraceQL по
|
||||
`span.messenger.request_id`, цепочки `bad`, выборка `GET /users/me`), Loki (записи по `request_id`, `trace_id` → трасса, счёт по
|
||||
`path`, `quantile_over_time`), Prometheus (`query_range` счётчиков приёма и потерь, `status/tsdb`, `status/config`), признаки
|
||||
слоёв; пул потоков; отказ на результате, равном пределу. Проверка: быстрый прогон — у каждого класса есть найденное; временно
|
||||
малый предел даёт отказ «lookup truncated» (правка откатывается).
|
||||
- [ ] 6.3 `bench/telemetry_cost.py` (только stdlib, `--selftest`): таблица вариантов, план кругами, разбор строк k6, сэмплера
|
||||
- [x] 6.3 `bench/telemetry_cost.py` (только stdlib, `--selftest`): таблица вариантов, план кругами, разбор строк k6, сэмплера
|
||||
`cost`, обхода метаданных, выборки и размера volume; окна; CPU на запрос, приём, рост, потери по звеньям, доли классов, точность
|
||||
квантилей; строки `runs.csv`, `components.csv`, `classes.csv`; правило шума, точный биномиальный интервал, вердикты H1–H8 и
|
||||
B1–B5 (таблица решения 12), пометки решения 11; `summary.md` и четыре SVG на `plots.Svg`; сверка `prometheus-lean.yml` с рабочим.
|
||||
@@ -95,64 +95,64 @@
|
||||
|
||||
## 7. Оркестратор `bench/run.py` (1, 8, 9, 11–14)
|
||||
|
||||
- [ ] 7.1 `Profile`: поля `telemetry_*` (варианты, интенсивности, окна, блокировки, порог медленного, доля `head`, интервал
|
||||
- [x] 7.1 `Profile`: поля `telemetry_*` (варианты, интенсивности, окна, блокировки, порог медленного, доля `head`, интервал
|
||||
`metrics`), лимиты сервисов телеметрии (рабочего стенда), `telemetry` (выключатель); профили `telemetry` и `telemetry_quick`
|
||||
(решения 2, 8, 14); `compose_env` — `BENCH_*` телеметрии; бюджет профиля и предупреждение CPU с телеметрией; `vm_warnings`,
|
||||
`leftovers` и `stop` — `mtusi-bench-lookup`, `mtusi-bench-du`, сеть `mtusi-bench-telemetry`; `limits()` и паспорт
|
||||
`stand.telemetry`. Проверка: `make bench_quick` — код 0, сервисов телеметрии нет, `stand.app_env` прежний.
|
||||
- [ ] 7.2 `Stand`: список `-f` — база, телеметрия, свой override (не перезаписывается целиком); старт сервисов телеметрии до
|
||||
- [x] 7.2 `Stand`: список `-f` — база, телеметрия, свой override (не перезаписывается целиком); старт сервисов телеметрии до
|
||||
приложения и `wait-ready`; `.work/variant.compose.yml` варианта; строка вложения без объекта (`copy_rows`); блокировки окна
|
||||
отказов в своей сессии `psql` с моментами `clock_timestamp()`; запуск выборки и размера volume; сверка записей о старте реплик,
|
||||
worker и relay с вариантом. Проверка: быстрый прогон (10.1) — вариант применён в каждом прогоне, отказ на подставленном неверном
|
||||
значении доли (временная правка таблицы, откат).
|
||||
- [ ] 7.3 `Bench.run_telemetry`: план в паспорт до первого прогона, прогон по решению 9 (подготовка, разогрев, сэмплер, k6,
|
||||
- [x] 7.3 `Bench.run_telemetry`: план в паспорт до первого прогона, прогон по решению 9 (подготовка, разогрев, сэмплер, k6,
|
||||
блокировки, ожидание заданий, обход метаданных, ожидание отправок, выборка, размер, уборка), пометки и отказы решения 11, запись
|
||||
строк, ETA и `progress.json`, `RESUME=1`, ненулевой код в конце при `lost`. Проверка: `make bench_telemetry_quick` — код 0;
|
||||
Ctrl+C посреди прогона — стенд удалён, метка «незавершена»; `RESUME=1` не снимает готовые прогоны.
|
||||
- [ ] 7.4 Выключатель `uploads` и `queue` (решение 13): `--telemetry on|off` в `Profile.telemetry`, не в `overrides`; сверка режима в
|
||||
- [x] 7.4 Выключатель `uploads` и `queue` (решение 13): `--telemetry on|off` в `Profile.telemetry`, не в `overrides`; сверка режима в
|
||||
`resume_problems`; у других профилей `on` — код 2 до стенда; старт телеметрии; предупреждение CPU вместо кода 2 у очереди с
|
||||
телеметрией; столбцы сервисов телеметрии в конце `cells.csv`; строка режима и «смешанное сравнение» варианта «до» в сводке
|
||||
загрузок. Проверка: 10.2; `uv run python bench/run.py --profile failover_quick --label x --telemetry on` — код 2 до стенда;
|
||||
`--resume` метки с другим режимом — код 2.
|
||||
- [ ] 7.5 `Makefile`: `bench_telemetry [TELEMETRY_LABEL=…] [RESUME=1] [VARIANTS=…]`, `bench_telemetry_quick` (метка
|
||||
- [x] 7.5 `Makefile`: `bench_telemetry [TELEMETRY_LABEL=…] [RESUME=1] [VARIANTS=…]`, `bench_telemetry_quick` (метка
|
||||
`quick-telemetry-<время>`), `TELEMETRY=on|off` у `bench_uploads`, `bench_uploads_quick`, `bench_queue`, `bench_queue_quick`,
|
||||
`$(KEEP_AWAKE)`, комментарии в стиле соседних; `.gitignore` — `evidence/telemetry-cost/quick-*/`. Проверка: `make -n` каждой
|
||||
цели; `git status` не видит быстрых меток.
|
||||
|
||||
## 8. Документы (15)
|
||||
|
||||
- [ ] 8.1 `.claude/rules/`: `bench.md` (раздел «Профиль цены телеметрии», выключатель, исключения границы чёрного ящика, правило
|
||||
- [x] 8.1 `.claude/rules/`: `bench.md` (раздел «Профиль цены телеметрии», выключатель, исключения границы чёрного ящика, правило
|
||||
бюджета CPU с телеметрией, таблица инструментов, «что не меняется» — телеметрия), `telemetry.md` (поля, `otel.sdk.span.started`,
|
||||
наборы границ, слои `bench/otel/` и их проверки, стенд `bench/`), `settings.md`, `logging.md` (запись о старте), `docker.md`
|
||||
(сервисы телеметрии на стенде `bench/`), `run-modes.md` — по необходимости. Проверка: `grep -n "trace_sample_ratio\|bench_telemetry\|metric_buckets" .claude/rules/*.md`
|
||||
находит правила; чисел метки в правилах нет.
|
||||
- [ ] 8.2 `AGENTS.md`: таблица команд (`bench_telemetry`, `bench_telemetry_quick`, `TELEMETRY=on`), карта кода (новые файлы
|
||||
- [x] 8.2 `AGENTS.md`: таблица команд (`bench_telemetry`, `bench_telemetry_quick`, `TELEMETRY=on`), карта кода (новые файлы
|
||||
`bench/`, `bench/otel/`, поля `[telemetry]`), каталог `evidence/telemetry-cost/`, текущее состояние лабы; `QUESTIONS.md` —
|
||||
решения apply в `## track1-telemetry-cost`. Проверка: `make check`.
|
||||
|
||||
## 9. Проверки кода
|
||||
|
||||
- [ ] 9.1 `make lint`, `make service_test`, `make service_test_db`, `make check`; `--selftest` модулей `bench/` (`telemetry_cost`,
|
||||
- [x] 9.1 `make lint`, `make service_test`, `make service_test_db`, `make check`; `--selftest` модулей `bench/` (`telemetry_cost`,
|
||||
`overload`, `uploads`, `reconcile`, `resources`, `scaling`, `plots`); `openspec validate track1-telemetry-cost --strict`.
|
||||
Проверка: всё — код 0.
|
||||
- [ ] 9.2 Рабочий стенд на новом коде (`make rolling_update` или `make run_docker`): «Started API», «Started worker», «Started
|
||||
- [x] 9.2 Рабочий стенд на новом коде (`make rolling_update` или `make run_docker`): «Started API», «Started worker», «Started
|
||||
relay» — доля 1, `default`, 15; `make test` — PASS; `make student_test` — красный только `test_exclusion_evidence_exists`; `driver.py
|
||||
--port 8080 telemetry-check` — код 0 (пробный прогон, вывод в scratchpad, evidence не переснимается). Проверка: выводы в отчёте
|
||||
apply.
|
||||
|
||||
## 10. Калибровка (до гипотез, на рабочем дереве)
|
||||
|
||||
- [ ] 10.1 `make stop`, `make bench_telemetry_quick`: код 0, все шесть вариантов; границы калибровки решения 8 у `full`. Нарушены —
|
||||
- [x] 10.1 `make stop`, `make bench_telemetry_quick`: код 0, все шесть вариантов; границы калибровки решения 8 у `full`. Нарушены —
|
||||
интенсивности API одним множителем (пропорции прежние), запись в design, «Уточнения apply», и в `Profile`, повтор быстрого
|
||||
прогона. Проверка: сводка быстрой метки — у `full` реплики заняты 30–60 % CPU в чистом окне, Collector, Tempo и worker — меньше
|
||||
70 %, недосланных нет, p95 времени до `ready` меньше 5 с; ETA полного профиля — в отчёте apply.
|
||||
- [ ] 10.2 `make bench_queue_quick TELEMETRY=on` и `make bench_uploads_quick TELEMETRY=on`, затем `make bench_queue_quick` без
|
||||
- [x] 10.2 `make bench_queue_quick TELEMETRY=on` и `make bench_uploads_quick TELEMETRY=on`, затем `make bench_queue_quick` без
|
||||
выключателя. Проверка: коды 0; в паспорте режим `on`; у ячеек очереди заполнены столбцы телеметрии, без выключателя — пусты и
|
||||
сервисов телеметрии нет; затем `docker compose start` рабочего стенда.
|
||||
|
||||
## 11. Гипотезы до метки
|
||||
|
||||
- [ ] 11.1 `REPORT.md`, новый раздел «Цена наблюдаемости (трек 1)»: гипотезы H1–H8 с порогами и критерии B1–B5 (решение 12),
|
||||
- [x] 11.1 `REPORT.md`, новый раздел «Цена наблюдаемости (трек 1)»: гипотезы H1–H8 с порогами и критерии B1–B5 (решение 12),
|
||||
правило шума, правило «если `balanced` не прошёл», методика (стенд, лимиты, варианты, нагрузка и окна, редкие события, источники
|
||||
измерений), рабочий стенд остаётся со 100 % трасс; чисел метки нет. Вопросы `QUESTIONS.md` к преподавателю — в «Открытые вопросы
|
||||
преподавателю». Проверка: у каждой гипотезы и критерия — порог; `make check`.
|
||||
|
||||
@@ -15,6 +15,7 @@ from fakes import (
|
||||
FakeUnitOfWork,
|
||||
)
|
||||
from src.config import settings
|
||||
from src.schemas.enums import MetricBucketsEnum
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@@ -44,6 +45,14 @@ def fixed_settings(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
{"body_timeout_seconds": 1, "max_unfinished_jobs": 0},
|
||||
),
|
||||
(settings.app, {"instance_id": "test-instance"}),
|
||||
(
|
||||
settings.telemetry,
|
||||
{
|
||||
"trace_sample_ratio": 1.0,
|
||||
"metric_buckets": MetricBucketsEnum.DEFAULT,
|
||||
"metric_export_interval_seconds": 15,
|
||||
},
|
||||
),
|
||||
)
|
||||
for section, fields in fixed:
|
||||
for name, value in fields.items():
|
||||
|
||||
@@ -12,16 +12,28 @@ from pydantic_settings import (
|
||||
BaseSettings,
|
||||
PydanticBaseSettingsSource,
|
||||
SettingsConfigDict,
|
||||
TomlConfigSettingsSource,
|
||||
)
|
||||
|
||||
from src.config.settings import Settings, Uploads, Worker
|
||||
from src.config.settings import BASE_DIR, Settings, Telemetry, Uploads, Worker
|
||||
from src.schemas.enums import MetricBucketsEnum
|
||||
from src.utils.constants import (
|
||||
API_STOP_BUDGET_SECONDS,
|
||||
CONTAINER_STOP_TIMEOUT_SECONDS,
|
||||
HTTP_DURATION_BUCKETS,
|
||||
HTTP_DURATION_BUCKETS_COARSE,
|
||||
JOB_DURATION_BUCKETS,
|
||||
JOB_DURATION_BUCKETS_COARSE,
|
||||
TELEMETRY_EXPORTER_SERIES_EXPIRATION_SECONDS,
|
||||
TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS,
|
||||
TELEMETRY_SHUTDOWN_TIMEOUT_SECONDS,
|
||||
TIME_TO_READY_BUCKETS,
|
||||
TIME_TO_READY_BUCKETS_COARSE,
|
||||
)
|
||||
from src.worker import main as worker_main
|
||||
|
||||
EXAMPLE_TOML_PATH = BASE_DIR.joinpath("config_example.toml")
|
||||
|
||||
|
||||
class _ArgumentsOnly(Settings):
|
||||
"""`Settings` без окружения, `.env` и `config.toml`."""
|
||||
@@ -94,3 +106,112 @@ def test_budgets_fit_container_stop() -> None:
|
||||
Worker(graceful_shutdown_seconds=8.01)
|
||||
worker_worst = 8 + 3 * worker_main._CLOSE_TIMEOUT_SECONDS
|
||||
assert worker_worst < CONTAINER_STOP_TIMEOUT_SECONDS
|
||||
|
||||
|
||||
# выбор трасс в голове и набор границ (design change `track1-telemetry-cost`,
|
||||
# решения 3–4; спек `service-configuration`, «Параметры телеметрии»)
|
||||
|
||||
|
||||
class _EnvironmentOnly(_ArgumentsOnly):
|
||||
"""`Settings` из окружения процесса, без `.env` и `config.toml`."""
|
||||
|
||||
@classmethod
|
||||
def settings_customise_sources(
|
||||
cls,
|
||||
settings_cls: type[BaseSettings], # noqa: ARG003
|
||||
init_settings: PydanticBaseSettingsSource,
|
||||
env_settings: PydanticBaseSettingsSource,
|
||||
*args: PydanticBaseSettingsSource, # noqa: ARG003
|
||||
**kwargs: Any, # noqa: ARG003
|
||||
) -> tuple[PydanticBaseSettingsSource, ...]:
|
||||
return (init_settings, env_settings)
|
||||
|
||||
|
||||
class _ExampleToml(_ArgumentsOnly):
|
||||
"""`Settings` только из `config_example.toml`, как из `config.toml`."""
|
||||
|
||||
model_config = SettingsConfigDict(
|
||||
**{**_ArgumentsOnly.model_config, "toml_file": EXAMPLE_TOML_PATH},
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def settings_customise_sources(
|
||||
cls,
|
||||
settings_cls: type[BaseSettings],
|
||||
init_settings: PydanticBaseSettingsSource,
|
||||
*args: PydanticBaseSettingsSource, # noqa: ARG003
|
||||
**kwargs: Any, # noqa: ARG003
|
||||
) -> tuple[PydanticBaseSettingsSource, ...]:
|
||||
return (init_settings, TomlConfigSettingsSource(settings_cls))
|
||||
|
||||
|
||||
def test_telemetry_defaults_keep_previous_behaviour() -> None:
|
||||
loaded = Telemetry()
|
||||
assert loaded.trace_sample_ratio == 1
|
||||
assert loaded.metric_buckets is MetricBucketsEnum.DEFAULT
|
||||
assert loaded.metric_export_interval_seconds == 15
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ratio", [0, 0.1, 0.5, 1])
|
||||
def test_trace_sample_ratio_accepts_range(ratio: float) -> None:
|
||||
assert Telemetry(trace_sample_ratio=ratio).trace_sample_ratio == ratio
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("field", "value"),
|
||||
[
|
||||
("trace_sample_ratio", 1.5),
|
||||
("trace_sample_ratio", -0.1),
|
||||
("trace_sample_ratio", float("nan")),
|
||||
("trace_sample_ratio", "nan"),
|
||||
("metric_buckets", "fine"),
|
||||
("metric_export_interval_seconds", 60),
|
||||
("metric_export_interval_seconds", -1),
|
||||
],
|
||||
)
|
||||
def test_wrong_telemetry_value_names_field(field: str, value: object) -> None:
|
||||
with pytest.raises(ValidationError) as caught:
|
||||
Telemetry(**{field: value})
|
||||
assert [error["loc"] for error in caught.value.errors()] == [(field,)]
|
||||
|
||||
|
||||
def test_export_interval_up_to_half_of_series_expiration() -> None:
|
||||
limit = TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS
|
||||
assert limit * 2 == TELEMETRY_EXPORTER_SERIES_EXPIRATION_SECONDS
|
||||
assert Telemetry(metric_export_interval_seconds=limit)
|
||||
with pytest.raises(ValidationError):
|
||||
Telemetry(metric_export_interval_seconds=limit + 0.1)
|
||||
|
||||
|
||||
def test_coarse_buckets_keep_slo_bounds() -> None:
|
||||
assert 0.25 in HTTP_DURATION_BUCKETS_COARSE
|
||||
assert 30 in TIME_TO_READY_BUCKETS_COARSE
|
||||
assert HTTP_DURATION_BUCKETS_COARSE[-1] == HTTP_DURATION_BUCKETS[-1]
|
||||
assert JOB_DURATION_BUCKETS_COARSE[-1] == JOB_DURATION_BUCKETS[-1]
|
||||
assert TIME_TO_READY_BUCKETS_COARSE[-1] == TIME_TO_READY_BUCKETS[-1]
|
||||
|
||||
|
||||
def test_telemetry_from_environment(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setenv("TELEMETRY__TRACE_SAMPLE_RATIO", "0.1")
|
||||
monkeypatch.setenv("TELEMETRY__METRIC_BUCKETS", "coarse")
|
||||
loaded = _EnvironmentOnly()
|
||||
assert loaded.telemetry.trace_sample_ratio == 0.1
|
||||
assert loaded.telemetry.metric_buckets is MetricBucketsEnum.COARSE
|
||||
|
||||
|
||||
def test_wrong_ratio_from_environment_names_field(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setenv("TELEMETRY__TRACE_SAMPLE_RATIO", "1.5")
|
||||
with pytest.raises(ValidationError) as caught:
|
||||
_EnvironmentOnly()
|
||||
assert [error["loc"] for error in caught.value.errors()] == [
|
||||
("telemetry", "trace_sample_ratio"),
|
||||
]
|
||||
|
||||
|
||||
def test_example_toml_loads_as_config_toml() -> None:
|
||||
"""`config_example.toml` — рабочий `config.toml` (задача 2.4)."""
|
||||
loaded = _ExampleToml()
|
||||
assert loaded.telemetry.trace_sample_ratio == 1
|
||||
assert loaded.telemetry.metric_buckets is MetricBucketsEnum.DEFAULT
|
||||
|
||||
@@ -57,12 +57,18 @@ from src.schemas.enums import (
|
||||
AttachmentErrorCode,
|
||||
AttachmentJobReason,
|
||||
JobDeliveryOutcome,
|
||||
MetricBucketsEnum,
|
||||
)
|
||||
from src.utils.constants import (
|
||||
ATTACHMENT_JOB_TYPE,
|
||||
HTTP_DURATION_BUCKETS,
|
||||
HTTP_DURATION_BUCKETS_COARSE,
|
||||
JOB_DURATION_BUCKETS_COARSE,
|
||||
METRIC_HTTP_SERVER_DURATION,
|
||||
METRIC_JOB_DURATION,
|
||||
METRIC_JOB_TIME_TO_READY,
|
||||
SERVICE_VERSION,
|
||||
TIME_TO_READY_BUCKETS_COARSE,
|
||||
)
|
||||
from src.worker import main as worker_main
|
||||
|
||||
@@ -1718,3 +1724,303 @@ def test_sdk_internal_metrics_off_without_telemetry(
|
||||
assert telemetry.start_process_telemetry(SERVICE) is False
|
||||
assert not telemetry.is_enabled()
|
||||
assert INTERNAL_METRICS_ENV not in os.environ
|
||||
|
||||
|
||||
# --- выбор трасс в голове и наборы границ ---------------------------------
|
||||
# (design change track1-telemetry-cost, решения 3–4)
|
||||
|
||||
SPAN_STARTED = "otel.sdk.span.started"
|
||||
SPAN_LIVE = "otel.sdk.span.live"
|
||||
SAMPLING_RESULT = "otel.span.sampling_result"
|
||||
PARENT_ORIGIN = "otel.span.parent.origin"
|
||||
# доля 0,5: корень выбран, если младшие 64 бита trace_id меньше 2**63
|
||||
TRACE_KEPT = (1 << 63) - 1
|
||||
TRACE_DROPPED = 1 << 63
|
||||
|
||||
|
||||
def _sampled_app() -> FastAPI:
|
||||
"""Ручка с дочерним span и записью журнала."""
|
||||
app = FastAPI()
|
||||
|
||||
@app.get("/api/v1/probe")
|
||||
async def probe() -> dict[str, str]:
|
||||
with telemetry.child_span("SELECT") as child:
|
||||
get_logger().info("Inside probe", child=child is not None)
|
||||
return {}
|
||||
|
||||
app.add_middleware(RequestContextMiddleware)
|
||||
return app
|
||||
|
||||
|
||||
async def _probe(times: int = 1) -> list[str]:
|
||||
transport = httpx.ASGITransport(app=_sampled_app())
|
||||
async with httpx.AsyncClient(
|
||||
transport=transport,
|
||||
base_url="http://test",
|
||||
) as client:
|
||||
return [
|
||||
(await client.get("/api/v1/probe")).headers["x-request-id"]
|
||||
for _ in range(times)
|
||||
]
|
||||
|
||||
|
||||
def _started(signals: Signals) -> dict[tuple[str, str], int]:
|
||||
return {
|
||||
(
|
||||
point.attributes[PARENT_ORIGIN],
|
||||
point.attributes[SAMPLING_RESULT],
|
||||
): point.value
|
||||
for point in signals.points(SPAN_STARTED)
|
||||
}
|
||||
|
||||
|
||||
def _ratio(monkeypatch: pytest.MonkeyPatch, ratio: float) -> None:
|
||||
monkeypatch.setattr(settings.telemetry, "trace_sample_ratio", ratio)
|
||||
|
||||
|
||||
async def test_ratio_one_traces_every_request(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
_ratio(monkeypatch, 1)
|
||||
signals = _start()
|
||||
try:
|
||||
request_ids = await _probe(5)
|
||||
started = _started(signals)
|
||||
spans = signals.finished_spans()
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
servers = [span for span in spans if span.kind == SpanKind.SERVER]
|
||||
assert sorted(
|
||||
span.attributes["messenger.request_id"] for span in servers
|
||||
) == sorted(request_ids)
|
||||
assert len(spans) == 10
|
||||
# отброшенных выборкой нет; живые span не отдаются
|
||||
assert started == {
|
||||
("none", "RECORD_AND_SAMPLE"): 5,
|
||||
("local", "RECORD_AND_SAMPLE"): 5,
|
||||
}
|
||||
assert signals.points(SPAN_LIVE) == []
|
||||
|
||||
|
||||
async def test_ratio_zero_keeps_metrics_and_logs(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
stdout: io.StringIO,
|
||||
) -> None:
|
||||
"""Невыбранный запрос: ни server span, ни дочерних; histogram и запись
|
||||
журнала — те же, у записи в хранилище логов `trace_id` с флагом «не
|
||||
выбрано», в stdout полей трассы нет."""
|
||||
_ratio(monkeypatch, 0)
|
||||
signals = _start()
|
||||
try:
|
||||
await _probe(3)
|
||||
points = signals.points(METRIC_HTTP_SERVER_DURATION)
|
||||
started = _started(signals)
|
||||
spans = signals.finished_spans()
|
||||
exported = [
|
||||
record
|
||||
for record in signals.finished_logs()
|
||||
if record.body == "Inside probe"
|
||||
]
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
assert spans == []
|
||||
(point,) = points
|
||||
assert point.count == 3
|
||||
assert started == {("none", "DROP"): 3}
|
||||
assert len(exported) == 3
|
||||
for record in exported:
|
||||
assert record.trace_id != 0
|
||||
assert not int(record.trace_flags) & 0x01
|
||||
assert record.attributes["child"] is False
|
||||
records = [r for r in _records(stdout) if r.get("event") == "Inside probe"]
|
||||
assert len(records) == 3
|
||||
for record in records:
|
||||
assert "trace_id" not in record
|
||||
assert "span_id" not in record
|
||||
|
||||
|
||||
async def test_ratio_half_decides_by_trace_id(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""Решение — по младшим 64 битам `trace_id` (`TraceIdRatioBased`)."""
|
||||
from opentelemetry.sdk.trace import RandomIdGenerator
|
||||
|
||||
ids = iter([TRACE_KEPT, TRACE_DROPPED])
|
||||
monkeypatch.setattr(
|
||||
RandomIdGenerator,
|
||||
"generate_trace_id",
|
||||
lambda self: next(ids), # noqa: ARG005
|
||||
)
|
||||
_ratio(monkeypatch, 0.5)
|
||||
signals = _start()
|
||||
try:
|
||||
kept, dropped = await _probe(2)
|
||||
started = _started(signals)
|
||||
spans = signals.finished_spans()
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
servers = [span for span in spans if span.kind == SpanKind.SERVER]
|
||||
(server,) = servers
|
||||
assert server.context.trace_id == TRACE_KEPT
|
||||
assert server.attributes["messenger.request_id"] == kept
|
||||
assert dropped != kept
|
||||
assert started == {
|
||||
("none", "RECORD_AND_SAMPLE"): 1,
|
||||
("none", "DROP"): 1,
|
||||
("local", "RECORD_AND_SAMPLE"): 1,
|
||||
}
|
||||
|
||||
|
||||
def test_remote_parent_flag_wins_over_ratio(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
"""Span с удалённым родителем следует его флагу: выбранный пишется и
|
||||
при доле 0, невыбранный не пишется и при доле 1 (producer и consumer)."""
|
||||
|
||||
def chain(parent: dataclasses.TraceContextDTO) -> None:
|
||||
with telemetry.producer_span(
|
||||
queue=QUEUE,
|
||||
job_type=ATTACHMENT_JOB_TYPE,
|
||||
publication=_publication(parent),
|
||||
):
|
||||
pass
|
||||
with telemetry.consumer_span(
|
||||
queue=QUEUE,
|
||||
job_type=ATTACHMENT_JOB_TYPE,
|
||||
parent=parent,
|
||||
):
|
||||
pass
|
||||
|
||||
_ratio(monkeypatch, 0)
|
||||
signals = _start()
|
||||
try:
|
||||
chain(SAVED)
|
||||
zero = signals.finished_spans()
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
assert {span.kind for span in zero} == {
|
||||
SpanKind.PRODUCER,
|
||||
SpanKind.CONSUMER,
|
||||
}
|
||||
assert {_hex(span.context.trace_id, 32) for span in zero} == {SAVED_TRACE}
|
||||
|
||||
_ratio(monkeypatch, 1)
|
||||
signals = _start()
|
||||
try:
|
||||
chain(UNSAMPLED)
|
||||
started = _started(signals)
|
||||
one = signals.finished_spans()
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
assert one == []
|
||||
assert started == {("remote", "DROP"): 2}
|
||||
|
||||
|
||||
async def test_coarse_buckets_in_export(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(
|
||||
settings.telemetry,
|
||||
"metric_buckets",
|
||||
MetricBucketsEnum.COARSE,
|
||||
)
|
||||
signals = _start()
|
||||
try:
|
||||
await _probe()
|
||||
(point,) = signals.points(METRIC_HTTP_SERVER_DURATION)
|
||||
histograms = core.job_histograms()
|
||||
assert histograms is not None
|
||||
histograms[0].record(0.3, {})
|
||||
histograms[1].record(12, {})
|
||||
(job,) = signals.points(METRIC_JOB_DURATION)
|
||||
(ready,) = signals.points(METRIC_JOB_TIME_TO_READY)
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
assert tuple(point.explicit_bounds) == HTTP_DURATION_BUCKETS_COARSE
|
||||
assert tuple(job.explicit_bounds) == JOB_DURATION_BUCKETS_COARSE
|
||||
assert tuple(ready.explicit_bounds) == TIME_TO_READY_BUCKETS_COARSE
|
||||
assert 0.25 in point.explicit_bounds
|
||||
assert 30 in ready.explicit_bounds
|
||||
|
||||
|
||||
async def test_default_buckets_unchanged() -> None:
|
||||
signals = _start()
|
||||
try:
|
||||
await _probe()
|
||||
(point,) = signals.points(METRIC_HTTP_SERVER_DURATION)
|
||||
finally:
|
||||
signals.finish()
|
||||
telemetry.remove_log_hooks()
|
||||
assert tuple(point.explicit_bounds) == HTTP_DURATION_BUCKETS
|
||||
|
||||
|
||||
def test_sampling_without_telemetry_has_nothing(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
monkeypatch.setattr(settings.telemetry, "enabled", False)
|
||||
_ratio(monkeypatch, 0.1)
|
||||
monkeypatch.setattr(
|
||||
settings.telemetry,
|
||||
"metric_buckets",
|
||||
MetricBucketsEnum.COARSE,
|
||||
)
|
||||
assert telemetry.start_process_telemetry(SERVICE) is False
|
||||
assert core.tracer() is None
|
||||
assert core.meter() is None
|
||||
|
||||
|
||||
def test_startup_fields(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Запись о старте называет долю, набор и интервал при включённой
|
||||
телеметрии и `None` при выключенной (спек `service-configuration`)."""
|
||||
_ratio(monkeypatch, 0.1)
|
||||
monkeypatch.setattr(
|
||||
settings.telemetry,
|
||||
"metric_buckets",
|
||||
MetricBucketsEnum.COARSE,
|
||||
)
|
||||
monkeypatch.setattr(settings.telemetry, "otlp_endpoint", COLLECTOR)
|
||||
assert telemetry.startup_fields(True) == {
|
||||
"telemetry_enabled": True,
|
||||
"telemetry_endpoint": COLLECTOR,
|
||||
"telemetry_environment": settings.telemetry.environment,
|
||||
"telemetry_trace_sample_ratio": 0.1,
|
||||
"telemetry_metric_buckets": "coarse",
|
||||
"telemetry_metric_export_interval_seconds": 15,
|
||||
}
|
||||
disabled = telemetry.startup_fields(False)
|
||||
assert disabled["telemetry_enabled"] is False
|
||||
assert set(disabled) == set(telemetry.startup_fields(True))
|
||||
assert all(
|
||||
value is None
|
||||
for key, value in disabled.items()
|
||||
if key != "telemetry_enabled"
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"module",
|
||||
["src/main.py", "src/worker/main.py", "src/relay/main.py"],
|
||||
)
|
||||
def test_startup_records_use_fields(module: str) -> None:
|
||||
from src.config.settings import BASE_DIR
|
||||
|
||||
source = BASE_DIR.joinpath(module).read_text(encoding="utf-8")
|
||||
assert "**telemetry.startup_fields(telemetry_enabled)" in source
|
||||
|
||||
|
||||
def test_sampler_choice() -> None:
|
||||
"""Доля 1 — тот же `ParentBased(ALWAYS_ON)`, что раньше; иначе —
|
||||
`ParentBased(TraceIdRatioBased)` (`parentbased_traceidratio`)."""
|
||||
from opentelemetry.sdk.trace.sampling import ALWAYS_ON, TraceIdRatioBased
|
||||
|
||||
always = sdk.sampler(1)
|
||||
assert always._root is ALWAYS_ON
|
||||
ratio = sdk.sampler(0.1)
|
||||
assert isinstance(ratio._root, TraceIdRatioBased)
|
||||
assert ratio._root.rate == 0.1
|
||||
|
||||
+20
-3
@@ -20,11 +20,12 @@ from pydantic_settings import (
|
||||
)
|
||||
from sqlalchemy.engine import URL
|
||||
|
||||
from src.schemas.enums import RunModeEnum
|
||||
from src.schemas.enums import MetricBucketsEnum, RunModeEnum
|
||||
from src.utils.constants import (
|
||||
API_STOP_BUDGET_SECONDS,
|
||||
INSTANCE_ID_PATTERN,
|
||||
S3_BUCKET_NAME_PATTERN,
|
||||
TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS,
|
||||
TELEMETRY_SHUTDOWN_TIMEOUT_SECONDS,
|
||||
)
|
||||
|
||||
@@ -464,7 +465,9 @@ class Telemetry(BaseModel):
|
||||
`TELEMETRY__OTLP_ENDPOINT` у реплик API, worker и relay; интервалы и
|
||||
очереди — из `config.toml`. Переменные `OTEL_*` настройками не являются: SDK
|
||||
собирается только из этих полей. Уборщик, миграции и команда replay секцию
|
||||
не применяют.
|
||||
не применяют. Доля выбора трасс и набор границ — design change
|
||||
`track1-telemetry-cost`, решения 3–4: значения по умолчанию сохраняют
|
||||
прежнее поведение, другие задаёт профиль цены телеметрии стенда `bench/`.
|
||||
"""
|
||||
|
||||
# выключена — ни провайдеров SDK, ни отправки, ни полей трассы в журнале
|
||||
@@ -473,10 +476,24 @@ class Telemetry(BaseModel):
|
||||
otlp_endpoint: str = "http://127.0.0.1:4318"
|
||||
# deployment.environment.name ресурса
|
||||
environment: str = Field(default="lab", pattern=r"^[a-z0-9._-]{1,32}$")
|
||||
# секунды между отправками метрик
|
||||
# доля корней трасс, выбранных в голове по trace_id (0…1; 1 — все,
|
||||
# `ParentBased(ALWAYS_ON)`); span с родителем следует флагу родителя
|
||||
# (design change `track1-telemetry-cost`, решение 3)
|
||||
trace_sample_ratio: float = Field(
|
||||
default=1.0,
|
||||
ge=0,
|
||||
le=1,
|
||||
allow_inf_nan=False,
|
||||
)
|
||||
# набор границ histogram: `default` — прежние, `coarse` — меньше границ с
|
||||
# теми же границами SLO (решение 4)
|
||||
metric_buckets: MetricBucketsEnum = MetricBucketsEnum.DEFAULT
|
||||
# секунды между отправками метрик; не больше половины срока рядов
|
||||
# экспортёра Collector (решение 4), иначе ряд пропадал бы между отправками
|
||||
metric_export_interval_seconds: float = Field(
|
||||
default=15,
|
||||
gt=0,
|
||||
le=TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS,
|
||||
allow_inf_nan=False,
|
||||
)
|
||||
# секунды на одну отправку пакета экспортёром
|
||||
|
||||
@@ -32,7 +32,7 @@ from src.infra.telemetry.metrics import (
|
||||
observe_queue,
|
||||
observe_worker,
|
||||
)
|
||||
from src.infra.telemetry.setup import start_process_telemetry
|
||||
from src.infra.telemetry.setup import start_process_telemetry, startup_fields
|
||||
|
||||
__all__ = [
|
||||
"Exporters",
|
||||
@@ -57,5 +57,6 @@ __all__ = [
|
||||
"server_span",
|
||||
"shutdown",
|
||||
"start_process_telemetry",
|
||||
"startup_fields",
|
||||
"wait_closed",
|
||||
]
|
||||
|
||||
@@ -131,10 +131,8 @@ def start(
|
||||
SERVICE_VERSION,
|
||||
)
|
||||
_state = _State(
|
||||
tracer=providers.tracer_provider.get_tracer(
|
||||
TELEMETRY_SCOPE,
|
||||
SERVICE_VERSION,
|
||||
),
|
||||
# собран `sdk.build` в окне внутренних метрик: счёт начатых span
|
||||
tracer=providers.tracer,
|
||||
meter=meter,
|
||||
otel_logger=providers.logger_provider.get_logger(
|
||||
TELEMETRY_SCOPE,
|
||||
|
||||
+71
-28
@@ -8,12 +8,15 @@ replay модулей SDK, protobuf и HTTP-клиента экспортёра
|
||||
|
||||
Всё — из `[telemetry]` (design change `otel-telemetry`, решение 8): ресурс
|
||||
конструктором без детекторов, у параметров явные значения, `atexit` SDK
|
||||
выключен. Sampler — `ParentBased(ALWAYS_ON)` (решение 5): корни выбираются
|
||||
всегда, удалённый родитель из задания передаёт свой флаг выборки.
|
||||
выключен. Sampler — `ParentBased(ALWAYS_ON)` (решение 5) при доле 1, иначе
|
||||
`ParentBased(TraceIdRatioBased)` по `[telemetry] trace_sample_ratio` (design
|
||||
change `track1-telemetry-cost`, решение 3): удалённый родитель из задания
|
||||
передаёт свой флаг выборки. Границы histogram — набор `metric_buckets`.
|
||||
|
||||
Внутренние метрики SDK (design change `slo-alerts`, решения 8–9): процессоры
|
||||
span и журнала и экспортёры OTLP span и журнала считают отброшенное и
|
||||
неудачные отправки в `MeterProvider` процесса. SDK 1.45 включает их только
|
||||
неудачные отправки в `MeterProvider` процесса, а `Tracer` — начатые span по
|
||||
решению выборки (`otel.sdk.span.started`, track1-telemetry-cost). SDK 1.45 включает их только
|
||||
переменной окружения в конструкторе, поэтому код ставит её на время их сборки
|
||||
(`_internal_metrics`) — внешние `OTEL_*` к этому моменту уже удалены.
|
||||
"""
|
||||
@@ -61,24 +64,36 @@ from opentelemetry.sdk.metrics.view import (
|
||||
from opentelemetry.sdk.resources import Resource
|
||||
from opentelemetry.sdk.trace import SpanLimits, TracerProvider
|
||||
from opentelemetry.sdk.trace.export import BatchSpanProcessor
|
||||
from opentelemetry.sdk.trace.sampling import ALWAYS_ON, ParentBased
|
||||
from opentelemetry.sdk.trace.sampling import (
|
||||
ALWAYS_ON,
|
||||
ParentBased,
|
||||
Sampler,
|
||||
TraceIdRatioBased,
|
||||
)
|
||||
from opentelemetry.trace import Tracer
|
||||
|
||||
from src.config.settings import Telemetry as TelemetrySettings
|
||||
from src.schemas.enums import MetricBucketsEnum
|
||||
from src.utils.constants import (
|
||||
HTTP_DURATION_BUCKETS,
|
||||
HTTP_DURATION_BUCKETS_COARSE,
|
||||
JOB_DURATION_BUCKETS,
|
||||
JOB_DURATION_BUCKETS_COARSE,
|
||||
METRIC_HTTP_SERVER_DURATION,
|
||||
METRIC_JOB_DURATION,
|
||||
METRIC_JOB_TIME_TO_READY,
|
||||
SERVICE_VERSION,
|
||||
TELEMETRY_LOG_ATTRIBUTE_LENGTH,
|
||||
TELEMETRY_LOGS_PATH,
|
||||
TELEMETRY_MAX_ATTRIBUTES,
|
||||
TELEMETRY_METRICS_PATH,
|
||||
TELEMETRY_SDK_DROPPED_HISTOGRAMS,
|
||||
TELEMETRY_SCOPE,
|
||||
TELEMETRY_SDK_DROPPED_INSTRUMENTS,
|
||||
TELEMETRY_SDK_INTERNAL_METRICS_ENV,
|
||||
TELEMETRY_SPAN_ATTRIBUTE_LENGTH,
|
||||
TELEMETRY_TRACES_PATH,
|
||||
TIME_TO_READY_BUCKETS,
|
||||
TIME_TO_READY_BUCKETS_COARSE,
|
||||
)
|
||||
|
||||
# все инструменты — cumulative: Prometheus забирает накопленное (решение 3)
|
||||
@@ -93,11 +108,19 @@ _CUMULATIVE = dict.fromkeys(
|
||||
),
|
||||
AggregationTemporality.CUMULATIVE,
|
||||
)
|
||||
# границы buckets histogram по имени инструмента
|
||||
# границы buckets histogram по набору и имени инструмента (design change
|
||||
# `track1-telemetry-cost`, решение 4)
|
||||
_BUCKETS = {
|
||||
METRIC_HTTP_SERVER_DURATION: HTTP_DURATION_BUCKETS,
|
||||
METRIC_JOB_DURATION: JOB_DURATION_BUCKETS,
|
||||
METRIC_JOB_TIME_TO_READY: TIME_TO_READY_BUCKETS,
|
||||
MetricBucketsEnum.DEFAULT: {
|
||||
METRIC_HTTP_SERVER_DURATION: HTTP_DURATION_BUCKETS,
|
||||
METRIC_JOB_DURATION: JOB_DURATION_BUCKETS,
|
||||
METRIC_JOB_TIME_TO_READY: TIME_TO_READY_BUCKETS,
|
||||
},
|
||||
MetricBucketsEnum.COARSE: {
|
||||
METRIC_HTTP_SERVER_DURATION: HTTP_DURATION_BUCKETS_COARSE,
|
||||
METRIC_JOB_DURATION: JOB_DURATION_BUCKETS_COARSE,
|
||||
METRIC_JOB_TIME_TO_READY: TIME_TO_READY_BUCKETS_COARSE,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
@@ -106,6 +129,20 @@ class Providers:
|
||||
tracer_provider: TracerProvider
|
||||
meter_provider: MeterProvider
|
||||
logger_provider: LoggerProvider
|
||||
# tracer собран в окне внутренних метрик: счёт начатых span по решению
|
||||
# выборки (`otel.sdk.span.started`)
|
||||
tracer: Tracer
|
||||
|
||||
|
||||
def sampler(ratio: float) -> Sampler:
|
||||
"""Выбор корня трассы (design change `track1-telemetry-cost`, решение 3):
|
||||
доля 1 — прежний `ParentBased(ALWAYS_ON)`, иначе
|
||||
`ParentBased(TraceIdRatioBased)` (`parentbased_traceidratio`). Span с
|
||||
родителем — локальным или удалённым из задания — следует флагу родителя:
|
||||
цепочка загрузки выбирается целиком."""
|
||||
if ratio >= 1:
|
||||
return ParentBased(ALWAYS_ON)
|
||||
return ParentBased(TraceIdRatioBased(ratio))
|
||||
|
||||
|
||||
@contextmanager
|
||||
@@ -162,12 +199,13 @@ def build(
|
||||
boundaries=boundaries,
|
||||
),
|
||||
)
|
||||
for name, boundaries in _BUCKETS.items()
|
||||
for name, boundaries in _BUCKETS[config.metric_buckets].items()
|
||||
),
|
||||
# гистограммы самого SDK для учёта потерь не нужны (решение 8)
|
||||
# гистограммы самого SDK для учёта потерь и счётчик живых span не
|
||||
# нужны (решение 8; track1-telemetry-cost, решение 3)
|
||||
*(
|
||||
View(instrument_name=name, aggregation=DropAggregation())
|
||||
for name in TELEMETRY_SDK_DROPPED_HISTOGRAMS
|
||||
for name in TELEMETRY_SDK_DROPPED_INSTRUMENTS
|
||||
),
|
||||
],
|
||||
)
|
||||
@@ -200,23 +238,27 @@ def build(
|
||||
max_queue_size=config.max_queue_size,
|
||||
meter_provider=meter_provider,
|
||||
)
|
||||
tracer_provider = TracerProvider(
|
||||
sampler=sampler(config.trace_sample_ratio),
|
||||
resource=attributes,
|
||||
shutdown_on_exit=False,
|
||||
span_limits=SpanLimits(
|
||||
max_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_events=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_links=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_span_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_event_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_link_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_attribute_length=TELEMETRY_SPAN_ATTRIBUTE_LENGTH,
|
||||
max_span_attribute_length=TELEMETRY_SPAN_ATTRIBUTE_LENGTH,
|
||||
),
|
||||
meter_provider=meter_provider,
|
||||
)
|
||||
tracer_provider.add_span_processor(span_processor)
|
||||
# счёт начатых span включает конструктор `Tracer` (SDK 1.45) — в
|
||||
# окне, как у процессоров (track1-telemetry-cost, решение 3)
|
||||
tracer = tracer_provider.get_tracer(TELEMETRY_SCOPE, SERVICE_VERSION)
|
||||
|
||||
tracer_provider = TracerProvider(
|
||||
sampler=ParentBased(ALWAYS_ON),
|
||||
resource=attributes,
|
||||
shutdown_on_exit=False,
|
||||
span_limits=SpanLimits(
|
||||
max_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_events=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_links=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_span_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_event_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_link_attributes=TELEMETRY_MAX_ATTRIBUTES,
|
||||
max_attribute_length=TELEMETRY_SPAN_ATTRIBUTE_LENGTH,
|
||||
max_span_attribute_length=TELEMETRY_SPAN_ATTRIBUTE_LENGTH,
|
||||
),
|
||||
)
|
||||
tracer_provider.add_span_processor(span_processor)
|
||||
logger_provider = LoggerProvider(
|
||||
resource=attributes,
|
||||
shutdown_on_exit=False,
|
||||
@@ -230,6 +272,7 @@ def build(
|
||||
tracer_provider=tracer_provider,
|
||||
meter_provider=meter_provider,
|
||||
logger_provider=logger_provider,
|
||||
tracer=tracer,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@@ -12,6 +12,29 @@ from src.utils.constants import CGROUP_ROOT
|
||||
logger: AbstractLogger = get_logger().bind(module="telemetry")
|
||||
|
||||
|
||||
def startup_fields(enabled: bool) -> dict[str, object]:
|
||||
"""Поля телеметрии записи о старте API, worker и relay: включена ли, а при
|
||||
включённой — адрес Collector, окружение, доля выбора трасс, набор границ
|
||||
histogram и интервал отправки метрик; при выключенной — `None` (design
|
||||
change `track1-telemetry-cost`, решение 3: по ним профиль цены телеметрии
|
||||
сверяет, что вариант применён)."""
|
||||
config = settings.telemetry
|
||||
return {
|
||||
"telemetry_enabled": enabled,
|
||||
"telemetry_endpoint": config.otlp_endpoint if enabled else None,
|
||||
"telemetry_environment": config.environment if enabled else None,
|
||||
"telemetry_trace_sample_ratio": (
|
||||
config.trace_sample_ratio if enabled else None
|
||||
),
|
||||
"telemetry_metric_buckets": (
|
||||
config.metric_buckets.value if enabled else None
|
||||
),
|
||||
"telemetry_metric_export_interval_seconds": (
|
||||
config.metric_export_interval_seconds if enabled else None
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def start_process_telemetry(
|
||||
service_name: str,
|
||||
*,
|
||||
|
||||
+1
-7
@@ -73,13 +73,7 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
|
||||
uploads_wait_timeout_seconds=settings.uploads.wait_timeout_seconds,
|
||||
uploads_body_timeout_seconds=settings.uploads.body_timeout_seconds,
|
||||
uploads_max_unfinished_jobs=settings.uploads.max_unfinished_jobs,
|
||||
telemetry_enabled=telemetry_enabled,
|
||||
telemetry_endpoint=(
|
||||
settings.telemetry.otlp_endpoint if telemetry_enabled else None
|
||||
),
|
||||
telemetry_environment=(
|
||||
settings.telemetry.environment if telemetry_enabled else None
|
||||
),
|
||||
**telemetry.startup_fields(telemetry_enabled),
|
||||
)
|
||||
try:
|
||||
yield
|
||||
|
||||
+1
-7
@@ -223,13 +223,7 @@ async def run() -> int:
|
||||
database_port=settings.database.port,
|
||||
database_name=namespace,
|
||||
database_pool_size=settings.database.pool_size,
|
||||
telemetry_enabled=telemetry_enabled,
|
||||
telemetry_endpoint=(
|
||||
settings.telemetry.otlp_endpoint if telemetry_enabled else None
|
||||
),
|
||||
telemetry_environment=(
|
||||
settings.telemetry.environment if telemetry_enabled else None
|
||||
),
|
||||
**telemetry.startup_fields(telemetry_enabled),
|
||||
)
|
||||
await _serve(service, stop=stop, snapshots=snapshots)
|
||||
finally:
|
||||
|
||||
@@ -11,7 +11,7 @@ from .attachment import (
|
||||
ReconcileFinding,
|
||||
ReconcileStrategy,
|
||||
)
|
||||
from .settings import RunModeEnum
|
||||
from .settings import MetricBucketsEnum, RunModeEnum
|
||||
|
||||
__all__ = [
|
||||
"AttachmentErrorCode",
|
||||
@@ -22,6 +22,7 @@ __all__ = [
|
||||
"ImageType",
|
||||
"JobDeliveryOutcome",
|
||||
"JobOutcome",
|
||||
"MetricBucketsEnum",
|
||||
"ReconcileAction",
|
||||
"ReconcileFinding",
|
||||
"ReconcileStrategy",
|
||||
|
||||
@@ -6,3 +6,12 @@ class RunModeEnum(StrEnum):
|
||||
|
||||
CONSOLE = "console"
|
||||
DOCKER = "docker"
|
||||
|
||||
|
||||
class MetricBucketsEnum(StrEnum):
|
||||
"""Набор границ histogram (design change `track1-telemetry-cost`, решение
|
||||
4): `default` — прежние границы, `coarse` — меньше границ при тех же
|
||||
диапазонах и границах SLO."""
|
||||
|
||||
DEFAULT = "default"
|
||||
COARSE = "coarse"
|
||||
|
||||
+20
-2
@@ -290,12 +290,30 @@ CGROUP_ROOT = "/sys/fs/cgroup"
|
||||
# решения 8–9): SDK 1.45 читает эту переменную в конструкторах процессоров и
|
||||
# экспортёров OTLP; код ставит её только на время их сборки
|
||||
TELEMETRY_SDK_INTERNAL_METRICS_ENV = "OTEL_PYTHON_SDK_INTERNAL_METRICS_ENABLED"
|
||||
# гистограммы длительности самого SDK: для учёта не нужны и множат ряды
|
||||
TELEMETRY_SDK_DROPPED_HISTOGRAMS = (
|
||||
# инструменты самого SDK, которые не отдаются (`DropAggregation`):
|
||||
# гистограммы длительности для учёта не нужны и множат ряды, счётчик живых
|
||||
# span — тоже (design change `track1-telemetry-cost`, решение 3)
|
||||
TELEMETRY_SDK_DROPPED_INSTRUMENTS = (
|
||||
"otel.sdk.exporter.operation.duration",
|
||||
"otel.sdk.metric_reader.collection.duration",
|
||||
"otel.sdk.span.live",
|
||||
)
|
||||
|
||||
# цена телеметрии (design change `track1-telemetry-cost`, решения 3–4)
|
||||
# секунды, после которых экспортёр `prometheus` Collector перестаёт отдавать
|
||||
# необновлённый ряд (`metric_expiration` в infra/otel/collector.yaml)
|
||||
TELEMETRY_EXPORTER_SERIES_EXPIRATION_SECONDS = 60
|
||||
# наибольший интервал отправки метрик SDK — половина срока рядов: иначе ряд
|
||||
# пропадал бы между отправками
|
||||
TELEMETRY_METRIC_EXPORT_INTERVAL_MAX_SECONDS = (
|
||||
TELEMETRY_EXPORTER_SERIES_EXPIRATION_SECONDS // 2
|
||||
)
|
||||
# набор границ `coarse`: те же диапазоны, вдвое меньше границ; границы SLO
|
||||
# (0,25 с у длительности HTTP, 30 с у времени до готовности) сохранены
|
||||
HTTP_DURATION_BUCKETS_COARSE = (0.005, 0.025, 0.1, 0.25, 1, 5, 30)
|
||||
JOB_DURATION_BUCKETS_COARSE = (0.05, 0.25, 1, 5, 20, 60)
|
||||
TIME_TO_READY_BUCKETS_COARSE = (0.5, 2.5, 10, 30, 120, 600)
|
||||
|
||||
# хранилище объектов (S3)
|
||||
# имя bucket по правилам S3: 3–63 символа, строчные латинские буквы,
|
||||
# цифры, точка и дефис, по краям — буква или цифра
|
||||
|
||||
+1
-7
@@ -142,13 +142,7 @@ async def run() -> int:
|
||||
database_port=settings.database.port,
|
||||
database_name=namespace,
|
||||
database_pool_size=settings.database.pool_size,
|
||||
telemetry_enabled=telemetry_enabled,
|
||||
telemetry_endpoint=(
|
||||
settings.telemetry.otlp_endpoint if telemetry_enabled else None
|
||||
),
|
||||
telemetry_environment=(
|
||||
settings.telemetry.environment if telemetry_enabled else None
|
||||
),
|
||||
**telemetry.startup_fields(telemetry_enabled),
|
||||
)
|
||||
await _serve(make_service, namespace=namespace, stop=stop, load=load)
|
||||
finally:
|
||||
|
||||
Reference in New Issue
Block a user