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

1import asyncio 

2from collections.abc import Callable 

3from types import TracebackType 

4from typing import Any, cast 

5from unittest.mock import MagicMock, call 

6 

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 

24 

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 

34 

35 

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]] 

42 

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) 

47 

48 def destination_name(self, queue: str) -> str: 

49 return queue 

50 

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) 

55 

56 @staticmethod 

57 def get_metrics( 

58 reader: InMemoryMetricReader, 

59 ) -> list[Metric]: 

60 """Get sorted metrics. 

61 

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) 

72 

73 @pytest.fixture() 

74 def tracer_provider(self) -> TracerProvider: 

75 return TracerProvider(resource=self.resource) 

76 

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 

82 

83 @pytest.fixture() 

84 def metric_reader(self) -> InMemoryMetricReader: 

85 return InMemoryMetricReader() 

86 

87 @pytest.fixture() 

88 def meter_provider(self, metric_reader: InMemoryMetricReader) -> MeterProvider: 

89 return MeterProvider(metric_readers=(metric_reader,), resource=self.resource) 

90 

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 

108 

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 ] 

113 

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 ] 

121 

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 ] 

129 

130 if action == Action.PUBLISH: 

131 assert attrs[SpanAttr.MESSAGING_OPERATION] == action, attrs[ 

132 SpanAttr.MESSAGING_OPERATION 

133 ] 

134 

135 if parent_span_id: 

136 assert span.parent 

137 assert span.parent.span_id == parent_span_id, span.parent.span_id 

138 

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 

148 

149 assert counter_point(proc_msg).value == count 

150 assert counter_point(pub_msg).value == count 

151 

152 else: 

153 assert len(metrics) == 2 

154 proc_dur, pub_dur = metrics 

155 

156 if error_type: 

157 assert (histogram_point(proc_dur).attributes or {})[ERROR_TYPE] == error_type 

158 

159 assert histogram_point(proc_dur).count == 1 

160 assert histogram_point(proc_dur).sum == IsFloat 

161 

162 assert histogram_point(pub_dur).count == 1 

163 assert histogram_point(pub_dur).sum == IsFloat 

164 

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,)) 

175 

176 args, kwargs = self.get_subscriber_params(queue) 

177 

178 @broker.subscriber(*args, **kwargs) 

179 async def handler(m: Any) -> None: 

180 mock(m) 

181 event.set() 

182 

183 broker = self.patch_broker(broker) 

184 msg = "start" 

185 

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) 

193 

194 create, publish, process = self.get_spans(trace_exporter) 

195 parent_span_id = create.context.span_id 

196 

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) 

200 

201 mock.assert_called_once_with(msg) 

202 

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,)) 

213 

214 first_queue = queue 

215 second_queue = queue + "2" 

216 

217 args, kwargs = self.get_subscriber_params(first_queue) 

218 

219 @broker.subscriber(*args, **kwargs) 

220 @broker.publisher(second_queue) 

221 async def handler1(m: Any) -> Any: 

222 return m 

223 

224 args2, kwargs2 = self.get_subscriber_params(second_queue) 

225 

226 @broker.subscriber(*args2, **kwargs2) 

227 async def handler2(m: Any) -> None: 

228 mock(m) 

229 event.set() 

230 

231 broker = self.patch_broker(broker) 

232 msg = "start" 

233 

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) 

241 

242 spans = self.get_spans(trace_exporter) 

243 create, pub1, proc1, pub2, proc2 = spans 

244 parent_span_id = create.context.span_id 

245 

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) 

251 

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))) 

255 

256 mock.assert_called_once_with(msg) 

257 

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() 

269 

270 args, kwargs = self.get_subscriber_params(queue) 

271 

272 @broker.subscriber(*args, **kwargs) 

273 async def handler(m: Any) -> None: 

274 event.set() 

275 

276 broker = self.patch_broker(broker) 

277 msg = "start" 

278 

279 async with broker, broker_without_middlewares: 

280 await broker.start() 

281 await broker_without_middlewares.start() 

282 

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) 

289 

290 create, process = self.get_spans(trace_exporter) 

291 parent_span_id = create.context.span_id 

292 

293 self.assert_span(create, Action.CREATE, queue, msg) 

294 self.assert_span(process, Action.PROCESS, queue, msg, parent_span_id) 

295 

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,)) 

306 

307 args, kwargs = self.get_subscriber_params(queue) 

308 

309 @broker.subscriber(*args, **kwargs) 

310 async def handler(m: Any) -> None: 

311 mock(m) 

312 event.set() 

313 

314 broker = self.patch_broker(broker) 

315 msg = "start" 

316 

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) 

324 

325 metrics = self.get_metrics(metric_reader) 

326 

327 self.assert_metrics(metrics) 

328 mock.assert_called_once_with(msg) 

329 

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" 

341 

342 args, kwargs = self.get_subscriber_params(queue) 

343 

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() 

351 

352 broker = self.patch_broker(broker) 

353 msg = "start" 

354 

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) 

362 

363 metrics = self.get_metrics(metric_reader) 

364 

365 self.assert_metrics(metrics, error_type=expected_value_type) 

366 mock.assert_called_once_with(msg) 

367 

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) 

377 

378 args, kwargs = self.get_subscriber_params(queue) 

379 

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() 

384 

385 broker = self.patch_broker(broker) 

386 msg = "start" 

387 

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) 

395 

396 mock.assert_called_once_with(msg, span_is_current=True) 

397 

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"} 

407 

408 args, kwargs = self.get_subscriber_params(queue) 

409 

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() 

420 

421 broker = self.patch_broker(broker) 

422 msg = "start" 

423 

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) 

437 

438 mock.assert_called_once_with( 

439 msg, 

440 foo="bar", 

441 baggage=expected_baggage, 

442 batch=[], 

443 repr=repr(expected_baggage), 

444 ) 

445 

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) 

454 

455 first_queue = queue + "1" 

456 second_queue = queue + "2" 

457 

458 args, kwargs = self.get_subscriber_params(first_queue) 

459 

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 

466 

467 args2, kwargs2 = self.get_subscriber_params(second_queue) 

468 

469 @broker.subscriber(*args2, **kwargs2) 

470 async def handler2(m: Any, baggage: CurrentBaggage) -> None: 

471 mock(m, baggage=baggage.get_all()) 

472 event.set() 

473 

474 broker = self.patch_broker(broker) 

475 msg = "start" 

476 

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) 

490 

491 assert mock.mock_calls == [call.cleared({}), call(msg, baggage={})] 

492 

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"} 

502 

503 first_queue = queue + "1" 

504 second_queue = queue + "2" 

505 

506 args, kwargs = self.get_subscriber_params(first_queue) 

507 

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 

515 

516 args2, kwargs2 = self.get_subscriber_params(second_queue) 

517 

518 @broker.subscriber(*args2, **kwargs2) 

519 async def handler2(m: Any, baggage: CurrentBaggage) -> None: 

520 mock(m, baggage=baggage.get_all()) 

521 event.set() 

522 

523 broker = self.patch_broker(broker) 

524 msg = "start" 

525 

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) 

539 

540 mock.assert_called_once_with(msg, baggage=expected_baggage) 

541 

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) 

550 

551 args, kwargs = self.get_subscriber_params(queue) 

552 

553 expected_baggage = {"foo": "bar", "bar": "baz"} 

554 

555 ctx = context.Context() 

556 for key, value in expected_baggage.items(): 

557 ctx = baggage.set_baggage(key, value, context=ctx) 

558 

559 propagator = W3CBaggagePropagator() 

560 headers: dict[str, Any] = {} 

561 propagator.inject(headers, context=ctx) 

562 

563 @broker.subscriber(*args, **kwargs) 

564 async def handler() -> None: 

565 mock(Baggage.from_headers(headers).get_all()) 

566 event.set() 

567 

568 broker = self.patch_broker(broker) 

569 msg = "start" 

570 

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) 

578 

579 mock.assert_called_once_with(expected_baggage) 

580 

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 

590 

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 

596 

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() 

606 

607 return await super().after_processed(exc_type, exc_val, exc_tb) 

608 

609 mid = self.telemetry_middleware_class(tracer_provider=tracer_provider) 

610 broker = self.get_broker( 

611 middlewares=(mid, CaptureExceptionMiddleware), 

612 apply_types=True, 

613 ) 

614 

615 args, kwargs = self.get_subscriber_params(queue) 

616 

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}" 

622 

623 async with broker: 

624 await broker.start() 

625 await broker.publish("msg", queue) 

626 await asyncio.wait_for(event.wait(), timeout=self.timeout) 

627 

628 mock.assert_called_once_with(None) 

629 

630 

631def counter_point(metric: Metric) -> NumberDataPoint: 

632 point = metric.data.data_points[0] 

633 assert isinstance(point, NumberDataPoint) 

634 return point 

635 

636 

637def histogram_point(metric: Metric) -> HistogramDataPoint: 

638 point = metric.data.data_points[0] 

639 assert isinstance(point, HistogramDataPoint) 

640 return point