Coverage for faststream/confluent/opentelemetry/provider.py: 89%

28 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1from collections.abc import Sequence 

2from typing import TYPE_CHECKING, Any, Union, cast 

3 

4from opentelemetry.semconv.trace import SpanAttributes 

5from typing_extensions import override 

6 

7from faststream._internal.types import MsgType 

8from faststream.confluent.response import KafkaPublishCommand 

9from faststream.opentelemetry import TelemetrySettingsProvider 

10from faststream.opentelemetry.consts import MESSAGING_DESTINATION_PUBLISH_NAME 

11 

12if TYPE_CHECKING: 

13 from confluent_kafka import Message 

14 

15 from faststream.message import StreamMessage 

16 from faststream.response import PublishCommand 

17 

18 

19class BaseConfluentTelemetrySettingsProvider( 

20 TelemetrySettingsProvider[MsgType, KafkaPublishCommand] 

21): 

22 __slots__ = ("messaging_system",) 

23 

24 def __init__(self) -> None: 

25 self.messaging_system = "kafka" 

26 

27 def get_publish_attrs_from_cmd(self, cmd: "KafkaPublishCommand") -> dict[str, Any]: 

28 attrs: dict[str, Any] = { 

29 SpanAttributes.MESSAGING_SYSTEM: self.messaging_system, 

30 SpanAttributes.MESSAGING_DESTINATION_NAME: cmd.destination, 

31 SpanAttributes.MESSAGING_MESSAGE_CONVERSATION_ID: cmd.correlation_id, 

32 } 

33 

34 if cmd.partition is not None: 34 ↛ 35line 34 didn't jump to line 35 because the condition on line 34 was never true

35 attrs[SpanAttributes.MESSAGING_KAFKA_DESTINATION_PARTITION] = cmd.partition 

36 

37 if cmd.key is not None: 37 ↛ 38line 37 didn't jump to line 38 because the condition on line 37 was never true

38 attrs[SpanAttributes.MESSAGING_KAFKA_MESSAGE_KEY] = cmd.key 

39 

40 return attrs 

41 

42 @override 

43 def get_publish_destination_name(self, cmd: "PublishCommand") -> str: 

44 return cmd.destination 

45 

46 

47class ConfluentTelemetrySettingsProvider( 

48 BaseConfluentTelemetrySettingsProvider["Message"], 

49): 

50 __slots__ = () 

51 

52 def get_consume_attrs_from_message( 

53 self, 

54 msg: "StreamMessage[Message]", 

55 ) -> dict[str, Any]: 

56 attrs = { 

57 SpanAttributes.MESSAGING_SYSTEM: self.messaging_system, 

58 SpanAttributes.MESSAGING_MESSAGE_ID: msg.message_id, 

59 SpanAttributes.MESSAGING_MESSAGE_CONVERSATION_ID: msg.correlation_id, 

60 SpanAttributes.MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES: len(msg.body), 

61 SpanAttributes.MESSAGING_KAFKA_DESTINATION_PARTITION: msg.raw_message.partition(), 

62 SpanAttributes.MESSAGING_KAFKA_MESSAGE_OFFSET: msg.raw_message.offset(), 

63 MESSAGING_DESTINATION_PUBLISH_NAME: msg.raw_message.topic(), 

64 } 

65 

66 if (key := msg.raw_message.key()) is not None: 

67 attrs[SpanAttributes.MESSAGING_KAFKA_MESSAGE_KEY] = key 

68 

69 return attrs 

70 

71 @override 

72 def get_consume_destination_name( 

73 self, 

74 msg: "StreamMessage[Message]", 

75 ) -> str: 

76 return cast("str", msg.raw_message.topic()) 

77 

78 

79class BatchConfluentTelemetrySettingsProvider( 

80 BaseConfluentTelemetrySettingsProvider[tuple["Message", ...]], 

81): 

82 __slots__ = () 

83 

84 def get_consume_attrs_from_message( 

85 self, 

86 msg: "StreamMessage[tuple[Message, ...]]", 

87 ) -> dict[str, Any]: 

88 raw_message = msg.raw_message[0] 

89 return { 

90 SpanAttributes.MESSAGING_SYSTEM: self.messaging_system, 

91 SpanAttributes.MESSAGING_MESSAGE_ID: msg.message_id, 

92 SpanAttributes.MESSAGING_MESSAGE_CONVERSATION_ID: msg.correlation_id, 

93 SpanAttributes.MESSAGING_BATCH_MESSAGE_COUNT: len(msg.raw_message), 

94 SpanAttributes.MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES: len( 

95 bytearray().join(cast("Sequence[bytes]", msg.body)), 

96 ), 

97 SpanAttributes.MESSAGING_KAFKA_DESTINATION_PARTITION: raw_message.partition(), 

98 MESSAGING_DESTINATION_PUBLISH_NAME: raw_message.topic(), 

99 } 

100 

101 @override 

102 def get_consume_destination_name( 

103 self, 

104 msg: "StreamMessage[tuple[Message, ...]]", 

105 ) -> str: 

106 return cast("str", msg.raw_message[0].topic()) 

107 

108 

109def telemetry_attributes_provider_factory( 

110 msg: Union["Message", Sequence["Message"], None], 

111) -> ConfluentTelemetrySettingsProvider | BatchConfluentTelemetrySettingsProvider: 

112 if isinstance(msg, Sequence): 

113 return BatchConfluentTelemetrySettingsProvider() 

114 return ConfluentTelemetrySettingsProvider()