Coverage for faststream/middlewares/logging.py: 95%

20 statements  

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

1import logging 

2from typing import TYPE_CHECKING, Any, Optional 

3 

4from faststream._internal.middlewares import BaseMiddleware 

5from faststream.exceptions import IgnoredException 

6from faststream.message.source_type import SourceType 

7 

8if TYPE_CHECKING: 

9 from types import TracebackType 

10 

11 from faststream._internal.basic_types import AsyncFuncAny 

12 from faststream._internal.context.repository import ContextRepo 

13 from faststream._internal.logger import LoggerState 

14 from faststream.message import StreamMessage 

15 

16 

17class CriticalLogMiddleware: 

18 __slots__ = ("logger",) 

19 

20 def __init__(self, logger: "LoggerState") -> None: 

21 """Initialize the class.""" 

22 self.logger = logger 

23 

24 def __call__( 

25 self, 

26 msg: Any | None, 

27 /, 

28 *, 

29 context: "ContextRepo", 

30 ) -> "_LoggingMiddleware": 

31 return _LoggingMiddleware( 

32 logger=self.logger, 

33 msg=msg, 

34 context=context, 

35 ) 

36 

37 

38class _LoggingMiddleware(BaseMiddleware): 

39 """A middleware class for logging critical errors.""" 

40 

41 __slots__ = ("logger", "source_type") 

42 

43 def __init__( 

44 self, 

45 *, 

46 logger: "LoggerState", 

47 context: "ContextRepo", 

48 msg: Any | None, 

49 ) -> None: 

50 super().__init__(msg, context=context) 

51 self.logger = logger 

52 self.source_type = SourceType.CONSUME 

53 

54 async def consume_scope( 

55 self, 

56 call_next: "AsyncFuncAny", 

57 msg: "StreamMessage[Any]", 

58 ) -> Any: 

59 source_type = self.source_type = msg.source_type 

60 

61 if source_type is not SourceType.RESPONSE: 

62 self.logger.log( 

63 "Received", 

64 extra=self.context.get_local("log_context", {}), 

65 ) 

66 

67 return await call_next(msg) 

68 

69 async def __aexit__( 

70 self, 

71 exc_type: type[BaseException] | None = None, 

72 exc_val: BaseException | None = None, 

73 exc_tb: Optional["TracebackType"] = None, 

74 ) -> bool: 

75 """Asynchronously called after processing.""" 

76 if self.source_type is not SourceType.RESPONSE: 76 ↛ 97line 76 didn't jump to line 97 because the condition on line 76 was always true

77 c = self.context.get_local("log_context", {}) 

78 

79 if exc_type: 

80 # TODO: move critical logging to `subscriber.consume()` method 

81 if issubclass(exc_type, IgnoredException): 

82 self.logger.log( 

83 message=str(exc_val), 

84 extra=c, 

85 ) 

86 

87 else: 

88 self.logger.log( 

89 message=f"{exc_type.__name__}: {exc_val}", 

90 log_level=logging.ERROR, 

91 exc_info=exc_val, 

92 extra=c, 

93 ) 

94 

95 self.logger.log(message="Processed", extra=c) 

96 

97 await super().__aexit__(exc_type, exc_val, exc_tb) 

98 

99 # Exception was not processed 

100 return False