update logging module

Author: vdusek

src/apify_client/_logging.py

@@ -2,7 +2,6 @@
 
 import functools
 import inspect
-import json
 import logging
 from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any, NamedTuple
@@ -15,15 +14,16 @@
     from apify_client.clients.base.base_client import _BaseBaseClient
 
 
-# Name of the logger used throughout the library
 logger_name = __name__.split('.')[0]
+"""Name of the logger used throughout the library."""
 
-# Logger used throughout the library
 logger = logging.getLogger(logger_name)
+"""Logger used throughout the library."""
 
 
-# Context containing the details of the request and the resource client making the request
 class LogContext(NamedTuple):
+    """Request context details for logging (attempt, client method, HTTP method, resource ID, URL)."""
+
     attempt: ContextVar[int | None]
     client_method: ContextVar[str | None]
     method: ContextVar[str | None]
@@ -40,58 +40,64 @@ class LogContext(NamedTuple):
 )
 
 
-# Metaclass for resource clients which wraps all their public methods
-# With injection of their details to the log context vars
 class WithLogDetailsClient(type):
+    """Metaclass that wraps public methods to inject client details into log context."""
+
     def __new__(cls, name: str, bases: tuple, attrs: dict) -> WithLogDetailsClient:
+        """Wrap all public methods in the class with logging context injection."""
         for attr_name, attr_value in attrs.items():
             if not attr_name.startswith('_') and inspect.isfunction(attr_value):
                 attrs[attr_name] = _injects_client_details_to_log_context(attr_value)
 
         return type.__new__(cls, name, bases, attrs)
 
 
-# Wraps an unbound method so that its call will inject the details
-# of the resource client (which is the `self` argument of the method)
-# to the log context vars
-def _injects_client_details_to_log_context(fun: Callable) -> Callable:
-    if inspect.iscoroutinefunction(fun):
+class RedirectLogFormatter(logging.Formatter):
+    """Log formatter that prepends colored logger name to messages."""
 
-        @functools.wraps(fun)
-        async def async_wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
-            log_context.client_method.set(fun.__qualname__)
-            log_context.resource_id.set(resource_client.resource_id)
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log by prepending colored logger name.
 
-            return await fun(resource_client, *args, **kwargs)
+        Args:
+            record: The log record to format.
 
-        return async_wrapper
-    elif inspect.isasyncgenfunction(fun):  # noqa: RET505
+        Returns:
+            Formatted log message with colored logger name prefix.
+        """
+        formatted_logger_name = f'{Fore.CYAN}[{record.name}]{Style.RESET_ALL}'
+        return f'{formatted_logger_name} -> {record.msg}'
 
-        @functools.wraps(fun)
-        async def async_generator_wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
-            log_context.client_method.set(fun.__qualname__)
-            log_context.resource_id.set(resource_client.resource_id)
 
-            async for item in fun(resource_client, *args, **kwargs):
-                yield item
+def create_redirect_logger(name: str) -> logging.Logger:
+    """Create a logger for redirecting logs from another Actor.
 
-        return async_generator_wrapper
-    else:
+    Args:
+        name: Logger name. Use dot notation for hierarchy (e.g., "apify.xyz" creates "xyz" under "apify").
 
