forked from mtusi2026/mtusi2026lab7
267 lines
18 KiB
Python
267 lines
18 KiB
Python
#!/usr/bin/env python3
|
||
"""Сигналы наблюдаемости lab6 (уровни 3–4) на запущенном стенде; данные читаются через API Grafana (datasource proxy).
|
||
1. Контролируемый запрос с заданным traceparent: server span в Tempo (шаблон маршрута, X-Request-Id,
|
||
service.instance.id = X-Instance-Id, дочерние SQL-spans) и access-лог в Loki с тем же trace_id/span_id.
|
||
2. Ошибка 404: request_id из тела ошибки находит лог, а лог — trace.
|
||
3. Upload → один trace: SERVER (api) → PRODUCER publish → CONSUMER process (worker) → S3 и SQL; лог worker в trace.
|
||
4. Retry: S3 «зависает» (docker compose pause) на первую попытку → в том же trace две публикации и две обработки,
|
||
первая с ошибкой, вторая — ready. Шаг управляет Docker Compose этого каталога: только учебный стенд.
|
||
5. Метрики сигналов есть в Prometheus; в labels нет id пользователей/чатов/сообщений/вложений, request_id и сырых URL.
|
||
6. В spans и логах нет пароля, session token, текста сообщения и имени файла.
|
||
7. Dashboard загружен provisioning-ом из репозитория, его запросы к Prometheus/Loki/Tempo находят данные.
|
||
Запуск: python3 student-tests/telemetry_check.py --ca-file secrets/tls/service-ca/ca.crt"""
|
||
import base64
|
||
import json
|
||
from pathlib import Path
|
||
import re
|
||
import secrets
|
||
import ssl
|
||
import subprocess
|
||
import sys
|
||
import time
|
||
import urllib.error
|
||
import urllib.parse
|
||
import urllib.request
|
||
import uuid
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||
from client import SPEC, Client, ROOT, arguments, check, run # noqa: E402
|
||
|
||
UUID_RE = re.compile(r'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', re.I)
|
||
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
|
||
|
||
|
||
|
||
def hexid(b64): # Tempo отдаёт OTLP JSON: id spans в base64, в логах и traceparent — hex
|
||
return base64.b64decode(b64).hex()
|
||
|
||
|
||
class Grafana:
|
||
def __init__(self, base):
|
||
password = (ROOT / 'secrets/runtime/grafana_admin_password').read_text().strip() # не печатается
|
||
self.base = base.rstrip('/')
|
||
self.auth = 'Basic ' + base64.b64encode(f'admin:{password}'.encode()).decode()
|
||
|
||
def get(self, path, **params):
|
||
url = self.base + path + ('?' + urllib.parse.urlencode(params) if params else '')
|
||
req = urllib.request.Request(url, headers={'Authorization': self.auth, 'Accept': 'application/json'})
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=15, context=ssl.create_default_context(cafile=ROOT / 'secrets/tls/service-ca/ca.crt')) as r:
|
||
return r.read().decode()
|
||
except urllib.error.HTTPError as e:
|
||
if e.code == 404:
|
||
return ''
|
||
raise
|
||
|
||
def trace(self, trace_id):
|
||
raw = self.get(f'/api/datasources/proxy/uid/tempo/api/traces/{trace_id}')
|
||
spans = []
|
||
for batch in json.loads(raw).get('batches', []) if raw else []:
|
||
res = {a['key']: next(iter(a['value'].values()), None) for a in batch['resource']['attributes']}
|
||
for scope in batch.get('scopeSpans', []):
|
||
for s in scope['spans']:
|
||
attrs = {a['key']: next(iter(a['value'].values()), None) for a in s.get('attributes', [])}
|
||
spans.append({'name': s['name'], 'kind': s.get('kind', '').replace('SPAN_KIND_', ''), 'id': hexid(s['spanId']),
|
||
'parent': hexid(s.get('parentSpanId', '')), 'status': s.get('status', {}).get('code', ''),
|
||
'start': int(s['startTimeUnixNano']), 'end': int(s['endTimeUnixNano']), 'attrs': attrs, 'resource': res})
|
||
return raw, spans
|
||
|
||
def logs(self, query, minutes=30):
|
||
raw = self.get('/api/datasources/proxy/uid/loki/loki/api/v1/query_range', query=query, limit=200,
|
||
start=str(int((time.time() - minutes * 60) * 1e9)), direction='forward')
|
||
rows = [{**stream['stream'], 'line': line} for stream in json.loads(raw)['data']['result'] for _, line in stream['values']]
|
||
return raw, rows
|
||
|
||
def prom(self, path, **params):
|
||
return json.loads(self.get('/api/datasources/proxy/uid/prometheus/api/v1/' + path, **params))['data']
|
||
|
||
|
||
def until(what, fn, ready=bool, seconds=45):
|
||
deadline = time.monotonic() + seconds
|
||
while True:
|
||
value = fn()
|
||
if ready(value):
|
||
return value
|
||
check(time.monotonic() < deadline, f'{what}: не дождались за {seconds} с')
|
||
time.sleep(1)
|
||
|
||
|
||
def has(kind, outcome=None):
|
||
return lambda x: any(s['kind'] == kind and (outcome is None or s['attrs'].get('messenger.job.outcome') == outcome) for s in x[1])
|
||
|
||
|
||
def traceparent():
|
||
tid, sid = secrets.token_hex(16), secrets.token_hex(8)
|
||
return tid, sid, f'00-{tid}-{sid}-01'
|
||
|
||
|
||
def compose(*args):
|
||
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True)
|
||
check(r.returncode == 0, f'docker compose {args[0]}: {r.stderr.strip()[-200:]}')
|
||
return r.stdout.strip()
|
||
|
||
|
||
def sql(query):
|
||
return compose('exec', '-T', '-u', 'postgres', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-tAc', query)
|
||
|
||
|
||
def main():
|
||
args = arguments('Сигналы наблюдаемости lab6', lambda p: p.add_argument('--grafana', default='https://localhost:3000'))
|
||
c, g = Client(args.base_url, args.ca_file), Grafana(args.grafana)
|
||
raw_dump = [] # всё, что прочитано из Tempo/Loki, — для проверки отсутствия секретов (шаг 6)
|
||
|
||
alice, bob, eve, chat = c.bootstrap()
|
||
text = 'секретный текст ' + uuid.uuid4().hex
|
||
|
||
# 1. Контролируемый запрос: клиент сам задаёт trace_id, API продолжает этот trace.
|
||
tid, client_span, tp = traceparent()
|
||
r = c.call('POST', f'/api/v1/chats/{chat["id"]}/messages', 201, actor=alice, body={'text': text},
|
||
headers={'Idempotency-Key': uuid.uuid4().hex, 'traceparent': tp}, schema='Message')
|
||
rid, instance = r['headers']['X-Request-Id'], r['headers']['X-Instance-Id']
|
||
raw, spans = until('trace сообщения в Tempo', lambda: g.trace(tid), has('SERVER'))
|
||
raw_dump.append(raw)
|
||
server = [s for s in spans if s['kind'] == 'SERVER']
|
||
check(len(server) == 1, 'ожидался один server span')
|
||
srv = server[0]
|
||
check(srv['name'] == 'POST /api/v1/chats/{chat_id}/messages', f'имя span: {srv["name"]}')
|
||
check(srv['parent'] == client_span, 'server span не продолжает traceparent клиента')
|
||
check(srv['attrs'].get('http.route') == '/api/v1/chats/{chat_id}/messages', 'нет http.route')
|
||
check(srv['attrs'].get('messenger.request_id') == rid, 'request_id span ≠ X-Request-Id')
|
||
check(srv['resource'].get('service.name') == 'messenger-api', 'service.name')
|
||
check(srv['resource'].get('service.instance.id') == instance, 'service.instance.id ≠ X-Instance-Id')
|
||
check(srv['resource'].get('deployment.environment.name') == 'lab', 'deployment.environment.name')
|
||
check(srv['resource'].get('service.version'), 'service.version')
|
||
db_spans = [s for s in spans if s['parent'] == srv['id'] and s['name'].startswith('pg.query')]
|
||
check(db_spans, 'нет дочерних SQL-spans')
|
||
raw, logs = until('access-лог в Loki', lambda: g.logs(f'{{service_name="messenger-api"}} | trace_id="{tid}" | event="http.request"'),
|
||
lambda x: x[1])
|
||
raw_dump.append(raw)
|
||
log = logs[0]
|
||
check(log['request_id'] == rid and log['span_id'] == srv['id'], 'лог не связан с server span')
|
||
check(log['severity_text'] == 'INFO' and log['service_name'] == 'messenger-api', 'severity/service.name лога')
|
||
print(f'PASS 1 trace {tid}: server span {srv["name"]} ({len(db_spans)} SQL), лог request_id={rid}')
|
||
|
||
# 2. Ошибка клиента: по request_id из тела ответа находится лог, по trace_id лога — trace.
|
||
err = c.call('GET', f'/api/v1/chats/{chat["id"]}', 404, actor=eve)['json']['error']
|
||
raw, logs = until('лог ошибки по request_id', lambda: g.logs(f'{{service_name="messenger-api"}} | request_id="{err["request_id"]}"'),
|
||
lambda x: x[1])
|
||
raw_dump.append(raw)
|
||
err_tid = logs[0]['trace_id']
|
||
raw, spans = until('trace ошибки', lambda: g.trace(err_tid), has('SERVER'))
|
||
raw_dump.append(raw)
|
||
check(any(s['kind'] == 'SERVER' and s['attrs'].get('http.response.status_code') == '404' for s in spans), 'trace 404')
|
||
print(f'PASS 2 404 request_id={err["request_id"]} → лог → trace {err_tid}')
|
||
|
||
# 3. Upload → обработка worker-ом в одном trace.
|
||
filename = f'тайное-имя-{uuid.uuid4().hex[:8]}.png'
|
||
tid, client_span, tp = traceparent()
|
||
att = c.call('POST', f'/api/v1/chats/{chat["id"]}/attachments?filename={urllib.parse.quote(filename)}', 202, actor=alice,
|
||
raw=PNG, headers={'Content-Type': 'image/png', 'traceparent': tp}, schema='Attachment')['json']
|
||
c.wait_ready(alice, att)
|
||
raw, spans = until('trace upload → worker', lambda: g.trace(tid), has('CONSUMER', 'done'))
|
||
raw_dump.append(raw)
|
||
by_id = {s['id']: s for s in spans}
|
||
srv = next(s for s in spans if s['kind'] == 'SERVER')
|
||
prod = [s for s in spans if s['kind'] == 'PRODUCER']
|
||
cons = [s for s in spans if s['kind'] == 'CONSUMER']
|
||
check(len(prod) == 1 and prod[0]['parent'] == srv['id'], 'PRODUCER span не дочерний к upload')
|
||
check(len(cons) == 1 and cons[0]['parent'] == prod[0]['id'], 'CONSUMER span не дочерний к PRODUCER')
|
||
check(prod[0]['resource']['service.name'] == 'messenger-api' and cons[0]['resource']['service.name'] == 'messenger-worker', 'сервисы')
|
||
under = {s['name'] for s in spans if s['parent'] == cons[0]['id']}
|
||
check({'claim job', 'S3.GetObject', 'render variants', 'S3.PutObject', 'S3.CopyObject', 'commit result', 'S3.DeleteObject'} <= under,
|
||
f'шаги worker: {sorted(under)}')
|
||
check(any(by_id.get(s['parent'], {}).get('name') == 'commit result' and s['name'].startswith('pg.query') for s in spans),
|
||
'нет SQL фиксации результата')
|
||
raw, logs = until('лог worker в trace', lambda: g.logs(f'{{service_name="messenger-worker"}} | trace_id="{tid}" | event="job.ready"'),
|
||
lambda x: x[1])
|
||
raw_dump.append(raw)
|
||
check(logs[0]['span_id'] == cons[0]['id'], 'лог job.ready не связан с CONSUMER span')
|
||
print(f'PASS 3 trace {tid}: upload → publish → process ({len(spans)} spans), лог job.ready в том же trace')
|
||
|
||
# 4. Retry: первая попытка упирается в «зависший» S3 (requestTimeout 8 с), вторая после backoff — успешна.
|
||
# S3 размораживается сразу после первой ошибки: вторая попытка (backoff 1–2 с) застанет его рабочим.
|
||
compose('stop', 'worker')
|
||
tid, client_span, tp = traceparent()
|
||
try:
|
||
att = c.call('POST', f'/api/v1/chats/{chat["id"]}/attachments?filename=retry.png', 202, actor=alice,
|
||
raw=PNG, headers={'Content-Type': 'image/png', 'traceparent': tp}, schema='Attachment')['json']
|
||
compose('pause', 's3')
|
||
compose('up', '-d', '--no-deps', 'worker') # start ждал бы healthy у замороженного s3
|
||
until('первая попытка завершилась ошибкой',
|
||
lambda: sql(f"SELECT 1 FROM jobs WHERE attachment_id = '{att['id']}' AND error_code IS NOT NULL"), seconds=60)
|
||
finally:
|
||
compose('unpause', 's3')
|
||
compose('up', '-d', '--no-deps', 'worker')
|
||
c.wait_ready(alice, att, wait_seconds=60)
|
||
raw, spans = until('trace с повтором', lambda: g.trace(tid), has('CONSUMER', 'done'))
|
||
raw_dump.append(raw)
|
||
prod = sorted((s for s in spans if s['kind'] == 'PRODUCER'), key=lambda s: s['start'])
|
||
cons = sorted((s for s in spans if s['kind'] == 'CONSUMER'), key=lambda s: s['start'])
|
||
check(len(prod) == 2 and len(cons) == 2, f'ожидались 2 публикации и 2 обработки: {len(prod)}/{len(cons)}')
|
||
check(cons[0]['parent'] == prod[0]['id'] and prod[1]['parent'] == cons[0]['id'] and cons[1]['parent'] == prod[1]['id'],
|
||
'цепочка publish → process → publish → process нарушена')
|
||
check(cons[0]['status'] == 'STATUS_CODE_ERROR' and cons[0]['attrs'].get('messenger.job.outcome') == 'retry', 'первая попытка не retry')
|
||
check(cons[1]['attrs'].get('messenger.job.attempt') == '2', 'вторая попытка не attempt 2')
|
||
raw, logs = until('логи retry', lambda: g.logs(f'{{service_name="messenger-worker"}} | trace_id="{tid}"'),
|
||
lambda x: {'job.retry', 'job.ready'} <= {l['event'] for l in x[1]})
|
||
raw_dump.append(raw)
|
||
print(f'PASS 4 trace {tid}: publish#1 → process#1 (retry, S3 timeout) → publish#2 → process#2 (ready)')
|
||
|
||
# 5. Метрики контракта есть, labels — низкой кардинальности.
|
||
required = ['http_server_request_duration_seconds_bucket', 'messenger_job_duration_seconds_bucket',
|
||
'messenger_attachment_time_to_ready_seconds_bucket', 'messenger_jobs_backlog', 'messenger_jobs_oldest_age_seconds',
|
||
'messenger_outbox_pending', 'rabbitmq_detailed_queue_messages_ready', 'db_client_connection_count',
|
||
'db_client_connection_pending_requests', 'messenger_worker_busy', 'messenger_worker_capacity',
|
||
'process_cpu_time_seconds_total', 'process_memory_usage_bytes', 'nodejs_eventloop_delay_p99_seconds']
|
||
names = set(g.prom('label/__name__/values'))
|
||
missing = [m for m in required if m not in names]
|
||
check(not missing, f'нет метрик: {missing}')
|
||
# Labels метрик приложения (у otelcol_* есть url_path — постоянный путь экспортёра, не запрос пользователя).
|
||
forbidden = {'user_id', 'chat_id', 'message_id', 'attachment_id', 'request_id', 'url', 'url_path', 'url_full', 'url_query',
|
||
'filename', 'text', 'messenger_request_id', 'messenger_job_id', 'messenger_attachment_id'}
|
||
app_labels = set(g.prom('labels', **{'match[]': '{job=~"messenger-.+"}'}))
|
||
check(not app_labels & forbidden, f'запрещённые labels: {app_labels & forbidden}')
|
||
# Значения живых серий (instant query): label values API отдаёт и устаревшие серии всего head-блока TSDB.
|
||
labels = set(g.prom('labels'))
|
||
for label in labels - {'__name__'}:
|
||
values = [r['metric'].get(label, '') for r in g.prom('query', query=f'group by ({label}) ({{{label}!=""}})')['result']]
|
||
check(not any(UUID_RE.search(v) for v in values), f'UUID в значениях label {label}')
|
||
routes = set(g.prom('label/http_route/values'))
|
||
check(routes and routes <= set(SPEC['paths']), f'http_route не из шаблонов OpenAPI: {sorted(routes - set(SPEC["paths"]))}')
|
||
print(f'PASS 5 метрики: {len(required)} обязательных есть; {len(labels)} labels без id/URL; {len(routes)} шаблонов http_route')
|
||
|
||
# 6. Секреты и содержимое не экспортируются (поиск и в прочитанных trace/логах, и по всему Loki за 30 минут).
|
||
blob = '\n'.join(raw_dump)
|
||
for name, value in (('пароль', alice['registration']['password']), ('session token', alice['token']),
|
||
('текст сообщения', text), ('имя файла', filename), ('имя файла (urlencoded)', urllib.parse.quote(filename))):
|
||
check(value not in blob, f'{name} попал в telemetry')
|
||
check(not g.logs(f'{{service_name=~"messenger-.+"}} |= `{value}`')[1], f'{name} найден в Loki')
|
||
check('Bearer ' not in blob and 'Basic ' not in blob, 'заголовок Authorization попал в telemetry')
|
||
print(f'PASS 6 секреты/контент не найдены в {len(raw_dump)} ответах Tempo/Loki и во всём Loki за 30 мин')
|
||
|
||
# 7. Dashboard из репозитория загружен provisioning-ом, его запросы находят данные за последние 15 минут
|
||
# (пустыми допустимы только панели ошибок экспорта и alerts — в норме этих серий нет).
|
||
dash = json.loads(g.get('/api/dashboards/uid/messenger-lab6'))
|
||
check(dash['meta'].get('provisioned') and dash['meta'].get('folderTitle') == 'Messenger', 'dashboard не из provisioning')
|
||
targets = [(p['title'], p['datasource']['uid'], t) for p in dash['dashboard']['panels'] for t in p.get('targets', [])]
|
||
now, empty = int(time.time()), []
|
||
for title, ds, t in targets:
|
||
if ds == 'prometheus':
|
||
q = t['expr'].replace('$__rate_interval', '1m')
|
||
found = g.prom('query_range', query=q, start=now - 900, end=now, step=30)['result']
|
||
elif ds == 'loki':
|
||
found = g.logs(t['expr'], minutes=15)[1]
|
||
else:
|
||
found = json.loads(g.get('/api/datasources/proxy/uid/tempo/api/search', q=t['query'], start=now - 900, end=now))['traces']
|
||
if not found:
|
||
empty.append(title)
|
||
allowed = re.compile(r'потер|отказ|alert', re.I)
|
||
check(all(allowed.search(t) for t in empty), f'панели без данных: {empty}')
|
||
print(f'PASS 7 dashboard «{dash["dashboard"]["title"]}»: {len(dash["dashboard"]["panels"])} панелей, '
|
||
f'{len(targets) - len(empty)}/{len(targets)} запросов с данными (пусто: {sorted(set(empty))})')
|
||
print('PASS: сигналы lab6 (traces, logs, metrics, связь через очередь, retry, отсутствие секретов, dashboard)')
|
||
|
||
|
||
if __name__ == '__main__':
|
||
run(main)
|