refactor: move 3.8+ compat code to compat.py

Author: heitorlessa

aws_lambda_powertools/logging/compat.py

@@ -0,0 +1,51 @@
+"""Maintenance: We can drop this upon Py3.7 EOL. It's a backport for "location" key to work."""
+from __future__ import annotations
+
+import io
+import logging
+import os
+import traceback
+
+
+def findCaller(stack_info=False, stacklevel=2):  # pragma: no cover
+    """
+    Find the stack frame of the caller so that we can note the source
+    file name, line number and function name.
+    """
+    f = logging.currentframe()  # noqa: VNE001
+    # On some versions of IronPython, currentframe() returns None if
+    # IronPython isn't run with -X:Frames.
+    if f is None:
+        return "(unknown file)", 0, "(unknown function)", None
+    while stacklevel > 0:
+        next_f = f.f_back
+        if next_f is None:
+            ## We've got options here.
+            ## If we want to use the last (deepest) frame:
+            break
+            ## If we want to mimic the warnings module:
+            # return ("sys", 1, "(unknown function)", None) # noqa: E800
+            ## If we want to be pedantic:  # noqa: E800
+            # raise ValueError("call stack is not deep enough") # noqa: E800
+        f = next_f  # noqa: VNE001
+        if not _is_internal_frame(f):
+            stacklevel -= 1
+    co = f.f_code
+    sinfo = None
+    if stack_info:
+        with io.StringIO() as sio:
+            sio.write("Stack (most recent call last):\n")
+            traceback.print_stack(f, file=sio)
+            sinfo = sio.getvalue()
+            if sinfo[-1] == "\n":
+                sinfo = sinfo[:-1]
+    return co.co_filename, f.f_lineno, co.co_name, sinfo
+
+
+# The following is based on warnings._is_internal_frame. It makes sure that
+# frames of the import mechanism are skipped when logging at module level and
+# using a stacklevel value greater than one.
+def _is_internal_frame(frame):  # pragma: no cover
+    """Signal whether the frame is a CPython or logging module internal."""
+    filename = os.path.normcase(frame.f_code.co_filename)
+    return filename == logging._srcfile or ("importlib" in filename and "_bootstrap" in filename)

aws_lambda_powertools/logging/logger.py

@@ -2,12 +2,10 @@
 
 import functools
 import inspect
-import io
 import logging
 import os
 import random
 import sys
-import traceback
 from typing import (
     IO,
     TYPE_CHECKING,
@@ -25,6 +23,8 @@
 
 import jmespath
 
+from aws_lambda_powertools.logging import compat
+
 from ..shared import constants
 from ..shared.functions import (
     extract_event_from_common_models,
@@ -270,7 +270,7 @@ def _get_logger(self):
         """Returns a Logger named {self.service}, or {self.service.filename} for child loggers"""
         logger_name = self.service
         if self.child:
-            logger_name = f"{self.service}.{self._get_caller_filename()}"
+            logger_name = f"{self.service}.{_get_caller_filename()}"
 
         return logging.getLogger(logger_name)
 
@@ -292,7 +292,7 @@ def _init_logger(self, formatter_options: Optional[Dict] = None, **kwargs):
         self.structure_logs(formatter_options=formatter_options, **kwargs)
 
         # Maintenance: We can drop this upon Py3.7 EOL. It's a backport for "location" key to work
-        self._logger.findCaller = self.findCaller
+        self._logger.findCaller = compat.findCaller
 
         # Pytest Live Log feature duplicates log records for colored output
         # but we explicitly add a filter for log deduplication.
@@ -655,51 +655,6 @@ def _get_log_level(level: Union[str, int, None]) -> Union[str, int]:
 
         return log_level.upper()
 
-    @staticmethod
-    def _get_caller_filename():
-        """Return caller filename by finding the caller frame"""
-        # Current frame         => _get_logger()
-        # Previous frame        => logger.py
-        # Before previous frame => Caller
-        frame = inspect.currentframe()
-        caller_frame = frame.f_back.f_back.f_back
-        return caller_frame.f_globals["__name__"]
-
-    # Maintenance: We can drop this upon Py3.7 EOL. It's a backport for "location" key to work
-    def findCaller(self, stack_info=False, stacklevel=2):  # pragma: no cover
-        """
-        Find the stack frame of the caller so that we can note the source
-        file name, line number and function name.
-        """
-        f = logging.currentframe()  # noqa: VNE001
-        # On some versions of IronPython, currentframe() returns None if
-        # IronPython isn't run with -X:Frames.
-        if f is None:
-            return "(unknown file)", 0, "(unknown function)", None
-        while stacklevel > 0:
-            next_f = f.f_back
-            if next_f is None:
-                ## We've got options here.
-                ## If we want to use the last (deepest) frame:
-                break
-                ## If we want to mimic the warnings module:
-                # return ("sys", 1, "(unknown function)", None) # noqa: E800
-                ## If we want to be pedantic:  # noqa: E800
-                # raise ValueError("call stack is not deep enough") # noqa: E800
-            f = next_f  # noqa: VNE001
-            if not _is_internal_frame(f):
-                stacklevel -= 1
-        co = f.f_code
-        sinfo = None
-        if stack_info:
-            with io.StringIO() as sio:
-                sio.write("Stack (most recent call last):\n")
-                traceback.print_stack(f, file=sio)
-                sinfo = sio.getvalue()
-                if sinfo[-1] == "\n":
-                    sinfo = sinfo[:-1]
-        return co.co_filename, f.f_lineno, co.co_name, sinfo
-
 
 def set_package_logger(
     level: Union[str, int] = logging.DEBUG,
@@ -740,16 +695,16 @@ def set_package_logger(
     logger.addHandler(handler)
 
 
-# Maintenance: We can drop this upon Py3.7 EOL. It's a backport for "location" key to work
-# The following is based on warnings._is_internal_frame. It makes sure that
-# frames of the import mechanism are skipped when logging at module level and
-# using a stacklevel value greater than one.
-def _is_internal_frame(frame):  # pragma: no cover
-    """Signal whether the frame is a CPython or logging module internal."""
-    filename = os.path.normcase(frame.f_code.co_filename)
-    return filename == logging._srcfile or ("importlib" in filename and "_bootstrap" in filename)
-
-
 def log_uncaught_exception_hook(exc_type, exc_value, exc_traceback, logger: Logger):
     """Callback function for sys.excepthook to use Logger to log uncaught exceptions"""
     logger.exception(exc_value, exc_info=(exc_type, exc_value, exc_traceback))  # pragma: no cover
+
+
+def _get_caller_filename():
+    """Return caller filename by finding the caller frame"""
+    # Current frame         => _get_logger()
+    # Previous frame        => logger.py
+    # Before previous frame => Caller
+    frame = inspect.currentframe()
+    caller_frame = frame.f_back.f_back.f_back
+    return caller_frame.f_globals["__name__"]