-        @functools.wraps(fun)
-        def wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
-            log_context.client_method.set(fun.__qualname__)
-            log_context.resource_id.set(resource_client.resource_id)
+    Returns:
+        Configured logger with RedirectLogFormatter.
+    """
+    to_logger = logging.getLogger(name)
+    to_logger.propagate = False
 
-            return fun(resource_client, *args, **kwargs)
+    # Remove filters and handlers in case this logger already exists and was set up in some way.
+    for handler in to_logger.handlers:
+        to_logger.removeHandler(handler)
+    for log_filter in to_logger.filters:
+        to_logger.removeFilter(log_filter)
 
-        return wrapper
+    handler = logging.StreamHandler()
+    handler.setFormatter(RedirectLogFormatter())
+    to_logger.addHandler(handler)
+    to_logger.setLevel(logging.DEBUG)
+    return to_logger
 
 
-# A filter which lets every log record through,
-# but adds the current logging context to the record
 class _ContextInjectingFilter(logging.Filter):
+    """Filter that injects current log context into all log records."""
+
     def filter(self, record: logging.LogRecord) -> bool:
+        """Add log context variables to the record."""
         record.client_method = log_context.client_method.get()
         record.resource_id = log_context.resource_id.get()
         record.method = log_context.method.get()
@@ -100,71 +106,39 @@ def filter(self, record: logging.LogRecord) -> bool:
         return True
 
 
-logger.addFilter(_ContextInjectingFilter())
-
-
-# Log formatter useful for debugging of the client
-# Will print out all the extra fields added to the log record
-class _DebugLogFormatter(logging.Formatter):
-    empty_record = logging.LogRecord('dummy', 0, 'dummy', 0, 'dummy', None, None)
-
-    # Gets the extra fields from the log record which are not present on an empty record
-    def _get_extra_fields(self, record: logging.LogRecord) -> dict:
-        extra_fields: dict = {}
-        for key, value in record.__dict__.items():
-            if key not in self.empty_record.__dict__:
-                extra_fields[key] = value  # noqa: PERF403
-
-        return extra_fields
-
-    def format(self, record: logging.LogRecord) -> str:
-        extra = self._get_extra_fields(record)
+def _injects_client_details_to_log_context(fun: Callable) -> Callable:
+    """Wrap a method to inject resource client details into log context before execution."""
+    if inspect.iscoroutinefunction(fun):
 
-        log_string = super().format(record)
-        if extra:
-            log_string = f'{log_string} ({json.dumps(extra)})'
-        return log_string
+        @functools.wraps(fun)
+        async def async_wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
+            log_context.client_method.set(fun.__qualname__)
+            log_context.resource_id.set(resource_client.resource_id)
 
+            return await fun(resource_client, *args, **kwargs)
 
-def create_redirect_logger(
-    name: str,
-) -> logging.Logger:
-    """Create a logger for redirecting logs from another Actor.
+        return async_wrapper
 
-    Args:
-        name: The name of the logger. It can be used to inherit from other loggers. Example: `apify.xyz` will use logger
-         named `xyz` and make it a children of `apify` logger.
+    if inspect.isasyncgenfunction(fun):
 
-    Returns:
-        The created logger.
-    """
-    to_logger = logging.getLogger(name)
-    to_logger.propagate = False
+        @functools.wraps(fun)
+        async def async_generator_wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
+            log_context.client_method.set(fun.__qualname__)
+            log_context.resource_id.set(resource_client.resource_id)
 
-    # Remove filters and handlers in case this logger already exists and was set up in some way.
-    for handler in to_logger.handlers:
-        to_logger.removeHandler(handler)
-    for log_filter in to_logger.filters:
-        to_logger.removeFilter(log_filter)
+            async for item in fun(resource_client, *args, **kwargs):
+                yield item
 
-    handler = logging.StreamHandler()
-    handler.setFormatter(RedirectLogFormatter())
-    to_logger.addHandler(handler)
-    to_logger.setLevel(logging.DEBUG)
-    return to_logger
+        return async_generator_wrapper
 
+    @functools.wraps(fun)
+    def wrapper(resource_client: _BaseBaseClient, *args: Any, **kwargs: Any) -> Any:
+        log_context.client_method.set(fun.__qualname__)
+        log_context.resource_id.set(resource_client.resource_id)
 
-class RedirectLogFormatter(logging.Formatter):
-    """Formatter applied to default redirect logger."""
+        return fun(resource_client, *args, **kwargs)
 
-    def format(self, record: logging.LogRecord) -> str:
-        """Format the log by prepending logger name to the original message.
+    return wrapper
 
-        Args:
-            record: Log record to be formatted.
 
-        Returns:
-            Formatted log message.
-        """
-        formatted_logger_name = f'{Fore.CYAN}[{record.name}]{Style.RESET_ALL}'
-        return f'{formatted_logger_name} -> {record.msg}'
+logger.addFilter(_ContextInjectingFilter())