Adding exception fields

Author: leandrodamascena

aws_lambda_powertools/logging/buffer/functions.py

@@ -1,19 +1,63 @@
 from __future__ import annotations
 
 import inspect
+import sys
 import time
-from typing import Any, Mapping
+from typing import TYPE_CHECKING, Any, Mapping
+
+if TYPE_CHECKING:
+    import logging
 
 
 def _create_buffer_record(
     level: int,
     msg: object,
     args: object,
+    exc_info: logging._ExcInfoType = None,
+    stack_info: bool = False,
     extra: Mapping[str, object] | None = None,
 ) -> dict[str, Any]:
+    """
+    Create a structured log record for buffering to save in buffer.
+
+    Parameters
+    ----------
+    level : int
+        Logging level (e.g., logging.DEBUG, logging.INFO) indicating log severity.
+    msg : object
+        The log message to be recorded.
+    args : object
+        Additional arguments associated with the log message.
+    exc_info : logging._ExcInfoType, optional
+        Exception information to be included in the log record.
+        If None, no exception details will be captured.
+    stack_info : bool, default False
+        Flag to include stack trace information in the log record.
+    extra : Mapping[str, object], optional
+        Additional context or metadata to be attached to the log record.
+
+    Returns
+    -------
+    dict[str, Any]
+
+    Notes
+    -----
+    - Captures caller frame information for precise log source tracking
+    - Automatically handles exception context
+    """
+    # 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 = inspect.stack()[3]
+
+    # Get the current timestamp
     timestamp = time.time()
 
+    # Dynamically replace exc_info with current system exception information
+    # This ensures the most recent exception is captured if available
+    if exc_info:
+        exc_info = sys.exc_info()
+
+    # Construct and return the og record dictionary
     return {
         "level": level,
         "msg": msg,
@@ -23,11 +67,47 @@ def _create_buffer_record(
         "function": caller_frame.function,
         "extra": extra,
         "timestamp": timestamp,
+        "exc_info": exc_info,
+        "stack_info": stack_info,
     }
 
 
 def _check_minimum_buffer_log_level(buffer_log_level, current_log_level):
-    # Define log level mapping
+    """
+    Determine if the current log level meets or exceeds the buffer's minimum log level.
+
+    Compares log levels to decide whether a log message should be included in the buffer.
+
+    Parameters
+    ----------
+    buffer_log_level : str
+        Minimum log level configured for the buffer.
+        Must be one of: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'.
+    current_log_level : str
+        Log level of the current log message.
+        Must be one of: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'.
+
+    Returns
+    -------
+    bool
+        True if the current log level is lower (more verbose) than the buffer's
+        minimum log level, indicating the message should be buffered.
+        False if the current log level is higher (less verbose) and should not be buffered.
+
+    Notes
+    -----
+    - Log levels are compared based on their numeric severity
+    - Conversion to uppercase ensures case-insensitive comparisons
+
+    Examples
+    --------
+    >>> _check_minimum_buffer_log_level('INFO', 'DEBUG')
+    True
+    >>> _check_minimum_buffer_log_level('ERROR', 'WARNING')
+    False
+    """
+    # Predefined log level mapping with numeric severity values
+    # Lower values indicate more verbose logging levels
     log_levels = {
         "DEBUG": 10,
         "INFO": 20,
@@ -36,7 +116,8 @@ def _check_minimum_buffer_log_level(buffer_log_level, current_log_level):
         "CRITICAL": 50,
     }
 
-    # Convert string levels to numeric if needed
+    # Normalize input log levels to uppercase for consistent comparison
+    # Retrieve corresponding numeric log level values
     buffer_level_num = log_levels.get(buffer_log_level.upper())
     current_level_num = log_levels.get(current_log_level.upper())
 

aws_lambda_powertools/logging/logger.py

@@ -1068,7 +1068,7 @@ def _create_and_flush_log_record(self, log_line: dict) -> None:
             lno=log_line["line"],
             msg=log_line["msg"],
             args=(),
-            exc_info=None,
+            exc_info=log_line["exc_info"],
             func=log_line["function"],
             extra=log_line["extra"],
         )
@@ -1121,7 +1121,14 @@ def _add_log_record_to_buffer(
                 # Ensures logs from previous invocations do not leak into current execution
                 self.buffer_cache.clear()
 
-            log_record: dict[str, Any] = _create_buffer_record(level=level, msg=msg, args=args, extra=extra)
+            log_record: dict[str, Any] = _create_buffer_record(
+                level=level,
+                msg=msg,
+                args=args,
+                exc_info=exc_info,
+                stack_info=stack_info,
+                extra=extra,
+            )
             self.buffer_cache.add(tracer_id, log_record)
 
     def flush_buffer(self) -> None:

tests/functional/logger/required_dependencies/test_powertools_logger_buffer.py

@@ -187,7 +187,33 @@ def test_ensure_log_location_after_flush_buffer(stdout, service_name, monkeypatc
 
     # THEN Validate that the log location is precisely captured
     log = capture_multiple_logging_statements_output(stdout)
-    assert "test_ensure_log_location_after_flush_buffer:184" in log[0]["location"]
+    assert "test_ensure_log_location_after_flush_buffer" in log[0]["location"]
+
+
+def test_exception_logging_during_buffer_flush(stdout, service_name, monkeypatch):
+    monkeypatch.setenv(constants.XRAY_TRACE_ID_ENV, "1-67c39786-5908a82a246fb67f3089263f")
+
+    # GIVEN A logger configured with a sufficiently large buffer
+    logger_buffer_config = LoggerBufferConfig(max_size=10240)
+    logger = Logger(level="DEBUG", service=service_name, stream=stdout, logger_buffer=logger_buffer_config)
+
+    # Custom exception class
+    class MyError(BaseException):
+        pass
+
+    # WHEN Logging an exception and flushing the buffer
+    try:
+        raise MyError("Test exception message")
+    except MyError as error:
+        logger.debug("Logging a test exception to verify buffer and exception handling", exc_info=error)
+
+    logger.flush_buffer()
+
+    # THEN Validate that the log exception fields
+    log = capture_multiple_logging_statements_output(stdout)
+    assert log[0]["exception_name"] == "MyError"
+    assert "Test exception message" in log[0]["exception"]
+    assert "test_exception_logging_during_buffer_flush" in log[0]["exception"]
 
 
 def test_create_buffer_with_items_evicted(stdout, service_name, monkeypatch):