From 9f42408d2654a2fe7334ef0ba1197e1f3047b43b Mon Sep 17 00:00:00 2001 From: dhairyakhandelwal880-dotcom Date: Wed, 18 Nov 2026 22:15:56 +0530 Subject: [PATCH] fix(logger): route log, warn, and fatal through buffer dispatch (#8827) --- .../logging/buffer/functions.py | 3 +- aws_lambda_powertools/logging/logger.py | 204 ++++++++---------- .../test_powertools_logger_buffer.py | 49 +++++ 3 files changed, 145 insertions(+), 111 deletions(-) diff --git a/aws_lambda_powertools/logging/buffer/functions.py b/aws_lambda_powertools/logging/buffer/functions.py index f21d2429fbb..6503b02d389 100644 --- a/aws_lambda_powertools/logging/buffer/functions.py +++ b/aws_lambda_powertools/logging/buffer/functions.py @@ -16,6 +16,7 @@ def _create_buffer_record( exc_info: logging._ExcInfoType = None, stack_info: bool = False, extra: Mapping[str, object] | None = None, + depth: int = 4, ) -> dict[str, Any]: """ Create a structured log record for buffering to save in buffer. @@ -47,7 +48,7 @@ def _create_buffer_record( """ # Retrieve the caller's frame information to capture precise log context # Uses inspect.stack() with index 3 to get the original caller's details - caller_frame = sys._getframe(3) + caller_frame = sys._getframe(depth) # Get the current timestamp timestamp = time.time() diff --git a/aws_lambda_powertools/logging/logger.py b/aws_lambda_powertools/logging/logger.py index 5d2a515d516..eed72927e32 100644 --- a/aws_lambda_powertools/logging/logger.py +++ b/aws_lambda_powertools/logging/logger.py @@ -567,8 +567,9 @@ def decorate(event, context, *args, **kwargs): return decorate - def debug( + def _log( self, + level: int | str, msg: object, *args: object, exc_info: logging._ExcInfoType = None, @@ -580,18 +581,14 @@ def debug( extra = extra or {} extra = {**extra, **kwargs} - # Logging workflow for logging.debug: - # 1. Buffer is completely disabled - log right away - # 2. DEBUG is the maximum level of buffer, so, can't bypass if enabled - # 3. Store in buffer for potential later processing + level_num = logging._checkLevel(level) - # MAINTAINABILITY_DECISION: - # Keeping this implementation to avoid complex code handling. - # Also for clarity over complexity + if level_num >= logging.ERROR: + if self._buffer_config and self._buffer_config.flush_on_error_log: + self.flush_buffer() - # Buffer is not active and we need to log immediately - if not self._buffer_config: - return self._logger.debug( + return self._logger.log( + level_num, msg, *args, exc_info=exc_info, @@ -600,41 +597,10 @@ def debug( extra=extra, ) - # Store record in the buffer - self._add_log_record_to_buffer( - level=logging.DEBUG, - msg=msg, - args=args, - exc_info=exc_info, - stack_info=stack_info, - extra=extra, - ) - - def info( - self, - msg: object, - *args: object, - exc_info: logging._ExcInfoType = None, - stack_info: bool = False, - stacklevel: int = 2, - extra: Mapping[str, object] | None = None, - **kwargs: object, - ) -> None: - extra = extra or {} - extra = {**extra, **kwargs} - - # Logging workflow for logging.info: - # 1. Buffer is completely disabled - log right away - # 2. Log severity exceeds buffer's minimum threshold - bypass buffering - # 3. If neither condition met, store in buffer for potential later processing - - # MAINTAINABILITY_DECISION: - # Keeping this implementation to avoid complex code handling. - # Also for clarity over complexity - # Buffer is not active and we need to log immediately if not self._buffer_config: - return self._logger.info( + return self._logger.log( + level_num, msg, *args, exc_info=exc_info, @@ -644,8 +610,10 @@ def info( ) # Bypass buffer when log severity meets or exceeds configured minimum - if _check_minimum_buffer_log_level(self._buffer_config.buffer_at_verbosity, "INFO"): - return self._logger.info( + level_name = logging.getLevelName(level_num) + if _check_minimum_buffer_log_level(self._buffer_config.buffer_at_verbosity, level_name): + return self._logger.log( + level_num, msg, *args, exc_info=exc_info, @@ -656,7 +624,7 @@ def info( # Store record in the buffer self._add_log_record_to_buffer( - level=logging.INFO, + level=level_num, msg=msg, args=args, exc_info=exc_info, @@ -664,7 +632,7 @@ def info( extra=extra, ) - def warning( + def debug( self, msg: object, *args: object, @@ -674,48 +642,57 @@ def warning( extra: Mapping[str, object] | None = None, **kwargs: object, ) -> None: - extra = extra or {} - extra = {**extra, **kwargs} - - # Logging workflow for logging.warning: - # 1. Buffer is completely disabled - log right away - # 2. Log severity exceeds buffer's minimum threshold - bypass buffering - # 3. If neither condition met, store in buffer for potential later processing - - # MAINTAINABILITY_DECISION: - # Keeping this implementation to avoid complex code handling. - # Also for clarity over complexity - - # Buffer is not active and we need to log immediately - if not self._buffer_config: - return self._logger.warning( - msg, - *args, - exc_info=exc_info, - stack_info=stack_info, - stacklevel=stacklevel, - extra=extra, - ) + return self._log( + logging.DEBUG, + msg, + *args, + exc_info=exc_info, + stack_info=stack_info, + stacklevel=stacklevel + 1, + extra=extra, + **kwargs, + ) - # Bypass buffer when log severity meets or exceeds configured minimum - if _check_minimum_buffer_log_level(self._buffer_config.buffer_at_verbosity, "WARNING"): - return self._logger.warning( - msg, - *args, - exc_info=exc_info, - stack_info=stack_info, - stacklevel=stacklevel, - extra=extra, - ) + def info( + self, + msg: object, + *args: object, + exc_info: logging._ExcInfoType = None, + stack_info: bool = False, + stacklevel: int = 2, + extra: Mapping[str, object] | None = None, + **kwargs: object, + ) -> None: + return self._log( + logging.INFO, + msg, + *args, + exc_info=exc_info, + stack_info=stack_info, + stacklevel=stacklevel + 1, + extra=extra, + **kwargs, + ) - # Store record in the buffer - self._add_log_record_to_buffer( - level=logging.WARNING, - msg=msg, - args=args, + def warning( + self, + msg: object, + *args: object, + exc_info: logging._ExcInfoType = None, + stack_info: bool = False, + stacklevel: int = 2, + extra: Mapping[str, object] | None = None, + **kwargs: object, + ) -> None: + return self._log( + logging.WARNING, + msg, + *args, exc_info=exc_info, stack_info=stack_info, + stacklevel=stacklevel + 1, extra=extra, + **kwargs, ) def error( @@ -728,24 +705,15 @@ def error( extra: Mapping[str, object] | None = None, **kwargs: object, ) -> None: - extra = extra or {} - extra = {**extra, **kwargs} - - # Workflow: Error Logging with automatic buffer flushing - # 1. Buffer configuration checked for immediate flush - # 2. If auto-flush enabled, trigger complete buffer processing - # 3. Error log is not "bufferable", so ensure error log is immediately available - - if self._buffer_config and self._buffer_config.flush_on_error_log: - self.flush_buffer() - - return self._logger.error( + return self._log( + logging.ERROR, msg, *args, exc_info=exc_info, stack_info=stack_info, - stacklevel=stacklevel, + stacklevel=stacklevel + 1, extra=extra, + **kwargs, ) def critical( @@ -758,26 +726,42 @@ def critical( extra: Mapping[str, object] | None = None, **kwargs: object, ) -> None: - extra = extra or {} - extra = {**extra, **kwargs} - - # Workflow: Error Logging with automatic buffer flushing - # 1. Buffer configuration checked for immediate flush - # 2. If auto-flush enabled, trigger complete buffer processing - # 3. Critical log is not "bufferable", so ensure error log is immediately available - - if self._buffer_config and self._buffer_config.flush_on_error_log: - self.flush_buffer() + return self._log( + logging.CRITICAL, + msg, + *args, + exc_info=exc_info, + stack_info=stack_info, + stacklevel=stacklevel + 1, + extra=extra, + **kwargs, + ) - return self._logger.critical( + def log( + self, + level: int | str, + msg: object, + *args: object, + exc_info: logging._ExcInfoType = None, + stack_info: bool = False, + stacklevel: int = 2, + extra: Mapping[str, object] | None = None, + **kwargs: object, + ) -> None: + return self._log( + level, msg, *args, exc_info=exc_info, stack_info=stack_info, - stacklevel=stacklevel, + stacklevel=stacklevel + 1, extra=extra, + **kwargs, ) + warn = warning + fatal = critical + def exception( self, msg: object, diff --git a/tests/functional/logger/required_dependencies/test_powertools_logger_buffer.py b/tests/functional/logger/required_dependencies/test_powertools_logger_buffer.py index c25ad5e9747..3e694d8d976 100644 --- a/tests/functional/logger/required_dependencies/test_powertools_logger_buffer.py +++ b/tests/functional/logger/required_dependencies/test_powertools_logger_buffer.py @@ -4,6 +4,7 @@ import io import json +import logging import random import string import warnings @@ -584,3 +585,51 @@ def test_flush_buffer_preserves_percent_style_formatting(stdout, service_name, m # THEN The flushed log should contain the interpolated message log = capture_multiple_logging_statements_output(stdout) assert log[0]["message"] == "user=alice count=42" + + +def test_logger_log_method_buffers_and_flushes_on_error(stdout, service_name, monkeypatch): + monkeypatch.setenv(constants.XRAY_TRACE_ID_ENV, "1-67c39786-5908a82a246fb67f3089263f") + + # GIVEN A logger configured with buffer and flush on error + logger_buffer_config = LoggerBufferConfig(max_bytes=10240, flush_on_error_log=True) + logger = Logger(level="DEBUG", service=service_name, stream=stdout, buffer_config=logger_buffer_config) + + # WHEN Logging debug via log() method + logger.log(logging.DEBUG, "buffered via log()") + + # THEN Message should be buffered, not immediately output + log = capture_multiple_logging_statements_output(stdout) + assert not log + + # WHEN Logging error via log() method + logger.log(logging.ERROR, "error via log()") + + # THEN Both the buffered debug log and error log should be output + log = capture_multiple_logging_statements_output(stdout) + assert len(log) == 2 + assert log[0]["message"] == "buffered via log()" + assert log[1]["message"] == "error via log()" + + +def test_logger_warn_and_fatal_aliases(stdout, service_name, monkeypatch): + monkeypatch.setenv(constants.XRAY_TRACE_ID_ENV, "1-67c39786-5908a82a246fb67f3089263f") + + # GIVEN A logger configured with buffer and flush on error + logger_buffer_config = LoggerBufferConfig(max_bytes=10240, buffer_at_verbosity="WARNING", flush_on_error_log=True) + logger = Logger(level="DEBUG", service=service_name, stream=stdout, buffer_config=logger_buffer_config) + + # WHEN Logging via warn() alias + logger.warn("buffered via warn()") + + # THEN Message should be buffered + log = capture_multiple_logging_statements_output(stdout) + assert not log + + # WHEN Logging via fatal() alias + logger.fatal("flushed via fatal()") + + # THEN Buffer should flush and both messages should appear + log = capture_multiple_logging_statements_output(stdout) + assert len(log) == 2 + assert log[0]["message"] == "buffered via warn()" + assert log[1]["message"] == "flushed via fatal()"