API changes: pickup logger from target module if possible

add constants (not cythonized: useless)

Author: penguinolog

README.rst

@@ -79,7 +79,7 @@ Argumented usage with arguments from signature:
 .. code-block:: python
 
     @logwrap.logwrap(
-        log=logging.getLogger(__name__),  # __name__ = 'logwrap'
+        log=None,  # if not set: try to find LOGGER, LOG, logger or log object in target module and use it if it logger instance. Fallback: logger named logwrap
         log_level=logging.DEBUG,
         exc_level=logging.ERROR,
         max_indent=20,  # forwarded to the pretty_repr

doc/source/logwrap.rst

@@ -12,12 +12,12 @@ API: Decorators: `LogWrap` class and `logwrap` function.
 
     .. versionadded:: 2.2.0
 
-    .. py:method:: __init__(func=None, *, log=logging.getLogger('logwrap'), log_level=logging.DEBUG, exc_level=logging.ERROR, max_indent=20, spec=None, blacklisted_names=None, blacklisted_exceptions=None, log_call_args=True, log_call_args_on_exc=True, log_traceback=True, log_result_obj=True, )
+    .. py:method:: __init__(func=None, *, log=None, log_level=logging.DEBUG, exc_level=logging.ERROR, max_indent=20, spec=None, blacklisted_names=None, blacklisted_exceptions=None, log_call_args=True, log_call_args_on_exc=True, log_traceback=True, log_result_obj=True, )
 
         :param func: function to wrap
         :type func: typing.Optional[typing.Callable]
-        :param log: logger object for decorator, by default used 'logwrap'
-        :type log: logging.Logger
+        :param log: logger object for decorator, by default trying to use logger from target module. Fallback: 'logwrap'
+        :type log: typing.Optional[logging.Logger]
         :param log_level: log level for successful calls
         :type log_level: int
         :param exc_level: log level for exception cases
@@ -52,6 +52,7 @@ API: Decorators: `LogWrap` class and `logwrap` function.
         .. versionchanged:: 3.3.0 Deprecation of `*args`
         .. versionchanged:: 4.0.0 Drop of `*args`
         .. versionchanged:: 5.1.0 log_traceback parameter
+        .. versionchanged:: 8.0.0 pick up logger from target module if possible
 
     .. py:method:: pre_process_param(self, arg)
 
@@ -111,6 +112,50 @@ API: Decorators: `LogWrap` class and `logwrap` function.
         :rtype: typing.Union[typing.Callable, typing.Awaitable]
 
 
+.. py:function:: logwrap(func=None, *, log=None, log_level=logging.DEBUG, exc_level=logging.ERROR, max_indent=20, spec=None, blacklisted_names=None, blacklisted_exceptions=None, log_call_args=True, log_call_args_on_exc=True, log_traceback=True, log_result_obj=True, )
+
+    Log function calls and return values.
+
+    :param func: function to wrap
+    :type func: typing.Optional[typing.Callable]
+    :param log: logger object for decorator, by default trying to use logger from target module. Fallback: 'logwrap'
+    :type log: typing.Optional[logging.Logger]
+    :param log_level: log level for successful calls
+    :type log_level: int
+    :param exc_level: log level for exception cases
+    :type exc_level: int
+    :param max_indent: maximum indent before classic `repr()` call.
+    :type max_indent: int
+    :param spec: callable object used as spec for arguments bind.
+                 This is designed for the special cases only,
+                 when impossible to change signature of target object,
+                 but processed/redirected signature is accessible.
+                 Note: this object should provide fully compatible signature
+                 with decorated function, or arguments bind will be failed!
+    :type spec: typing.Optional[typing.Callable]
+    :param blacklisted_names: Blacklisted argument names. Arguments with this names will be skipped in log.
+    :type blacklisted_names: typing.Optional[typing.Iterable[str]]
+    :param blacklisted_exceptions: list of exceptions, which should be re-raised
+                                   without producing traceback and text log record.
+    :type blacklisted_exceptions: typing.Optional[typing.Iterable[typing.Type[Exception]]]
+    :param log_call_args: log call arguments before executing wrapped function.
+    :type log_call_args: bool
+    :param log_call_args_on_exc: log call arguments if exception raised.
+    :type log_call_args_on_exc: bool
+    :param log_traceback: log traceback on excaption in addition to failure info
+    :type log_traceback: bool
+    :param log_result_obj: log result of function call.
+    :type log_result_obj: bool
+    :return: built real decorator.
+    :rtype: typing.Union[LogWrap, typing.Callable[..., typing.Union[typing.Awaitable[typing.Any], typing.Any]]]
+
+    .. versionchanged:: 3.3.0 Extract func from log and do not use Union.
+    .. versionchanged:: 3.3.0 Deprecation of *args
+    .. versionchanged:: 4.0.0 Drop of *args
+    .. versionchanged:: 5.1.0 log_traceback parameter
+    .. versionchanged:: 8.0.0 pick up logger from target module if possible
+
+
 .. py:class:: BoundParameter(inspect.Parameter)
 
     Parameter-like object store BOUND with value parameter.

logwrap/constants.py

@@ -0,0 +1,16 @@
+#    Copyright 2016 - 2019 Alexey Stepanov aka penguinolog
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Global constants."""
+
+VALID_LOGGER_NAMES = ("LOGGER", "LOG", "logger", "log")

logwrap/log_on_access.py

@@ -27,9 +27,9 @@
 import typing
 
 # LogWrap Implementation
+from logwrap import constants
 from logwrap import repr_utils
 
-
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 _CURRENT_FILE = os.path.abspath(__file__)
 
@@ -222,14 +222,13 @@ def _get_logger_for_instance(self, instance: typing.Any) -> logging.Logger:
         """
         if self.logger is not None:
             return self.logger
-        valid_logger_names = ("logger", "log")
-        for logger_name in valid_logger_names:
+        for logger_name in constants.VALID_LOGGER_NAMES:
             logger_candidate = getattr(instance, logger_name, None)
             if isinstance(logger_candidate, logging.Logger):
                 return logger_candidate
         instance_module = inspect.getmodule(instance)
-        for logger_name in valid_logger_names:
-            logger_candidate = getattr(instance_module, logger_name.upper(), None)
+        for logger_name in constants.VALID_LOGGER_NAMES:
+            logger_candidate = getattr(instance_module, logger_name, None)
             if isinstance(logger_candidate, logging.Logger):
                 return logger_candidate
         return _LOGGER

logwrap/log_wrap.pxd

@@ -15,6 +15,7 @@
 """log_wrap shared code module."""
 
 import inspect
+import logging
 import typing
 
 from logwrap cimport class_decorator
@@ -48,6 +49,6 @@ cdef:
 
         cdef:
             str _get_func_args_repr(self, sig: inspect.Signature, tuple args, dict kwargs)
-            void _make_done_record(self, str func_name, result: typing.Any) except *
-            void _make_calling_record(self, str name, str arguments, str method=?) except *
-            void _make_exc_record(self, str name, str arguments, Exception exception) except *
+            void _make_done_record(self, logger: logging.Logger, str func_name, result: typing.Any) except *
+            void _make_calling_record(self, logger: logging.Logger, str name, str arguments, str method=?) except *
+            void _make_exc_record(self, logger: logging.Logger, str name, str arguments, Exception exception) except *

logwrap/log_wrap.py

@@ -30,6 +30,7 @@
 
 # LogWrap Implementation
 from logwrap import class_decorator
+from logwrap import constants
 from logwrap import repr_utils
 
 LOGGER: logging.Logger = logging.getLogger("logwrap")
@@ -154,7 +155,7 @@ def __init__(
         self,
         func: typing.Optional[typing.Callable[..., FuncResultType]] = None,
         *,
-        log: logging.Logger = LOGGER,
+        log: typing.Optional[logging.Logger] = None,
         log_level: int = logging.DEBUG,
         exc_level: int = logging.ERROR,
         max_indent: int = 20,
@@ -170,8 +171,8 @@ def __init__(
 
         :param func: function to wrap
         :type func: typing.Optional[typing.Callable]
-        :param log: logger object for decorator, by default used 'logwrap'
-        :type log: logging.Logger
+        :param log: logger object for decorator, by default trying to use logger from target module. Fallback: 'logwrap'
+        :type log: typing.Optional[logging.Logger]
         :param log_level: log level for successful calls
         :type log_level: int
         :param exc_level: log level for exception cases
@@ -202,6 +203,7 @@ def __init__(
 
         .. versionchanged:: 3.3.0 Extract func from log and do not use Union.
         .. versionchanged:: 5.1.0 log_traceback parameter
+        .. versionchanged:: 8.0.0 pick up logger from target module if possible
         """
         super().__init__(func=func)
 
@@ -215,7 +217,13 @@ def __init__(
         else:
             self.__blacklisted_exceptions = list(blacklisted_exceptions)
 
-        self.__logger: logging.Logger = log
+        if isinstance(log, logging.Logger):
+            self.__logger: typing.Optional[logging.Logger] = log
+        else:
+            self.__logger = None
+
+        if func is not None:  # Special case: we can prefetch logger
+            self.__logger = self._get_logger_for_func(func)
 
         self.__log_level: int = log_level
         self.__exc_level: int = exc_level
@@ -228,6 +236,18 @@ def __init__(
 
         # We are not interested to pass any arguments to object
 
+    def _get_logger_for_func(self, func: FuncResultType) -> logging.Logger:
+        """Get logger for function from function module if possible."""
+        if self.__logger is not None:
+            return self.__logger
+
+        func_module = inspect.getmodule(func)
+        for logger_name in constants.VALID_LOGGER_NAMES:
+            logger_candidate = getattr(func_module, logger_name, None)
+            if isinstance(logger_candidate, logging.Logger):
+                return logger_candidate
+        return LOGGER
+
     @property
     def log_level(self) -> int:
         """Log level for normal behavior.
@@ -385,10 +405,10 @@ def log_result_obj(self, val: bool) -> None:
         self.__log_result_obj = val
 
     @property
-    def _logger(self) -> logging.Logger:
+    def _logger(self) -> typing.Optional[logging.Logger]:
         """Logger instance.
 
-        :rtype: logging.Logger
+        :rtype: typing.Optional[logging.Logger]
         """
         return self.__logger
 
@@ -515,30 +535,33 @@ def _get_func_args_repr(
             param_str += "\n"
         return param_str
 
-    def _make_done_record(self, func_name: str, result: typing.Any) -> None:
+    def _make_done_record(self, logger: logging.Logger, func_name: str, result: typing.Any) -> None:
         """Construct success record.
 
+        :type logger: logging.Logger
         :type func_name: str
         :type result: typing.Any
         """
         msg: str = f"Done: {func_name!r}"
 
         if self.log_result_obj:
             msg += f" with result:\n{repr_utils.pretty_repr(result, max_indent=self.max_indent)}"
-        self._logger.log(level=self.log_level, msg=msg)
+        logger.log(level=self.log_level, msg=msg)
 
-    def _make_calling_record(self, name: str, arguments: str, method: str = "Calling") -> None:
+    def _make_calling_record(self, logger: logging.Logger, name: str, arguments: str, method: str = "Calling") -> None:
         """Make log record before execution.
 
+        :type logger: logging.Logger
         :type name: str
         :type arguments: str
         :type method: str
         """
-        self._logger.log(level=self.log_level, msg=f"{method}: \n{name}({arguments if self.log_call_args else ''})")
+        logger.log(level=self.log_level, msg=f"{method}: \n{name}({arguments if self.log_call_args else ''})")
 
-    def _make_exc_record(self, name: str, arguments: str, exception: Exception) -> None:
+    def _make_exc_record(self, logger: logging.Logger, name: str, arguments: str, exception: Exception) -> None:
         """Make log record if exception raised.
 
+        :type logger: logging.Logger
         :type name: str
         :type arguments: str
         :type exception: Exception
@@ -554,7 +577,7 @@ def _make_exc_record(self, name: str, arguments: str, exception: Exception) -> N
             else exception.__class__.__name__
         )
 
-        self._logger.log(
+        logger.log(
             level=self.exc_level,
             msg=f"Failed: \n{name}({arguments if self.log_call_args_on_exc else ''})\n{tb_text}",
             exc_info=False,
@@ -569,18 +592,20 @@ def _get_function_wrapper(self, func: typing.Callable[..., FuncResultType]) -> t
         :rtype: typing.Callable
         """
 
+        logger: logging.Logger = self._get_logger_for_func(func)
+
         # noinspection PyCompatibility,PyMissingOrEmptyDocstring
         @functools.wraps(func)
         async def async_wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
             sig: inspect.Signature = inspect.signature(self._spec or func)
             args_repr: str = self._get_func_args_repr(sig=sig, args=args, kwargs=kwargs)
 
             try:
-                self._make_calling_record(name=func.__name__, arguments=args_repr, method="Awaiting")
+                self._make_calling_record(logger=logger, name=func.__name__, arguments=args_repr, method="Awaiting")
                 result = await func(*args, **kwargs)
-                self._make_done_record(func.__name__, result)
+                self._make_done_record(logger=logger, func_name=func.__name__, result=result)
             except Exception as e:
-                self._make_exc_record(name=func.__name__, arguments=args_repr, exception=e)
+                self._make_exc_record(logger=logger, name=func.__name__, arguments=args_repr, exception=e)
                 raise
             return result  # type: ignore
 
@@ -591,11 +616,11 @@ def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
             args_repr: str = self._get_func_args_repr(sig=sig, args=args, kwargs=kwargs)
 
             try:
-                self._make_calling_record(name=func.__name__, arguments=args_repr)
+                self._make_calling_record(logger=logger, name=func.__name__, arguments=args_repr)
                 result = func(*args, **kwargs)
-                self._make_done_record(func.__name__, result)
+                self._make_done_record(logger=logger, func_name=func.__name__, result=result)
             except Exception as e:
-                self._make_exc_record(name=func.__name__, arguments=args_repr, exception=e)
+                self._make_exc_record(logger=logger, name=func.__name__, arguments=args_repr, exception=e)
                 raise
             return result
 
@@ -622,7 +647,7 @@ def __call__(  # pylint: disable=useless-super-delegation
 def logwrap(
     func: None = None,
     *,
-    log: logging.Logger = LOGGER,
+    log: typing.Optional[logging.Logger] = None,
     log_level: int = logging.DEBUG,
     exc_level: int = logging.ERROR,
     max_indent: int = 20,
@@ -641,7 +666,7 @@ def logwrap(
 def logwrap(
     func: typing.Callable[..., typing.Awaitable[FuncFinalResult]],
     *,
-    log: logging.Logger = LOGGER,
+    log: typing.Optional[logging.Logger] = None,
     log_level: int = logging.DEBUG,
     exc_level: int = logging.ERROR,
     max_indent: int = 20,
@@ -660,7 +685,7 @@ def logwrap(
 def logwrap(
     func: typing.Callable[..., FuncFinalResult],
     *,
-    log: logging.Logger = LOGGER,
+    log: typing.Optional[logging.Logger] = None,
     log_level: int = logging.DEBUG,
     exc_level: int = logging.ERROR,
     max_indent: int = 20,
@@ -678,7 +703,7 @@ def logwrap(
 def logwrap(  # noqa: F811
     func: typing.Optional[typing.Callable[..., FuncResultType]] = None,
     *,
-    log: logging.Logger = LOGGER,
+    log: typing.Optional[logging.Logger] = None,
     log_level: int = logging.DEBUG,
     exc_level: int = logging.ERROR,
     max_indent: int = 20,
@@ -694,8 +719,8 @@ def logwrap(  # noqa: F811
 
     :param func: function to wrap
     :type func: typing.Optional[typing.Callable]
-    :param log: logger object for decorator, by default used 'logwrap'
-    :type log: logging.Logger
+    :param log: logger object for decorator, by default trying to use logger from target module. Fallback: 'logwrap'
+    :type log: typing.Optional[logging.Logger]
     :param log_level: log level for successful calls
     :type log_level: int
     :param exc_level: log level for exception cases
@@ -723,12 +748,13 @@ def logwrap(  # noqa: F811
     :param log_result_obj: log result of function call.
     :type log_result_obj: bool
     :return: built real decorator.
-    :rtype: _log_wrap_shared.BaseLogWrap
+    :rtype: typing.Union[LogWrap, typing.Callable[..., FuncResultType]]
 
     .. versionchanged:: 3.3.0 Extract func from log and do not use Union.
     .. versionchanged:: 3.3.0 Deprecation of *args
     .. versionchanged:: 4.0.0 Drop of *args
     .. versionchanged:: 5.1.0 log_traceback parameter
+    .. versionchanged:: 8.0.0 pick up logger from target module if possible
     """
     wrapper = LogWrap(
         log=log,