From 72e2598d28471a698f024ab62de28801edfdb184 Mon Sep 17 00:00:00 2001 From: roman Date: Wed, 11 Nov 2026 20:53:13 +0300 Subject: [PATCH] fix: address job-trace-propagation verify findings Co-Authored-By: Claude Opus 5.5 --- .claude/rules/docker.md | 4 +- .claude/rules/run-modes.md | 3 +- .claude/rules/telemetry.md | 6 + .claude/skills/run-mtusi-messenger/SKILL.md | 20 ++- .claude/skills/run-mtusi-messenger/driver.py | 162 +++++++++++++----- AGENTS.md | 4 +- QUESTIONS.md | 23 +++ REPORT.md | 13 +- evidence/telemetry/budget.md | 16 +- .../dashboards/messenger-overview.json | 18 +- .../changes/job-trace-propagation/design.md | 37 +++- .../specs/observability/spec.md | 12 +- .../changes/job-trace-propagation/tasks.md | 37 ++++ service-tests/unit/test_attachment_relay.py | 44 +++++ service-tests/unit/test_telemetry.py | 11 ++ src/infra/broker/client.py | 10 +- src/relay/main.py | 14 +- 17 files changed, 355 insertions(+), 79 deletions(-) diff --git a/.claude/rules/docker.md b/.claude/rules/docker.md index f9fa5eb..84e5d84 100644 --- a/.claude/rules/docker.md +++ b/.claude/rules/docker.md @@ -422,7 +422,9 @@ Design change `otel-telemetry`, решения 1, 7, 14–20; правила к - **`restart.sh`** сервисы телеметрии не трогает (решение 6). - **Суммы:** постоянные лимиты 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`. + Tempo 640, Grafana 512); пики и правило «лимит ≥ 1,5 × пика» — `evidence/telemetry/budget.md`; + пик — `memory.peak`, а если он с файловым кэшем не проходит правило — `anon` + `kernel` + `shmem` + (`telemetry.md`, «Что считать пиком»). У Tempo пик упирается в `GOMEMLIMIT` (398 из 400 МиБ): его лимит — не меньше 1,5 × `GOMEMLIMIT`, а не «`GOMEMLIMIT` — 80 % лимита» (design change `otel-telemetry`, «Уточнения apply», п. 19). До ВМ остаётся 254 МиБ: новый сервис или поднятый лимит — с пересчётом. Соединений PostgreSQL телеметрия не добавляет. diff --git a/.claude/rules/run-modes.md b/.claude/rules/run-modes.md index 09c586f..6332221 100644 --- a/.claude/rules/run-modes.md +++ b/.claude/rules/run-modes.md @@ -102,7 +102,8 @@ access_log=False)`. Импорты в `src/__main__.py` — внутри `if __n Design change `otel-telemetry`, решения 8, 13, 20, и `job-trace-propagation`, решения 7, 15. Консоль (`make run_dev`, `make run_worker`, `make run_relay`) — без телеметрии: «Started API», «Started worker» и «Started relay» говорят `telemetry_enabled: false`, к `127.0.0.1:4318` -обращений нет, модулей SDK в процессе нет. На стенде compose её включает окружение `api`, +обращений нет, модулей SDK трасс и журнала, экспортёра и protobuf в процессе нет (модули SDK +метрик грузит сам redis-py — не больше, чем `import redis.asyncio`). На стенде compose её включает окружение `api`, `worker` и `relay`; `make test_isolated`, стенд отказов и `bench/` выключают её у всех трёх. Relay закрывает SDK в окне `gather` закрытия клиентов (0,5 с), «Stopped relay» — после него: худший случай остановки прежний. diff --git a/.claude/rules/telemetry.md b/.claude/rules/telemetry.md index 4d755ae..ba62e3e 100644 --- a/.claude/rules/telemetry.md +++ b/.claude/rules/telemetry.md @@ -114,6 +114,12 @@ paths: (`evidence/telemetry/budget.md`). Если пик упирается в `GOMEMLIMIT` (Tempo: 398 из 400 МиБ под `make student_test`), 80 % с правилом 1,5 × несовместимы: лимит — не меньше 1,5 × `GOMEMLIMIT` (Tempo 640 МиБ при 400). Пик меряется под `make test` + `make load` + `make student_test`. +- **Что считать пиком** (verify change `job-trace-propagation`, W5): `memory.peak` cgroup — верхняя + граница, в неё входит файловый кэш (`file` в `memory.stat`), который ядро освобождает до OOM. + 1,5 × `memory.peak` ≤ лимита — правило выполнено. Если нет, пик — неосвобождаемая часть + `anon` + `kernel` + `shmem` из `memory.stat` (наибольшая за прогон, хотя бы в конце), и лимит не + меньше 1,5 × её; в `budget.md` — оба числа и `file`. Grafana после рестарта: `memory.peak` 343 МиБ, + из них `file` 95, `anon` + `kernel` + `shmem` ≈ 197 — лимит 512 достаточен. ## Проверки diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index f2b1283..16e51ac 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -480,7 +480,9 @@ python3 .claude/skills/run-mtusi-messenger/driver.py stand-from-scratch --runs 2 ``` - **`trace-chain`** — сквозная трасса загрузки и сигналы уровня 4, всё через HTTP API Grafana: - 1) `docker compose stop worker`, три загрузки — `outbox` + `published` в + 1) предусловие — глубина очереди 0 в Prometheus за 120 с (не дождались — код 2 «stand is not + quiet»: незавершённые задания других прогонов), `docker compose stop worker`, три загрузки — + `outbox` + `published` в `messenger_queue_depth{job="messenger-relay"}` = 3, возраст старейшего не меньше времени с первой загрузки минус 35 с и растёт; `docker start` worker — все `ready`, глубина и возраст 0; 2) worker остановлен, загрузка F (её `X-Request-Id` R), задание опубликовано (PostgreSQL, @@ -497,12 +499,13 @@ python3 .claude/skills/run-mtusi-messenger/driver.py stand-from-scratch --runs 2 `attachment_id` (одна строка своего вложения), `docker start` relay — `ready`, у worker другой `trace_id`, корень — consumer span, span producer нет; 5) пулы (10 у реплик, 2 у worker, 1 у relay; занятых не больше), ёмкость worker 2, ряды очереди только у relay, пределы контейнеров - = `docker inspect` (`NanoCpus`, `Memory`), память меньше предела, нет `docker.sock` в + = `docker inspect` (`NanoCpus`, `Memory`), память меньше предела, CPU каждого контейнера + вырос за прогон (`increase(container_cpu_time_seconds_total[…])` > 0), нет `docker.sock` в `docker compose config`, запросы панелей уровня 4 без ошибок и с данными, время до `ready` выросло на число загрузок без replay (счётчики двух процессов worker: после перезапуска Prometheus не видит сброса, если новый процесс насчитал больше), сумма — не меньше 3 × время остановки worker. В `finally` — `unpause s3`, worker и relay запущены. Код 0 / 1, 2 — нет - стенда или Grafana. Рабочий стенд, ~5 мин; `docker start`, а не `compose start`: тот поднял + стенда или Grafana либо стенд не тихий. Рабочий стенд, ~5 мин; `docker start`, а не `compose start`: тот поднял бы зависимости, в том числе замороженный S3. - **`telemetry-check`** — всё через HTTP API Grafana (источники-прокси Prometheus, Loki, Tempo): @@ -529,11 +532,12 @@ python3 .claude/skills/run-mtusi-messenger/driver.py stand-from-scratch --runs 2 трасса и значение ряда. Код 0 / 1, 2 — нет стенда или Grafana. - **`telemetry-outage`** — Collector `stop`, затем `pause`: `make test`, загрузка до `ready`, число записей логгеров `opentelemetry.*` в stdout за окно (не больше одной на логгер в минуту), - `docker stop` одной реплики и `docker compose stop worker` (время, код, «Stopped API», «Stopped - worker»), с change `job-trace-propagation` — relay без перезапусков (`StartedAt`, - `RestartCount`) и `docker stop` relay (быстрее 10 с, код 0, «Stopped relay»), `make replicas`, - worker и relay снова запущены, возврат Collector — новые запись, трасса (и span producer - relay) и ряды API, worker и relay; затем все сервисы телеметрии остановлены — `docker compose + возврат Collector — новые запись, трасса (и span producer relay) и ряды API, worker и relay при + прежних `StartedAt` и `RestartCount` всех контейнеров `api`, `worker` и `relay` (без + перезапусков, verify W2); затем Collector снова недоступен тем же способом, `make test`, + `docker stop` одной реплики, `docker compose stop worker` и `docker stop` relay (время меньше + 10 с, код 0, «Stopped API», «Stopped worker», «Stopped relay»), `make replicas`, worker и + relay снова запущены, возврат Collector; затем все сервисы телеметрии остановлены — `docker compose restart api worker relay` («Started relay» с телеметрией), `make test`, возврат. В `finally` — `unpause`, `start` телеметрии, `make replicas`, worker и relay. - **`stand-from-scratch`** — только свой одноразовый проект: `--project` принимает лишь имя diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index 0d609d7..953a8f9 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -11353,8 +11353,9 @@ def telemetry_outage(port: int, grafana: Grafana) -> int: for mode in ("stop", "pause"): prefix = f"[collector {mode}] " since = time.time() - relay_before = relay_state() + states_before = app_states() action = "stop" if mode == "stop" else "pause" + back_action = "start" if mode == "stop" else "unpause" compose(action, "otel-collector") print(f"{prefix}docker compose {action} otel-collector", flush=True) code, last = make_test(port) @@ -11417,6 +11418,51 @@ def telemetry_outage(port: int, grafana: Grafana) -> int: ), ], ) + # сигналы возвращаются к тем же процессам: ни одного перезапуска api, + # worker и relay с начала недоступности (verify W2, сценарий + # «Collector недоступен для relay») + back = time.time() + compose(back_action, "otel-collector") + print(f"{prefix}otel-collector back", flush=True) + add( + [ + (prefix + row[0], row[1], row[2]) + for row in signals_back(grafana, port, token, chat_id, back) + ], + ) + states_after = app_states() + print( + f"{prefix}containers (StartedAt, RestartCount): " + f"{len(states_before)} before, {len(states_after)} after", + flush=True, + ) + add( + [ + ( + prefix + "api, worker and relay start time and restarts " + "unchanged", + "yes", + yes(bool(states_before) and states_after == states_before), + ), + ], + ) + # остановка при недоступном Collector — второе окно того же вида: в + # буферах SDK данные свежего make test + compose(action, "otel-collector") + print( + f"{prefix}docker compose {action} otel-collector (stops)", + flush=True, + ) + code, last = make_test(port) + add( + [ + ( + prefix + "make test before stops", + "0 PASS", + f"{code} {last.split(':')[0]}", + ), + ], + ) replica = service_ids("api")[0] took, exit_code, stopped, _ = timed_stop(replica) print( @@ -11472,19 +11518,8 @@ def telemetry_outage(port: int, grafana: Grafana) -> int: ), ], ) - # relay только что опубликовал задание загрузки (design change - # job-trace-propagation, решение 15): без перезапусков, остановка в срок - add( - [ - ( - prefix + "relay start time and restarts unchanged", - "yes", - yes( - bool(relay_before) and relay_state() == relay_before, - ), - ), - ], - ) + # relay только что опубликовал задание make test (design change + # job-trace-propagation, решение 15): остановка в срок relay = service_ids("relay")[0] took, exit_code, stopped, _ = timed_stop(relay) print(f"{prefix}docker stop relay: {took:.2f} s", flush=True) @@ -11510,15 +11545,8 @@ def telemetry_outage(port: int, grafana: Grafana) -> int: ], ) add([(prefix + "LB ready", "yes", yes(wait_lb_ready(port)))]) - back = time.time() - compose("start" if mode == "stop" else "unpause", "otel-collector") - print(f"{prefix}otel-collector back", flush=True) - add( - [ - (prefix + row[0], row[1], row[2]) - for row in signals_back(grafana, port, token, chat_id, back) - ], - ) + compose(back_action, "otel-collector") + print(f"{prefix}otel-collector back (after stops)", flush=True) # --- все сервисы телеметрии остановлены, приложение перезапущено -------- prefix = "[telemetry down] " @@ -11617,28 +11645,38 @@ def telemetry_outage(port: int, grafana: Grafana) -> int: return report_reconcile( rows, passed="API, worker and relay work and stop in time without the " - "Collector, signals come back without restarts", + "Collector; after it returns their signals come back without " + "restarts; restarted without telemetry services, they start and work", ) -def relay_state() -> tuple[str, str] | None: - """`StartedAt` и `RestartCount` работающего relay; нет — `None`.""" - ids = service_ids("relay") - if not ids: - return None +def app_states() -> dict[str, tuple[str, str]]: + """`StartedAt` и `RestartCount` работающих контейнеров api, worker и + relay: `id` → пара; не хватает сервиса — пустой словарь.""" + ids = { + service: service_ids(service) for service in ("api", "worker", "relay") + } + if not all(ids.values()): + return {} + every = [cid for found in ids.values() for cid in found] out = subprocess.run( [ "docker", "inspect", "-f", - "{{.State.StartedAt}} {{.RestartCount}}", - ids[0], + "{{.Id}} {{.State.StartedAt}} {{.RestartCount}}", + *every, ], capture_output=True, text=True, check=False, - ).stdout.split() - return (out[0], out[1]) if len(out) == 2 else None + ).stdout + states: dict[str, tuple[str, str]] = {} + for line in out.splitlines(): + parts = line.split() + if len(parts) == 3: + states[parts[0]] = (parts[1], parts[2]) + return states if len(states) == len(every) else {} # --- trace-chain (design change job-trace-propagation, решение 16) ---------- @@ -11752,8 +11790,33 @@ def trace_chain(port: int, grafana: Grafana) -> int: return str(found[0][2].get("trace_id", "")) if found else "" # --- 1. очередь при остановленном worker ------------------------------- - depth_base = grafana.prom_sum(QUEUE_DEPTH) - step("queue depth before (no unfinished jobs)", "0", f"{depth_base:g}") + # предусловие — тихий стенд: последняя точка глубины в Prometheus до 30 с + # давности, поэтому ждать нуля, а не сравнивать одну точку (verify W3); + # не дождались — стенд, а не дефект: код 2 + quiet_from = time.monotonic() + quiet = poll( + lambda: grafana.prom_sum(QUEUE_DEPTH) == 0, + timeout=METRIC_WAIT_S, + interval=3, + ) + print( + f"queue depth 0 waited: {time.monotonic() - quiet_from:.0f} s", + flush=True, + ) + if not quiet: + print( + "trace-chain: stand is not quiet: queue depth " + f"{grafana.prom_sum(QUEUE_DEPTH):g} after {METRIC_WAIT_S} s " + "(unfinished jobs of other runs)", + flush=True, + ) + return 2 + step( + f"queue depth before reaches 0 within {METRIC_WAIT_S} s " + "(no unfinished jobs)", + "yes", + "yes", + ) compose("stop", "worker", timeout=60) print("docker compose stop worker", flush=True) queued = [upload(f"queue{n}") for n in range(TCH_QUEUE_UPLOADS)] @@ -12004,7 +12067,7 @@ def trace_chain(port: int, grafana: Grafana) -> int: ) # --- 5. сигналы уровня 4 ----------------------------------------------- - rows.extend(level4_rows(grafana)) + rows.extend(level4_rows(grafana, started)) print("waiting for the time-to-ready histogram to settle", flush=True) final, _ = settled(grafana, histogram) # счётчики процессов worker, запущенных в частях 1 и 2: оба начинали с 0 @@ -12169,10 +12232,23 @@ def retry_chain_rows( return rows -def level4_rows(grafana: Grafana) -> list[tuple[str, str, str]]: - """Пулы, насыщение worker, контейнеры = `docker inspect`, нет сокета - Docker, один источник очереди, панели уровня 4 с данными.""" +def level4_rows( + grafana: Grafana, + since: float, +) -> list[tuple[str, str, str]]: + """Пулы, насыщение worker, контейнеры = `docker inspect` и CPU, выросший + за прогон с `since`, нет сокета Docker, один источник очереди, панели + уровня 4 с данными.""" rows: list[tuple[str, str, str]] = [] + # окно прогона и scrape сверху: increase() видит рост CPU каждого процесса + window = int(time.time() - since) + TCH_METRIC_LAG_S + cpu_grown = { + str(i["metric"].get("instance")): float(i["value"][1]) + for i in grafana.prom( + "sum by (instance) " + f"(increase(container_cpu_time_seconds_total[{window}s]))", + ) + } limits = grafana.prom("db_client_connection_max") by_job: dict[str, list[str]] = {} for item in limits: @@ -12248,6 +12324,14 @@ def level4_rows(grafana: Grafana) -> list[tuple[str, str, str]]: yes(0 < usage.get(short, 0) < memory.get(short, 0)), ), ) + rows.append( + ( + f"{service} {short} CPU grows during the run " + f"(increase over {window} s > 0)", + "yes", + yes(cpu_grown.get(short, 0) > 0), + ), + ) config = compose("config") rows.append( ( diff --git a/AGENTS.md b/AGENTS.md index 010c51a..c5876fb 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -534,8 +534,8 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `driver.py --port worker-memory` | память контейнера worker (~35 с): на девять случаев в пределах контракта два одинаковых файла разом, новая cgroup на случай; `memory.peak`, `VmHWM`, `render_peak`, OOM, сумма пиков меньше 1 ГБ; worker и relay запускаются при любом исходе; `evidence/worker/memory.md` | | `driver.py freeze-sessions [--rounds 6] [--settle 15]` | сессии PostgreSQL и журнал пула после заморозки (~2,5 мин), работает и на рабочем стенде: приложение в процессе одноразового контейнера `api`, PostgreSQL только через TCP-прокси пробы, заморожен прокси, а не сервер; режимы — между блоками и до запросов при пуле 2 и 4; `evidence/storage/freeze-sessions.md` | | `driver.py --port telemetry-check` | телеметрия рабочего стенда через HTTP API Grafana с паролем из `.env` (~2 мин, change `otel-telemetry`): вход, порт, источники, dashboard provisioned и неизменяем, цели Prometheus; свой запрос → stdout → Loki → Tempo, traceparent, нестандартный метод, 401, 404; загрузка → трасса worker, недекодируемый JPEG → `failed`; рост счётчиков по репликам и исходам; S3 заморожен → span S3 с ошибкой (`unpause` в `finally`); сети хранилищ из api и worker, разовый контейнер с `OTEL_*`, проба приватности, рестарт Collector и хранилищ; `evidence/telemetry/check.md` | -| `driver.py --port telemetry-outage` | Collector `stop` и `pause` (~3 мин): `make test`, загрузка до `ready`, записи SDK в stdout, relay без перезапусков, `docker stop` реплики, worker и relay быстрее 10 с с кодом 0; все сервисы телеметрии остановлены — рестарт api, worker и relay, `make test`; сигналы (и span producer relay) снова приходят; стенд возвращается в `finally`; `evidence/telemetry/collector-outage.md` | -| `driver.py --port trace-chain` | сквозная трасса и сигналы уровня 4 на рабочем стенде (~5 мин, change `job-trace-propagation`), через HTTP API Grafana: очередь и её возраст при остановленном worker и спад до 0; загрузка с повтором при замороженном S3 — одна трасса: server span API, два span producer relay, два consumer span worker (parent и link, span S3 с ошибкой, запись оригинала и вариантов); replay в той же трассе; задание без контекста (`UPDATE` колонок своей строки) — корень worker; время до `ready`, пулы, ёмкость worker, пределы контейнеров = `docker inspect`, нет сокета Docker, панели уровня 4 с данными; `unpause s3`, worker и relay — в `finally`; `evidence/telemetry/trace-chain.md` | +| `driver.py --port telemetry-outage` | Collector `stop` и `pause` (~3,5 мин): `make test`, загрузка до `ready`, записи SDK в stdout; возврат Collector — запись, трасса, span producer и ряды API, worker и relay при прежних `StartedAt` и `RestartCount` их контейнеров; второе окно того же вида — `make test`, `docker stop` реплики, worker и relay быстрее 10 с с кодом 0; все сервисы телеметрии остановлены — рестарт api, worker и relay, `make test`; сигналы (и span producer relay) снова приходят; стенд возвращается в `finally`; `evidence/telemetry/collector-outage.md` | +| `driver.py --port trace-chain` | сквозная трасса и сигналы уровня 4 на рабочем стенде (~5 мин, change `job-trace-propagation`), через HTTP API Grafana: предусловие — глубина очереди 0 за 120 с (иначе код 2 «stand is not quiet»); очередь и её возраст при остановленном worker и спад до 0; загрузка с повтором при замороженном S3 — одна трасса: server span API, два span producer relay, два consumer span worker (parent и link, span S3 с ошибкой, запись оригинала и вариантов); replay в той же трассе; задание без контекста (`UPDATE` колонок своей строки) — корень worker; время до `ready`, пулы, ёмкость worker, пределы контейнеров = `docker inspect` и рост CPU каждого за прогон, нет сокета Docker, панели уровня 4 с данными; `unpause s3`, worker и relay — в `finally`; `evidence/telemetry/trace-chain.md` | | `driver.py stand-from-scratch [--runs 2]` | `make run_docker` на пустых volumes своим проектом `mtusi-lab6-scratch` (рабочий — код 2) на свободных портах (~1 мин на прогон): код 0, состояния, `RestartCount` брокера и телеметрии 0, нет `eacces`, provisioning, `make test`; проект удаляется с volumes при любом исходе, ID контейнеров рабочего стенда прежние; `evidence/stand/from-scratch.md` | | `driver.py freeze-lb [--rounds 3]` | только не рабочий проект compose (`COMPOSE_PROJECT_NAME`, по умолчанию `mtusi-lab6-freeze`; `mtusi-lab6` — код 2): сама поднимает стенд с данными в tmpfs (volumes нет) на образе `mtusi-messenger:lab6` и убирает его при любом исходе; `docker pause` PostgreSQL, шесть запросов через LB — 503 за ~8 с, 504 нет, `unpause` в `finally`, сессий не больше пулов (~1,5 мин); раздел `evidence/storage/freeze-sessions.md` | | `make start_db` / `make stop_db` | Postgres стенда: `up -d --wait postgres` / `stop postgres` | diff --git a/QUESTIONS.md b/QUESTIONS.md index a6fa5fd..b173563 100644 --- a/QUESTIONS.md +++ b/QUESTIONS.md @@ -260,6 +260,9 @@ Change `openspec/changes/job-trace-propagation/` (propose 2026-11-11). Номе трасс и логов, protobuf и `requests` нет; экономия ленивого импорта — ~6,5 МиБ и ~200 модулей. Принять как есть (тест сравнивает с `import redis.asyncio`) или уточнить сценарий в archive («кроме модулей, которые загружают сторонние библиотеки»)? Ответ меняет только формулировку сценария и докстринг теста (design, «Уточнения apply», п. 1). + **Закрыт на verify (W1):** сценарий и требование переформулированы по фактической проверке — нет провайдеров и модулей + SDK трасс и журнала, экспортёра, protobuf и `requests`, модулей SDK метрик не больше, чем у `import redis.asyncio` + (design, «Уточнения apply», п. 17); тест прежний. 5. Пользователю (apply): `memory.peak` уборщика на рабочем стенде — 176 МиБ при лимите 256 (плановая сверка при старте); правило «лимит ≥ 1,5 × пика» для него не выполнено (264). Поднять лимит до 288 МиБ (сумма стенда +32 МиБ, до ВМ остаётся 222 МиБ) или оставить: пик — сверка, а не этот change? Ответ — правка `docker-compose.yml`, `docker.md` и `REPORT.md` @@ -272,3 +275,23 @@ Change `openspec/changes/job-trace-propagation/` (propose 2026-11-11). Номе лимит Grafana — не предмет change, код и compose не менялись. Поднять до 576 МиБ (сумма стенда +64 МиБ, до ВМ остаётся 190 МиБ), мерить без кэша (`anon` + `kernel`) или оставить? Ответ — правка `docker-compose.yml`, `docker.md`, `REPORT.md` и `budget.md` (решает verify). + **Закрыт на verify (W5):** мерить без кэша — `memory.peak` включает файловый кэш, который ядро освобождает до OOM; + неосвобождаемая часть `anon` + `kernel` + `shmem` ≈ 197 МиБ, 1,5 × ≈ 296 ≤ 512, лимит не меняется. Правило «что считать + пиком» — `telemetry.md` и `docker.md`, вывод `budget.md` и `REPORT.md` исправлены (design, «Уточнения apply», п. 21). + +### Решения apply по verify + +- W2–W4, S2–S4 исправлены (design, «Уточнения apply», п. 18–20, 22–24; `tasks.md`, раздел 13). Без пользователя решено: + `telemetry-outage` проверяет возврат сигналов в первом окне каждого вида и останавливает процессы во втором окне того же + вида (команда ~3,5 мин); непредвиденная ошибка снимка очереди relay повторяется не чаще интервала снимка (5 с), а не на + каждом проходе; панель пула — две оси с разными единицами, а не две панели (раскладка строки «Saturation» прежняя); + `trace-chain` на нетихом стенде — код 2, как «нет стенда». + +### Предложения на потом + +- S1 (verify, для change `slo-alerts`): `increase()` недосчитывает после рестарта worker — новый процесс начинает + counter с нуля под тем же `instance`, и если он насчитал больше прежнего, Prometheus сброса не видит (`trace-chain` + складывает «тихие» значения двух процессов, «Уточнения apply», п. 8). Для правил SLO и alert это занижение ошибок и + готовых заданий. Варианты: created timestamps Prometheus 3 (`created-timestamp-zero-ingestion`: Collector-экспортёр + должен отдавать `_created`, проверить) или окна правил длиннее типичного времени жизни процесса с оговоркой в runbook; + либо `service.instance.id` с суффиксом запуска процесса (меняет число рядов — цена в кардинальности). diff --git a/REPORT.md b/REPORT.md index a15132f..050626d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -214,8 +214,9 @@ producer под сохранённым контекстом: проходы rela возраст: `max(messenger_queue_oldest_age_seconds{job="messenger-relay"})` (с) — `max`, а не сумма: два relay дали бы два ряда одного числа; - пул: `sum by (job, instance) (db_client_connection_count{db_client_connection_state="used"}) / sum by (job, instance) (db_client_connection_max)` - (`percentunit`), ожидающие — `sum by (job, instance) (db_client_connection_pending_requests)`, отказы — - `sum by (job) (rate(db_client_connection_timeouts_total[5m]))` (`short`); + (`percentunit`), ожидающие — `sum by (job, instance) (db_client_connection_pending_requests)` (`short`, + запросы, левая ось), отказы — `sum by (job) (rate(db_client_connection_timeouts_total[5m]))` (`ops`, отказы + в секунду, правая ось той же панели: число и скорость под одной единицей не смешиваются); - worker: `sum(messenger_worker_busy) / sum(messenger_worker_capacity)` и среднее за окно `sum(rate(messenger_job_duration_seconds_sum{job="messenger-worker"}[5m])) / sum(messenger_worker_capacity)` (`percentunit`; длительность пишется ровно за время на месте — закон Литтла), ожидающие места — @@ -253,8 +254,10 @@ replay, консоль, `make test_isolated`, стенд отказов и `benc `evidence/telemetry/budget.md`): relay с SDK — `memory.peak` 103 МиБ (старт), CPU до 25 % ядра при лимите 0,25 только при разборе накопленных заданий; уборщик после ленивого импорта — 108 МиБ вместе с плановой сверкой при старте; правило «лимит ≥ 1,5 × пика» у обоих выполнено (256 МиБ). -Ограничение: у Grafana в этом замере `memory.peak` 343 МиБ с файловым кэшем (1,5 × пик больше -лимита 512 на 3 МиБ; `QUESTIONS.md`, `## job-trace-propagation`, вопрос 6). +У Grafana в этом замере `memory.peak` 343 МиБ, из них файловый кэш 95 МиБ, который ядро освобождает +до OOM; неосвобождаемая часть `anon` + `kernel` + `shmem` ≈ 197 МиБ, 1,5 × ≈ 296 ≤ 512 — правило +выполнено, лимит прежний. Пик — `memory.peak`, а если с кэшем он правило не проходит — `anon` + +`kernel` + `shmem` (`.claude/rules/telemetry.md`, «Что считать пиком»). **Ограничения уровня 4:** @@ -285,7 +288,7 @@ replay, консоль, `make test_isolated`, стенд отказов и `benc | Уровень 3: Collector, хранилища, provisioning, свой запрос и задание найдены, приватность | `driver.py --port 8080 telemetry-check` | код 0: Loki → Tempo по `X-Request-Id`, трасса worker, рост счётчиков, история после рестарта хранилищ | `evidence/telemetry/check.md` | | Телеметрия не меняет ответы и остановку | `driver.py --port 8080 telemetry-outage` | код 0: `make test` PASS и остановка < 10 с при остановленном и замороженном Collector | `evidence/telemetry/collector-outage.md` | | Стенд с нуля одной командой | `driver.py stand-from-scratch --runs 2` | код 0 оба раза, `RestartCount` брокера и телеметрии 0 | `evidence/stand/from-scratch.md` | -| Лимиты и бюджет телеметрии | замер `docker stats` и `memory.peak` | лимит ≥ 1,5 × пика у всех сервисов телеметрии | `evidence/telemetry/budget.md` | +| Лимиты и бюджет телеметрии | замер `docker stats`, `memory.peak` и `memory.stat` | лимит ≥ 1,5 × пика у всех сервисов телеметрии (у Grafana пик — `anon` + `kernel` + `shmem` без файлового кэша) | `evidence/telemetry/budget.md` | | Уровень 4: контекст W3C API → relay → worker, producer и consumer span (parent и link), цепочка одной загрузки до S3 и БД с повтором и replay | `driver.py --port 8080 trace-chain` | код 0: одна трасса, две пары producer / consumer, span S3 с ошибкой и запись оригинала и вариантов, replay в той же трассе, задание без контекста — корень worker | `evidence/telemetry/trace-chain.md` (commit `72cfa9a`) | | Уровень 4: dashboard — p50 / p95 / p99, доля ошибок, глубина и возраст очереди, пул БД, насыщение worker, контейнеры | `driver.py --port 8080 trace-chain`, `telemetry-check` | запросы панелей уровня 4 без ошибок и с данными; ряды очереди только у relay; пределы = `docker inspect`; нет сокета Docker | `evidence/telemetry/trace-chain.md`, `evidence/telemetry/check.md` | | Уровень 4: relay с SDK не меняет остановку | `driver.py --port 8080 telemetry-outage` | `docker stop` relay < 10 с, код 0, «Stopped relay» при остановленном и замороженном Collector | `evidence/telemetry/collector-outage.md` | diff --git a/evidence/telemetry/budget.md b/evidence/telemetry/budget.md index 34130d1..2a7fe55 100644 --- a/evidence/telemetry/budget.md +++ b/evidence/telemetry/budget.md @@ -129,13 +129,15 @@ closed-loop на шумном хосте, не метка `bench/`: это по лимите, как выше), worker 121,3 / 1024 (с `docker start` в `trace-chain`; до него — 502,3: процессы обработки `make student_test`), Collector 83,5 / 256, Prometheus 94,6 / 384, Loki 159,9 / 512, Tempo 279,6 / 640, PostgreSQL 274,3 / 1024, брокер 250,4 / 512, Valkey 29,8 / 128, LB 29,4 / 256. -- **Расхождение: Grafana.** `memory.peak` 343,2 МиБ при лимите 512 (1,5 × пик = 515 > 512), хотя в - первом разделе и в design (решение 15, «Уточнения apply», п. 12) — 248–294 и 255 МиБ. Пик набран - в первые минуты после рестарта `telemetry-outage` (уже 343,2 в начале простоя) и дальше не рос; - `docker stats` (без неактивного page cache) — 253–261 МиБ; `memory.stat` в конце: `anon` 188, - `file` 95 (из них `inactive_file` 69), `shmem` 1,6 МиБ — пик включает файловый кэш, который ядро - отдаёт первым. По правилу `telemetry.md` (`memory.peak`) лимит не выполнен; лимит Grafana — не - предмет этого change, правка не делалась (`QUESTIONS.md`, `## job-trace-propagation`, вопрос 6). +- **Grafana: `memory.peak` раздут файловым кэшем.** `memory.peak` 343,2 МиБ при лимите 512 (1,5 × + `memory.peak` = 515), хотя в первом разделе и в design (решение 15, «Уточнения apply», п. 12) — + 248–294 и 255 МиБ. Пик набран в первые минуты после рестарта `telemetry-outage` (уже 343,2 в + начале простоя) и дальше не рос; `docker stats` (без неактивного page cache) — 253–261 МиБ; + `memory.stat` в конце: `anon` 188, `file` 95 (из них `inactive_file` 69), `shmem` 1,6 МиБ. + Файловый кэш ядро освобождает до OOM, поэтому `memory.peak` здесь — верхняя граница, а не пик: + неосвобождаемая часть `anon` + `kernel` + `shmem` ≈ 197 МиБ, 1,5 × ≈ 296 ≤ 512 — правило + `telemetry.md` («Go и память»: пик, раздутый кэшем) выполнено, лимит не меняется (`QUESTIONS.md`, + `## job-trace-propagation`, вопрос 6, закрыт на verify). - **S3** — `memory.peak` 512,8 МиБ при лимите 512 (стенд жил с 16:04:32Z): известная запись `KNOWN_ISSUES.md` «память S3 на долго живущем стенде», не этот change. - **Суммы** не изменились: `docker inspect` 15 работающих контейнеров — 11,5 CPU / 7296 МиБ, `docker diff --git a/infra/otel/grafana/dashboards/messenger-overview.json b/infra/otel/grafana/dashboards/messenger-overview.json index 25c28e1..249e13e 100644 --- a/infra/otel/grafana/dashboards/messenger-overview.json +++ b/infra/otel/grafana/dashboards/messenger-overview.json @@ -305,11 +305,23 @@ { "id": 20, "type": "timeseries", - "title": "PostgreSQL pool: waiting and timeouts", - "description": "Requests waiting for a pool connection (instantaneous) and pool checkouts that timed out per second.", + "title": "PostgreSQL pool: waiting (left) and timeouts/s (right)", + "description": "Left axis, requests: requests waiting for a pool connection (instantaneous). Right axis, per second: pool checkouts that timed out.", "datasource": {"type": "prometheus", "uid": "prometheus"}, "gridPos": {"h": 8, "w": 6, "x": 6, "y": 36}, - "fieldConfig": {"defaults": {"unit": "short", "min": 0}, "overrides": []}, + "fieldConfig": { + "defaults": {"unit": "short", "min": 0, "custom": {"axisLabel": "requests"}}, + "overrides": [ + { + "matcher": {"id": "byFrameRefID", "options": "B"}, + "properties": [ + {"id": "unit", "value": "ops"}, + {"id": "custom.axisPlacement", "value": "right"}, + {"id": "custom.axisLabel", "value": "timeouts/s"} + ] + } + ] + }, "options": {"legend": {"displayMode": "list", "placement": "bottom"}, "tooltip": {"mode": "multi"}}, "targets": [ { diff --git a/openspec/changes/job-trace-propagation/design.md b/openspec/changes/job-trace-propagation/design.md index 321316b..82c56aa 100644 --- a/openspec/changes/job-trace-propagation/design.md +++ b/openspec/changes/job-trace-propagation/design.md @@ -360,12 +360,13 @@ restart grafana` (проверяет apply). Запросы: не больше), ёмкость worker 2, пределы контейнеров = `docker inspect` (`NanoCpus`, `Memory`), память меньше предела, нет монтирования сокета Docker в `docker compose config`, панели уровня 4 с данными (общий обход панелей с `telemetry-check`). - `finally`: `unpause s3`, `start worker relay`. Таблица «шаг → ожидаемо → получено», коды 0 / 1 / 2 (нет стенда) → - `evidence/telemetry/trace-chain.md`. + `finally`: `unpause s3`, `start worker relay`. Таблица «шаг → ожидаемо → получено», коды 0 / 1 / 2 (нет стенда или + стенд не тихий — «Уточнения apply», п. 19; CPU каждого процесса — п. 22) → `evidence/telemetry/trace-chain.md`. - **`telemetry-check`:** шаги задания — по consumer span трассы загрузки, а не по корню; шаг «трасса задания — трасса загрузки» (`trace_id` «Uploaded attachment» = `trace_id` записей worker); relay — в списке контейнеров пробы сетей. - **`telemetry-outage`:** relay — в остановках при остановленном и замороженном Collector (быстрее 10 с, код 0, «Stopped - relay») и в рестарте при остановленных сервисах телеметрии; сигналы relay снова приходят. + relay») и в рестарте при остановленных сервисах телеметрии; сигналы relay снова приходят без перезапуска («Уточнения + apply», п. 18). - **Быстрые тесты** (`service-tests/unit`, in-memory экспортёры): контекст загрузки (в span, вне span, выключено); span producer (родитель, заголовки, ошибка, выключено — заголовки как есть, без контекста — ничего); consumer span (родитель и link, без заголовков и с неверным — корень, флаг `00` — не записывается); время до `ready` (replay — нет наблюдения); @@ -494,3 +495,33 @@ evidence. `REPORT.md` — «Наблюдаемость»: сквозная тр возврата Collector, поэтому «span и метрики relay снова приходят без перезапуска relay» (сценарий «Collector недоступен для relay») проверены после `docker start` того же контейнера; без перезапуска — только `StartedAt` и `RestartCount` во время недоступности (п. 9). Порядок шагов команды — возможная правка драйвера (решает verify). + +Правки по verify (`tasks.md`, раздел 13; код change — `72cfa9a`): + +17. **W1 — сценарий «Модули SDK без телеметрии не загружаются»** переформулирован по фактической проверке (п. 1): нет + провайдеров и модулей SDK трасс и журнала, экспортёра, protobuf и `requests`; модулей SDK метрик не больше, чем + после `import redis.asyncio` в отдельном интерпретаторе. Тест `test_sdk_modules_not_loaded_without_telemetry` прежний; + вопрос 4 `QUESTIONS.md` закрыт. +18. **W2 — `telemetry-outage` (п. 9, 16).** В каждом окне (`stop`, `pause`) Collector возвращается до остановок: сигналы API, + worker и relay (запись, трасса со span producer relay, ряды) приходят при прежних `StartedAt` и `RestartCount` всех + контейнеров `api`, `worker`, `relay`. Остановки (сценарии `graceful-shutdown`) — во втором окне того же вида после + `make test`: в буферах SDK свежие данные. Итоговая строка — «…after it returns their signals come back without + restarts; restarted without telemetry services, they start and work». Команда длиннее на окно (~3,5 мин). +19. **W3 — предусловие `trace-chain` (п. 15):** глубина очереди ждётся до нуля не дольше `METRIC_WAIT_S` (120 с); не + дождались — код 2 «stand is not quiet» (стенд, а не дефект), строка таблицы — «queue depth before reaches 0 within 120 s». +20. **W4 — снимок очереди relay.** `_take_snapshot` ловит любую ошибку, кроме отказа PostgreSQL (прежний пропуск): + `error` «Queue snapshot failed» с `exc_info`, следующая попытка — через интервал снимка (`QueueSnapshots.postpone`): + постоянная ошибка не пишет запись на каждый проход; прежний снимок устаревает сам. Публикация не прерывается. +21. **W5 — что считать пиком памяти (решение 15, п. 14).** `memory.peak` включает файловый кэш, который ядро освобождает до + OOM; если 1,5 × `memory.peak` больше лимита, пик — `anon` + `kernel` + `shmem` из `memory.stat` (`telemetry.md`, «Что + считать пиком»). Grafana: 343 МиБ с кэшем 95, без него ≈ 197, 1,5 × ≈ 296 ≤ 512 — лимит прежний, вопрос 6 закрыт. + Контрольная выборка на рабочем стенде (2026-11-11, Grafana ~30 мин после рестарта): `memory.peak` 343,9 МиБ, `anon` + 210,8, `kernel` 6,4, `shmem` 1,6, `file` 95,0 — ≈ 218,8, 1,5 × ≈ 328 ≤ 512. +22. **S2 — CPU в `trace-chain`:** у каждого контейнера `api`, `worker`, `relay` `increase(container_cpu_time_seconds_total + [окно прогона + 35 с])` > 0 (сценарии «Пределы как в compose» — «CPU растёт под нагрузкой» — и «Пулы процессов + стенда» — ряды у каждого процесса). Перезапуск worker и relay внутри прогона рост не скрывает: `increase()` видит сброс + или занижает, но не до нуля. +23. **S3 — панель «PostgreSQL pool»:** ожидающие (`short`, левая ось) и отказы в секунду (`ops`, правая ось, override по + `refId` B) — разные единицы в одной панели, а не одна `short`; запросы прежние. +24. **S4 — пустой `tracestate`** по W3C равен отсутствующему: `trace_context_from_headers` отдаёт контекст с `traceparent` и + `tracestate = None`; длиннее 512 — по-прежнему `None` целиком (как в CHECK колонки). diff --git a/openspec/changes/job-trace-propagation/specs/observability/spec.md b/openspec/changes/job-trace-propagation/specs/observability/spec.md index 3497827..bbb98ee 100644 --- a/openspec/changes/job-trace-propagation/specs/observability/spec.md +++ b/openspec/changes/job-trace-propagation/specs/observability/spec.md @@ -295,9 +295,11 @@ API MUST NOT продолжать трассу клиента: входящие run_worker`, `make run_relay`), во временном прогоне `make test_isolated`, на стенде отказов `make failure_checks` и на стенде `bench/` она SHALL быть выключена по умолчанию: методика и бюджеты этих стендов прежние, а профиль, которому нужна телеметрия, включает её явно. Выключенная телеметрия SHALL выключать SDK целиком: ни трасс, ни метрик, ни отправки записей -журнала, ни обращений к Collector, ни полей трассы в журнале, ни модулей SDK и экспортёра в памяти процесса. Модулей SDK -MUST NOT загружать и процессы, которые SDK не запускают: уборщик, сервис миграций, команда replay. Вариант «телеметрия -выключена» трека 1 — та же одна настройка. +журнала, ни обращений к Collector, ни полей трассы в журнале, ни провайдеров и экспортёра SDK в памяти процесса. Код +приложения MUST NOT загружать модули SDK трасс и журнала, экспортёра, protobuf и HTTP-клиента экспортёра ни при выключенной +телеметрии, ни в процессах, которые SDK не запускают: уборщик, сервис миграций, команда replay. Модулей SDK метрик в таком +процессе MUST NOT быть больше, чем загружает сама сторонняя библиотека, которую процесс импортирует (redis-py при импорте +проверяет, установлен ли SDK метрик). Вариант «телеметрия выключена» трека 1 — та же одна настройка. #### Scenario: Консоль без телеметрии @@ -313,7 +315,9 @@ MUST NOT загружать и процессы, которые SDK не зап #### Scenario: Модули SDK без телеметрии не загружаются - **WHEN** код процессов API, worker, relay и уборщика импортирован при выключенной телеметрии -- **THEN** ни одного модуля SDK и экспортёра OpenTelemetry, protobuf и HTTP-клиента экспортёра в процессе нет +- **THEN** в процессе нет ни провайдеров и модулей SDK трасс и журнала, ни экспортёра OpenTelemetry, ни protobuf, ни + HTTP-клиента экспортёра, а модулей SDK метрик не больше, чем после одного `import redis.asyncio` в отдельном + интерпретаторе ### Requirement: Наблюдаемость в отчёте diff --git a/openspec/changes/job-trace-propagation/tasks.md b/openspec/changes/job-trace-propagation/tasks.md index fe2834c..e9d5179 100644 --- a/openspec/changes/job-trace-propagation/tasks.md +++ b/openspec/changes/job-trace-propagation/tasks.md @@ -204,3 +204,40 @@ лимиты ≥ 1,5 × пика, суммы `docker.md` и `REPORT.md` совпадают. - [x] 12.5 Ссылки `REPORT.md` и `AGENTS.md` на новые файлы evidence и их commit; `graphify update .`. Проверка: файлы, названные в `REPORT.md`, существуют; в графе есть новые модули пакета телеметрии. + +## 13. Замечания проверки + +Находки verify (код — `72cfa9a`, evidence — `eaa1161`), решения — design, «Уточнения apply», п. 17–24. Пересъёмка +evidence — после коммита этих правок основной сессией. + +- [x] 13.1 W1: требование «Где телеметрия включена» и сценарий «Модули SDK без телеметрии не загружаются» дельты + `observability` — по фактической проверке `test_sdk_modules_not_loaded_without_telemetry` (без SDK трасс и журнала, + экспортёра, protobuf, `requests`; модулей SDK метрик не больше, чем у `import redis.asyncio`); `run-modes.md`; вопрос 4 + `QUESTIONS.md` закрыт. Проверка: `openspec validate job-trace-propagation --strict`; тест зелёный. +- [x] 13.2 W2: `telemetry-outage` — в каждом окне возврат Collector до остановок, сигналы API, worker и relay (span producer, + ряды) при прежних `StartedAt` / `RestartCount` всех контейнеров `api`, `worker`, `relay`; остановки — во втором окне того + же вида; итоговая строка без ложного «without restarts»; `SKILL.md`, `AGENTS.md`. Проверка: пробный прогон — код 0. +- [x] 13.3 W3: `trace-chain` — предусловие «глубина 0» с ожиданием до `METRIC_WAIT_S`, не дождались — код 2 «stand is not + quiet». Проверка: пробный прогон — код 0; `py_compile` системным `python3`. +- [x] 13.4 W4: `_take_snapshot` relay — любая ошибка снимка, кроме отказа PostgreSQL, — `error` «Queue snapshot failed» с + `exc_info` и следующая попытка через интервал; relay не останавливается. Проверка: тест + `test_relay_loop_survives_snapshot_error` красный до правки, зелёный после. +- [x] 13.5 W5: правило «что считать пиком» (`memory.peak` с файловым кэшем → `anon` + `kernel` + `shmem`) в + `telemetry.md` и `docker.md`; `REPORT.md` (бюджет и строка «Лимиты и бюджет телеметрии» без противоречия); вывод + `evidence/telemetry/budget.md` о Grafana; вопрос 6 `QUESTIONS.md` закрыт. Проверка: `grep` правила и строк. +- [x] 13.6 S2: `trace-chain` — `increase(container_cpu_time_seconds_total[окно прогона])` > 0 у каждого контейнера `api`, + `worker`, `relay`. Проверка: пробный прогон — строки «CPU grows during the run» `yes`. +- [x] 13.7 S3: панель «PostgreSQL pool: waiting and timeouts» — ожидающие и отказы в секунду под разными единицами и осями. + Проверка: `python3 -m json.tool`; после `docker compose restart grafana` — обход панелей `trace-chain` без ошибок и с + данными. +- [x] 13.8 S4: `trace_context_from_headers` — пустой `tracestate` равен отсутствующему (контекст с `traceparent`). Проверка: + случаи `empty-tracestate` и `empty-tracestate-bytes` теста `test_delivery_headers` красные до правки, зелёные после. +- [x] 13.9 S1 не исправляется: `QUESTIONS.md`, `## job-trace-propagation`, «Предложения на потом» (для change `slo-alerts`). +- [x] 13.10 Регрессия: `make lint`, `make service_test`, `make service_test_db`, сборка и развёртывание relay (и api через + `make rolling_update`), `make test`, `make student_test` (красный только `test_exclusion_evidence_exists`), `docker + compose config --quiet`, пробные `trace-chain` и `telemetry-outage` (вывод в scratchpad), `openspec validate + job-trace-propagation --strict`. +- [ ] 13.11 Пересъёмка evidence (после коммита правок основной сессией): `driver.py --port 8080 telemetry-outage` → + `evidence/telemetry/collector-outage.md` (итоговая строка без ложного «without restarts»), `driver.py --port 8080 + trace-chain` → `evidence/telemetry/trace-chain.md` (затронут: предусловие, CPU, панель пула); ссылки commit в `REPORT.md` + и `AGENTS.md`. diff --git a/service-tests/unit/test_attachment_relay.py b/service-tests/unit/test_attachment_relay.py index 735d737..ab27b2c 100644 --- a/service-tests/unit/test_attachment_relay.py +++ b/service-tests/unit/test_attachment_relay.py @@ -421,3 +421,47 @@ async def test_relay_loop_takes_snapshot_not_more_often( await relay_main._serve(loop_service, stop=stop, snapshots=failing) assert failing.latest is None assert snapshots.latest is previous + + +class _RecordingLogger: + """Записи цикла relay: событие, уровень и поля.""" + + def __init__(self) -> None: + self.records: list[tuple[str, str, dict[str, object]]] = [] + + def __getattr__(self, level: str): + def record(event: str, **fields: object) -> None: + self.records.append((level, event, fields)) + + return record + + +class _BrokenSnapshotService(_LoopService): + """Снимок падает не отказом PostgreSQL, а непредвиденной ошибкой.""" + + async def queue_snapshot(self) -> dataclasses.QueueSnapshotDTO: + self.snapshots += 1 + raise RuntimeError("probe") + + +async def test_relay_loop_survives_snapshot_error( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Непредвиденная ошибка снимка не останавливает relay: запись `error` + «Queue snapshot failed» с `exc_info`, проходы идут дальше, снимка нет + (verify W4).""" + monkeypatch.setattr(settings.relay, "poll_interval_seconds", 0) + log = _RecordingLogger() + monkeypatch.setattr(relay_main, "logger", log) + stop = asyncio.Event() + loop_service = _BrokenSnapshotService(stop, passes=3) + snapshots = relay_main.QueueSnapshots() + await relay_main._serve(loop_service, stop=stop, snapshots=snapshots) + # все три прохода выполнены: сигнал поставил последний + assert loop_service.passes == 0 + assert loop_service.snapshots == 1 + assert snapshots.latest is None + errors = [r for r in log.records if r[0] == "error"] + assert [event for _, event, _ in errors] == ["Queue snapshot failed"] + assert isinstance(errors[0][2]["exc_info"], RuntimeError) + assert "Relay pass failed" not in [event for _, event, _ in log.records] diff --git a/service-tests/unit/test_telemetry.py b/service-tests/unit/test_telemetry.py index 4fdfa50..cd99daf 100644 --- a/service-tests/unit/test_telemetry.py +++ b/service-tests/unit/test_telemetry.py @@ -1373,6 +1373,15 @@ def test_relay_resource() -> None: ({"traceparent": "\xff".encode("latin-1")}, None), ({"traceparent": 42}, None), ({"traceparent": SAVED.traceparent, "tracestate": "x" * 513}, None), + # пустой tracestate по W3C равен отсутствующему (verify S4) + ( + {"traceparent": SAVED.traceparent, "tracestate": ""}, + (SAVED.traceparent, None), + ), + ( + {"traceparent": SAVED.traceparent.encode(), "tracestate": b""}, + (SAVED.traceparent, None), + ), ], ids=[ "no-headers", @@ -1384,6 +1393,8 @@ def test_relay_resource() -> None: "not-ascii", "number", "long-tracestate", + "empty-tracestate", + "empty-tracestate-bytes", ], ) def test_delivery_headers( diff --git a/src/infra/broker/client.py b/src/infra/broker/client.py index f428f23..cebaa05 100644 --- a/src/infra/broker/client.py +++ b/src/infra/broker/client.py @@ -310,16 +310,16 @@ def trace_context_from_headers( """Контекст W3C из заголовков сообщения (design change `job-trace-propagation`, решения 1, 6): `traceparent` по шаблону версии `00`, `tracestate` не длиннее предела, иначе `None` — новая трасса, а не - ошибка. Тело и его разбор заголовки не меняют.""" + ошибка. Пустой `tracestate` по W3C равен отсутствующему: контекст — + только `traceparent` (verify S4). Тело и его разбор заголовки не + меняют.""" if not headers: return None traceparent = _header_text(headers.get(TRACE_HEADER_TRACEPARENT)) if traceparent is None or _TRACEPARENT.fullmatch(traceparent) is None: return None - tracestate = _header_text(headers.get(TRACE_HEADER_TRACESTATE)) - if tracestate is not None and not ( - 0 < len(tracestate) <= TRACESTATE_MAX_LENGTH - ): + tracestate = _header_text(headers.get(TRACE_HEADER_TRACESTATE)) or None + if tracestate is not None and len(tracestate) > TRACESTATE_MAX_LENGTH: return None return TraceContextDTO(traceparent=traceparent, tracestate=tracestate) diff --git a/src/relay/main.py b/src/relay/main.py index 0c437ee..4b0d498 100644 --- a/src/relay/main.py +++ b/src/relay/main.py @@ -175,6 +175,11 @@ class QueueSnapshots: self.latest = snapshot self._taken_at = now + def postpone(self, *, now: float) -> None: + """Попытка не удалась: следующая — через интервал, прежний снимок + остаётся и устаревает сам.""" + self._taken_at = now + async def run() -> int: stop = _install_stop() @@ -253,7 +258,9 @@ async def _take_snapshot( ) -> None: """Снимок очереди не чаще `QUEUE_SNAPSHOT_INTERVAL_SECONDS`, только при включённой телеметрии; отказ PostgreSQL — пропуск: устаревший снимок - gauge перестаёт отдавать сам.""" + gauge перестаёт отдавать сам. Любая другая ошибка снимка relay не + останавливает: запись `error` и следующая попытка через интервал + (verify W4).""" if snapshots is None: return now = time.monotonic() @@ -264,6 +271,11 @@ async def _take_snapshot( except exceptions.ServiceUnavailable: # причину уже записала единица работы return + except Exception as e: + # снимок — только метрика: публикация продолжается + logger.error("Queue snapshot failed", exc_info=e) + snapshots.postpone(now=now) + return snapshots.store(snapshot, now=now)