107 lines
5.4 KiB
Python
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()
|