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:
2026-11-14 19:17:25 +03:00
co-authored by Claude Opus 5.5
parent 37f86801d6
commit 509afca89e
43 changed files with 5784 additions and 159 deletions
+82 -1
View File
@@ -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
+7
View File
@@ -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`;
+6 -1
View File
@@ -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» — после
+8 -2
View File
@@ -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, приложение их не читает.
+37 -7
View File
@@ -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`).
+3
View File
@@ -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 её
# нет: консоль — без телеметрии.
+2
View File
@@ -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 на пробных метках
+25 -9
View File
@@ -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 на запрос старых и новых реплик)
+31 -6
View File
@@ -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
+25
View File
@@ -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`, «Результаты»).
+129
View File
@@ -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 | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
+56
View File
@@ -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
+229
View File
@@ -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
View File
@@ -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,
+85
View File
@@ -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
+59
View File
@@ -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]
+33
View File
@@ -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]
+50
View File
@@ -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
View File
File diff suppressed because it is too large Load Diff
+10 -2
View File
@@ -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
+23
View File
@@ -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
+625
View File
@@ -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:]))
+18
View File
@@ -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
View File
@@ -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 меняет только выбор трасс
+30 -30
View File
@@ -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`.
+9
View File
@@ -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():
+122 -1
View File
@@ -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
+306
View File
@@ -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
View File
@@ -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,
)
# секунды на одну отправку пакета экспортёром
+2 -1
View File
@@ -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",
]
+2 -4
View File
@@ -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
View File
@@ -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,
)
+23
View File
@@ -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
View File
@@ -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
View File
@@ -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:
+2 -1
View File
@@ -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",
+9
View File
@@ -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
View File
@@ -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
View File
@@ -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: