Files
mtusi2026lab6/student-tests/telemetry_unit.py
T
2026-11-06 11:12:38 +03:00

107 lines
5.4 KiB
Python

"""Offline checks for trace propagation and telemetry redaction."""
import asyncio
import json
import logging
import sys
import unittest
from pathlib import Path
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from opentelemetry import trace, metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import InMemoryMetricReader
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from src import telemetry as tel
from src import broker
class TelemetryTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.exporter = InMemorySpanExporter()
provider = TracerProvider()
provider.add_span_processor(SimpleSpanProcessor(cls.exporter))
trace.set_tracer_provider(provider)
cls.reader = InMemoryMetricReader()
metrics.set_meter_provider(MeterProvider(metric_readers=[cls.reader]))
def test_upload_outbox_publish_consume_context(self):
self.exporter.clear()
recorded = {}
def publish(payload, headers):
recorded.update(headers)
with tel.tracer.start_as_current_span('upload') as upload:
saved = tel.carrier()
self.assertIn('traceparent', saved)
with patch.object(broker, '_publish', side_effect=publish):
asyncio.run(broker.publish({'type': 'attachment.process.v1', 'attempt': 2}, json.loads(json.dumps(saved))))
with tel.tracer.start_as_current_span('consume', context=tel.extract(recorded), kind=tel.SpanKind.CONSUMER):
pass
spans = {s.name: s for s in self.exporter.get_finished_spans()}
self.assertEqual(spans['attachment.publish'].parent.span_id, spans['upload'].context.span_id)
self.assertEqual(spans['attachment.publish'].attributes['messaging.retry.attempt'], 2)
self.assertEqual(spans['consume'].parent.span_id, spans['attachment.publish'].context.span_id)
self.assertEqual(spans['consume'].context.trace_id, spans['upload'].context.trace_id)
self.assertNotIn('type', recorded)
def test_log_formatter_only_explicit_fields(self):
rec = logging.LogRecord('test', logging.INFO, __file__, 1, 'http.request', (), None)
rec.authorization = 'secret'; rec.body = 'private message'; rec.route = '/api/v1/chats/{chat_id}'
output = tel.JsonFormatter().format(rec)
self.assertNotIn('secret', output)
self.assertNotIn('private message', output)
self.assertEqual(json.loads(output)['route'], '/api/v1/chats/{chat_id}')
def test_metrics_keep_route_template(self):
attrs = {'method': 'POST', 'route': '/api/v1/chats/{chat_id}/attachments', 'status_class': '2xx'}
tel.http_requests.add(1, attrs)
tel.http_duration.record(0.125, attrs)
result = self.reader.get_metrics_data()
data = [item for resource in result.resource_metrics for scope in resource.scope_metrics for item in scope.metrics]
requests = next(item for item in data if item.name == 'messenger.http.requests')
point = next(point for point in requests.data.data_points if point.attributes == attrs)
self.assertEqual(point.value, 1)
self.assertEqual(set(point.attributes), {'method', 'route', 'status_class'})
def test_otlp_log_drops_secrets_and_exception(self):
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import InMemoryLogExporter, SimpleLogRecordProcessor
exporter = InMemoryLogExporter()
provider = LoggerProvider()
provider.add_log_record_processor(SimpleLogRecordProcessor(exporter))
handler = LoggingHandler(logger_provider=provider)
tel.log.addHandler(handler)
try:
with tel.tracer.start_as_current_span('log-test') as span:
try:
raise ValueError('secret exception body')
except ValueError:
tel.log.exception('http.request', extra={'authorization': 'secret token', 'body': 'private', 'route': '/api/v1/users'})
record = exporter.get_finished_logs()[0].log_record
self.assertEqual(record.body, 'http.request')
self.assertEqual(record.trace_id, span.get_span_context().trace_id)
self.assertNotIn('authorization', record.attributes)
self.assertNotIn('body', record.attributes)
self.assertFalse(any(k.startswith('exception.') for k in record.attributes))
finally:
tel.log.removeHandler(handler)
provider.shutdown()
def test_failed_publish_marks_span_without_exception_content(self):
self.exporter.clear()
with patch.object(broker, '_publish', side_effect=OSError('private broker URL')):
with self.assertRaises(broker.ApiError):
asyncio.run(broker.publish({'attempt': 1}))
span, = self.exporter.get_finished_spans()
self.assertEqual(span.status.status_code, tel.StatusCode.ERROR)
self.assertEqual(span.events, ())
def test_custom_http_methods_have_bounded_label(self):
self.assertEqual(tel.http_method('POST'), 'POST')
for value in ('CUSTOM1', 'CUSTOM2', 'secret'):
self.assertEqual(tel.http_method(value), '_OTHER')
if __name__ == '__main__': unittest.main()