Coverage for tests/opentelemetry/basic.py: 99%
312 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 21:20 +0000
1import asyncio
2from collections.abc import Callable
3from types import TracebackType
4from typing import Any, cast
5from unittest.mock import MagicMock, call
7import pytest
8from dirty_equals import IsFloat, IsUUID
9from opentelemetry import baggage, context
10from opentelemetry.baggage.propagation import W3CBaggagePropagator
11from opentelemetry.sdk.metrics import MeterProvider
12from opentelemetry.sdk.metrics.export import (
13 HistogramDataPoint,
14 InMemoryMetricReader,
15 Metric,
16 NumberDataPoint,
17)
18from opentelemetry.sdk.resources import Resource
19from opentelemetry.sdk.trace import Span, TracerProvider
20from opentelemetry.sdk.trace.export import SimpleSpanProcessor
21from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
22from opentelemetry.semconv.trace import SpanAttributes as SpanAttr
23from opentelemetry.trace import SpanKind, get_current_span
25from faststream import BaseMiddleware
26from faststream.opentelemetry import Baggage, CurrentBaggage, CurrentSpan
27from faststream.opentelemetry.consts import (
28 ERROR_TYPE,
29 MESSAGING_DESTINATION_PUBLISH_NAME,
30 MessageAction as Action,
31)
32from faststream.opentelemetry.middleware import TelemetryMiddleware
33from tests.brokers.base.basic import BaseTestcaseConfig
36@pytest.mark.asyncio()
37class LocalTelemetryTestcase(BaseTestcaseConfig[Any]):
38 messaging_system: str
39 include_messages_counters: bool
40 resource: Resource = Resource.create(attributes={"service.name": "faststream.test"})
41 telemetry_middleware_class: Callable[..., TelemetryMiddleware[Any]]
43 # These tests use the patched broker as the broker itself; the base signature
44 # types it as a context manager around one.
45 def patch_broker(self, *brokers: Any, **kwargs: Any) -> Any:
46 return super().patch_broker(*brokers, **kwargs)
48 def destination_name(self, queue: str) -> str:
49 return queue
51 @staticmethod
52 def get_spans(exporter: InMemorySpanExporter) -> list[Span]:
53 spans = cast("tuple[Span, ...]", exporter.get_finished_spans())
54 return sorted(spans, key=lambda s: s.start_time or 0)
56 @staticmethod
57 def get_metrics(
58 reader: InMemoryMetricReader,
59 ) -> list[Metric]:
60 """Get sorted metrics.
62 Return order:
63 - messaging.process.duration
64 - messaging.process.messages
65 - messaging.publish.duration
66 - messaging.publish.messages
67 """
68 data = reader.get_metrics_data()
69 assert data
70 metrics = data.resource_metrics[0].scope_metrics[0].metrics
71 return sorted(metrics, key=lambda m: m.name)
73 @pytest.fixture()
74 def tracer_provider(self) -> TracerProvider:
75 return TracerProvider(resource=self.resource)
77 @pytest.fixture()
78 def trace_exporter(self, tracer_provider: TracerProvider) -> InMemorySpanExporter:
79 exporter = InMemorySpanExporter()
80 tracer_provider.add_span_processor(SimpleSpanProcessor(exporter))
81 return exporter
83 @pytest.fixture()
84 def metric_reader(self) -> InMemoryMetricReader:
85 return InMemoryMetricReader()
87 @pytest.fixture()
88 def meter_provider(self, metric_reader: InMemoryMetricReader) -> MeterProvider:
89 return MeterProvider(metric_readers=(metric_reader,), resource=self.resource)
91 def assert_span(
92 self,
93 span: Span,
94 action: str,
95 queue: str,
96 msg: str,
97 parent_span_id: int | None = None,
98 ) -> None:
99 attrs = span.attributes or {}
100 assert attrs[SpanAttr.MESSAGING_SYSTEM] == self.messaging_system, attrs[
101 SpanAttr.MESSAGING_SYSTEM
102 ]
103 assert attrs[SpanAttr.MESSAGING_MESSAGE_CONVERSATION_ID] == IsUUID, attrs[
104 SpanAttr.MESSAGING_MESSAGE_CONVERSATION_ID
105 ]
106 assert span.name == f"{self.destination_name(queue)} {action}", span.name
107 assert span.kind in {SpanKind.CONSUMER, SpanKind.PRODUCER}, span.kind
109 if span.kind == SpanKind.PRODUCER and action in {Action.CREATE, Action.PUBLISH}:
110 assert attrs[SpanAttr.MESSAGING_DESTINATION_NAME] == queue, attrs[
111 SpanAttr.MESSAGING_DESTINATION_NAME
112 ]
114 if span.kind == SpanKind.CONSUMER and action in {Action.CREATE, Action.PROCESS}:
115 assert attrs[MESSAGING_DESTINATION_PUBLISH_NAME] == queue, attrs[
116 MESSAGING_DESTINATION_PUBLISH_NAME
117 ]
118 assert attrs[SpanAttr.MESSAGING_MESSAGE_ID] == IsUUID, attrs[
119 SpanAttr.MESSAGING_MESSAGE_ID
120 ]
122 if action == Action.PROCESS:
123 assert attrs[SpanAttr.MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES] == len(msg), (
124 attrs[SpanAttr.MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES]
125 )
126 assert attrs[SpanAttr.MESSAGING_OPERATION] == action, attrs[
127 SpanAttr.MESSAGING_OPERATION
128 ]
130 if action == Action.PUBLISH:
131 assert attrs[SpanAttr.MESSAGING_OPERATION] == action, attrs[
132 SpanAttr.MESSAGING_OPERATION
133 ]
135 if parent_span_id:
136 assert span.parent
137 assert span.parent.span_id == parent_span_id, span.parent.span_id
139 def assert_metrics(
140 self,
141 metrics: list[Metric],
142 count: int = 1,
143 error_type: str | None = None,
144 ) -> None:
145 if self.include_messages_counters:
146 assert len(metrics) == 4
147 proc_dur, proc_msg, pub_dur, pub_msg = metrics
149 assert counter_point(proc_msg).value == count
150 assert counter_point(pub_msg).value == count
152 else:
153 assert len(metrics) == 2
154 proc_dur, pub_dur = metrics
156 if error_type:
157 assert (histogram_point(proc_dur).attributes or {})[ERROR_TYPE] == error_type
159 assert histogram_point(proc_dur).count == 1
160 assert histogram_point(proc_dur).sum == IsFloat
162 assert histogram_point(pub_dur).count == 1
163 assert histogram_point(pub_dur).sum == IsFloat
165 async def test_subscriber_create_publish_process_span(
166 self,
167 queue: str,
168 mock: MagicMock,
169 tracer_provider: TracerProvider,
170 trace_exporter: InMemorySpanExporter,
171 event: asyncio.Event,
172 ) -> None:
173 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider)
174 broker = self.get_broker(middlewares=(mid,))
176 args, kwargs = self.get_subscriber_params(queue)
178 @broker.subscriber(*args, **kwargs)
179 async def handler(m: Any) -> None:
180 mock(m)
181 event.set()
183 broker = self.patch_broker(broker)
184 msg = "start"
186 async with broker:
187 await broker.start()
188 tasks = (
189 asyncio.create_task(broker.publish(msg, queue)),
190 asyncio.create_task(event.wait()),
191 )
192 await asyncio.wait(tasks, timeout=self.timeout)
194 create, publish, process = self.get_spans(trace_exporter)
195 parent_span_id = create.context.span_id
197 self.assert_span(create, Action.CREATE, queue, msg)
198 self.assert_span(publish, Action.PUBLISH, queue, msg, parent_span_id)
199 self.assert_span(process, Action.PROCESS, queue, msg, parent_span_id)
201 mock.assert_called_once_with(msg)
203 async def test_chain_subscriber_publisher(
204 self,
205 queue: str,
206 mock: MagicMock,
207 tracer_provider: TracerProvider,
208 trace_exporter: InMemorySpanExporter,
209 event: asyncio.Event,
210 ) -> None:
211 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider)
212 broker = self.get_broker(middlewares=(mid,))
214 first_queue = queue
215 second_queue = queue + "2"
217 args, kwargs = self.get_subscriber_params(first_queue)
219 @broker.subscriber(*args, **kwargs)
220 @broker.publisher(second_queue)
221 async def handler1(m: Any) -> Any:
222 return m
224 args2, kwargs2 = self.get_subscriber_params(second_queue)
226 @broker.subscriber(*args2, **kwargs2)
227 async def handler2(m: Any) -> None:
228 mock(m)
229 event.set()
231 broker = self.patch_broker(broker)
232 msg = "start"
234 async with broker:
235 await broker.start()
236 tasks = (
237 asyncio.create_task(broker.publish(msg, queue)),
238 asyncio.create_task(event.wait()),
239 )
240 await asyncio.wait(tasks, timeout=self.timeout)
242 spans = self.get_spans(trace_exporter)
243 create, pub1, proc1, pub2, proc2 = spans
244 parent_span_id = create.context.span_id
246 self.assert_span(create, Action.CREATE, first_queue, msg)
247 self.assert_span(pub1, Action.PUBLISH, first_queue, msg, parent_span_id)
248 self.assert_span(proc1, Action.PROCESS, first_queue, msg, parent_span_id)
249 self.assert_span(pub2, Action.PUBLISH, second_queue, msg, proc1.context.span_id)
250 self.assert_span(proc2, Action.PROCESS, second_queue, msg, parent_span_id)
252 starts = [span.start_time for span in (create, pub1, proc1, pub2, proc2)]
253 # strictly increasing, and every span has started
254 assert starts == sorted(set(filter(None, starts)))
256 mock.assert_called_once_with(msg)
258 @pytest.mark.flaky(reruns=3, reruns_delay=1)
259 async def test_no_trace_context_create_process_span(
260 self,
261 queue: str,
262 tracer_provider: TracerProvider,
263 trace_exporter: InMemorySpanExporter,
264 event: asyncio.Event,
265 ) -> None:
266 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider)
267 broker = self.get_broker(middlewares=(mid,))
268 broker_without_middlewares = self.get_broker()
270 args, kwargs = self.get_subscriber_params(queue)
272 @broker.subscriber(*args, **kwargs)
273 async def handler(m: Any) -> None:
274 event.set()
276 broker = self.patch_broker(broker)
277 msg = "start"
279 async with broker, broker_without_middlewares:
280 await broker.start()
281 await broker_without_middlewares.start()
283 broker.config.broker_config.middlewares = ()
284 tasks = (
285 asyncio.create_task(broker_without_middlewares.publish(msg, queue)),
286 asyncio.create_task(event.wait()),
287 )
288 await asyncio.wait(tasks, timeout=self.timeout)
290 create, process = self.get_spans(trace_exporter)
291 parent_span_id = create.context.span_id
293 self.assert_span(create, Action.CREATE, queue, msg)
294 self.assert_span(process, Action.PROCESS, queue, msg, parent_span_id)
296 async def test_metrics(
297 self,
298 queue: str,
299 mock: MagicMock,
300 meter_provider: MeterProvider,
301 metric_reader: InMemoryMetricReader,
302 event: asyncio.Event,
303 ) -> None:
304 mid = self.telemetry_middleware_class(meter_provider=meter_provider)
305 broker = self.get_broker(middlewares=(mid,))
307 args, kwargs = self.get_subscriber_params(queue)
309 @broker.subscriber(*args, **kwargs)
310 async def handler(m: Any) -> None:
311 mock(m)
312 event.set()
314 broker = self.patch_broker(broker)
315 msg = "start"
317 async with broker:
318 await broker.start()
319 tasks = (
320 asyncio.create_task(broker.publish(msg, queue)),
321 asyncio.create_task(event.wait()),
322 )
323 await asyncio.wait(tasks, timeout=self.timeout)
325 metrics = self.get_metrics(metric_reader)
327 self.assert_metrics(metrics)
328 mock.assert_called_once_with(msg)
330 async def test_error_metrics(
331 self,
332 queue: str,
333 mock: MagicMock,
334 meter_provider: MeterProvider,
335 metric_reader: InMemoryMetricReader,
336 event: asyncio.Event,
337 ) -> None:
338 mid = self.telemetry_middleware_class(meter_provider=meter_provider)
339 broker = self.get_broker(middlewares=(mid,))
340 expected_value_type = "ValueError"
342 args, kwargs = self.get_subscriber_params(queue)
344 @broker.subscriber(*args, **kwargs)
345 async def handler(m: Any) -> None:
346 try:
347 raise ValueError
348 finally:
349 mock(m)
350 event.set()
352 broker = self.patch_broker(broker)
353 msg = "start"
355 async with broker:
356 await broker.start()
357 tasks = (
358 asyncio.create_task(broker.publish(msg, queue)),
359 asyncio.create_task(event.wait()),
360 )
361 await asyncio.wait(tasks, timeout=self.timeout)
363 metrics = self.get_metrics(metric_reader)
365 self.assert_metrics(metrics, error_type=expected_value_type)
366 mock.assert_called_once_with(msg)
368 async def test_span_in_context(
369 self,
370 queue: str,
371 mock: MagicMock,
372 tracer_provider: TracerProvider,
373 event: asyncio.Event,
374 ) -> None:
375 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider)
376 broker = self.get_broker(middlewares=(mid,), apply_types=True)
378 args, kwargs = self.get_subscriber_params(queue)
380 @broker.subscriber(*args, **kwargs)
381 async def handler(m: Any, span: CurrentSpan) -> None:
382 mock(m, span_is_current=span is get_current_span())
383 event.set()
385 broker = self.patch_broker(broker)
386 msg = "start"
388 async with broker:
389 await broker.start()
390 tasks = (
391 asyncio.create_task(broker.publish(msg, queue)),
392 asyncio.create_task(event.wait()),
393 )
394 await asyncio.wait(tasks, timeout=self.timeout)
396 mock.assert_called_once_with(msg, span_is_current=True)
398 async def test_get_baggage(
399 self,
400 queue: str,
401 mock: MagicMock,
402 event: asyncio.Event,
403 ) -> None:
404 mid = self.telemetry_middleware_class()
405 broker = self.get_broker(middlewares=(mid,), apply_types=True)
406 expected_baggage = {"foo": "bar"}
408 args, kwargs = self.get_subscriber_params(queue)
410 @broker.subscriber(*args, **kwargs)
411 async def handler1(m: Any, baggage: CurrentBaggage) -> None:
412 mock(
413 m,
414 foo=baggage.get("foo"),
415 baggage=baggage.get_all(),
416 batch=baggage.get_all_batch(),
417 repr=repr(baggage),
418 )
419 event.set()
421 broker = self.patch_broker(broker)
422 msg = "start"
424 async with broker:
425 await broker.start()
426 tasks = (
427 asyncio.create_task(
428 broker.publish(
429 msg,
430 queue,
431 headers=Baggage({"foo": "bar"}).to_headers(),
432 ),
433 ),
434 asyncio.create_task(event.wait()),
435 )
436 await asyncio.wait(tasks, timeout=self.timeout)
438 mock.assert_called_once_with(
439 msg,
440 foo="bar",
441 baggage=expected_baggage,
442 batch=[],
443 repr=repr(expected_baggage),
444 )
446 async def test_clear_baggage(
447 self,
448 queue: str,
449 mock: MagicMock,
450 event: asyncio.Event,
451 ) -> None:
452 mid = self.telemetry_middleware_class()
453 broker = self.get_broker(middlewares=(mid,), apply_types=True)
455 first_queue = queue + "1"
456 second_queue = queue + "2"
458 args, kwargs = self.get_subscriber_params(first_queue)
460 @broker.subscriber(*args, **kwargs)
461 @broker.publisher(second_queue)
462 async def handler1(m: Any, baggage: CurrentBaggage) -> Any:
463 baggage.clear()
464 mock.cleared(baggage.get_all())
465 return m
467 args2, kwargs2 = self.get_subscriber_params(second_queue)
469 @broker.subscriber(*args2, **kwargs2)
470 async def handler2(m: Any, baggage: CurrentBaggage) -> None:
471 mock(m, baggage=baggage.get_all())
472 event.set()
474 broker = self.patch_broker(broker)
475 msg = "start"
477 async with broker:
478 await broker.start()
479 tasks = (
480 asyncio.create_task(
481 broker.publish(
482 msg,
483 first_queue,
484 headers=Baggage({"foo": "bar"}).to_headers(),
485 ),
486 ),
487 asyncio.create_task(event.wait()),
488 )
489 await asyncio.wait(tasks, timeout=self.timeout)
491 assert mock.mock_calls == [call.cleared({}), call(msg, baggage={})]
493 async def test_modify_baggage(
494 self,
495 queue: str,
496 mock: MagicMock,
497 event: asyncio.Event,
498 ) -> None:
499 mid = self.telemetry_middleware_class()
500 broker = self.get_broker(middlewares=(mid,), apply_types=True)
501 expected_baggage = {"baz": "bar", "bar": "baz"}
503 first_queue = queue + "1"
504 second_queue = queue + "2"
506 args, kwargs = self.get_subscriber_params(first_queue)
508 @broker.subscriber(*args, **kwargs)
509 @broker.publisher(second_queue)
510 async def handler1(m: Any, baggage: CurrentBaggage) -> Any:
511 baggage.set("bar", "baz")
512 baggage.set("baz", "bar")
513 baggage.remove("foo")
514 return m
516 args2, kwargs2 = self.get_subscriber_params(second_queue)
518 @broker.subscriber(*args2, **kwargs2)
519 async def handler2(m: Any, baggage: CurrentBaggage) -> None:
520 mock(m, baggage=baggage.get_all())
521 event.set()
523 broker = self.patch_broker(broker)
524 msg = "start"
526 async with broker:
527 await broker.start()
528 tasks = (
529 asyncio.create_task(
530 broker.publish(
531 msg,
532 first_queue,
533 headers=Baggage({"foo": "bar"}).to_headers(),
534 ),
535 ),
536 asyncio.create_task(event.wait()),
537 )
538 await asyncio.wait(tasks, timeout=self.timeout)
540 mock.assert_called_once_with(msg, baggage=expected_baggage)
542 async def test_get_baggage_from_headers(
543 self,
544 queue: str,
545 mock: MagicMock,
546 event: asyncio.Event,
547 ) -> None:
548 mid = self.telemetry_middleware_class()
549 broker = self.get_broker(middlewares=(mid,), apply_types=True)
551 args, kwargs = self.get_subscriber_params(queue)
553 expected_baggage = {"foo": "bar", "bar": "baz"}
555 ctx = context.Context()
556 for key, value in expected_baggage.items():
557 ctx = baggage.set_baggage(key, value, context=ctx)
559 propagator = W3CBaggagePropagator()
560 headers: dict[str, Any] = {}
561 propagator.inject(headers, context=ctx)
563 @broker.subscriber(*args, **kwargs)
564 async def handler() -> None:
565 mock(Baggage.from_headers(headers).get_all())
566 event.set()
568 broker = self.patch_broker(broker)
569 msg = "start"
571 async with broker:
572 await broker.start()
573 tasks = (
574 asyncio.create_task(broker.publish(msg, queue, headers=headers)),
575 asyncio.create_task(event.wait()),
576 )
577 await asyncio.wait(tasks, timeout=self.timeout)
579 mock.assert_called_once_with(expected_baggage)
581 async def test_correct_finalize_tokens(
582 self,
583 queue: str,
584 event: asyncio.Event,
585 mock: MagicMock,
586 tracer_provider: TracerProvider,
587 ) -> None:
588 class CaptureExceptionMiddleware(BaseMiddleware):
589 target_taken = False
591 def __init__(self, *args: Any, **kwargs: Any) -> None:
592 super().__init__(*args, **kwargs)
593 self.is_target = self.msg is not None and not self.target_taken
594 if self.is_target:
595 type(self).target_taken = True
597 async def after_processed(
598 self,
599 exc_type: type[BaseException] | None = None,
600 exc_val: BaseException | None = None,
601 exc_tb: TracebackType | None = None,
602 ) -> Any:
603 if self.is_target: 603 ↛ 607line 603 didn't jump to line 607 because the condition on line 603 was always true
604 mock(exc_val)
605 event.set()
607 return await super().after_processed(exc_type, exc_val, exc_tb)
609 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider)
610 broker = self.get_broker(
611 middlewares=(mid, CaptureExceptionMiddleware),
612 apply_types=True,
613 )
615 args, kwargs = self.get_subscriber_params(queue)
617 @broker.subscriber(*args, **kwargs)
618 @broker.publisher(f"{queue}-out1")
619 @broker.publisher(f"{queue}-out2")
620 async def handler(msg: str) -> str:
621 return f"handled:{msg}"
623 async with broker:
624 await broker.start()
625 await broker.publish("msg", queue)
626 await asyncio.wait_for(event.wait(), timeout=self.timeout)
628 mock.assert_called_once_with(None)
631def counter_point(metric: Metric) -> NumberDataPoint:
632 point = metric.data.data_points[0]
633 assert isinstance(point, NumberDataPoint)
634 return point
637def histogram_point(metric: Metric) -> HistogramDataPoint:
638 point = metric.data.data_points[0]
639 assert isinstance(point, HistogramDataPoint)
640 return point