Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash-preview-04-17· GoogleHugging Face LMArena Human Preference 140K

How would you write a subclass of logurus Logger class? So that i can still follow the…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Mistralmistral-medium-2505’s answer.
  1. User

    How would you write a subclass of logurus Logger class? So that i can still follow the "only use from loguru import logger" but from my custom package

  2. Gemini Assistant

    Okay, this is a common pattern request, but with Loguru's specific design around a single, global logger instance, directly subclassing loguru.Logger and creating a new instance that completely replaces the original while maintaining all its state (handlers, levels, etc.) is problematic and generally not the intended way to extend Loguru.

    Here's why:

    1. Global State: The loguru.logger instance manages all handlers globally. If you create a new instance of a subclass, it starts with no handlers unless you explicitly copy or add them.
    2. Configuration: Calls like loguru.logger.add(...) or loguru.logger.configure(...) modify the original global instance. A separate instance of your subclass won't be affected by these calls unless you intercept them and apply them manually, which is complex.
    3. Loguru's logger is an Instance: When you from loguru import logger, you are importing a specific instance of the Logger class, not the class itself.

    The Recommended Approach: Delegation (Wrapping)

    Instead of true subclassing to create a new instance, the most robust and Loguru-idiomatic way to add custom behavior while preserving the global state is to create a wrapper class that delegates most calls to the original loguru.logger instance and adds or overrides specific methods.

    This allows you to use from my_package import logger where my_package.logger is your custom object, but it still interacts with the single, globally configured Loguru instance under the hood.

    Here's how you would implement this:

    1. Create your package structure:

    my_package/
    ├── __init__.py
    └── _logger.py  # Conventionally use a leading underscore for internal modules
    

    2. Define your custom logger wrapper in my_package/_logger.py:

    # my_package/_logger.py
    
    import loguru
    import functools
    import sys
    
    # Get the original loguru logger instance
    # It's important to import this *before* anyone else might configure it,
    # though the wrapper approach works even if it's already configured.
    _original_logger = loguru.logger
    
    class MyLogger:
        """
        A wrapper around loguru.logger to add custom methods or behavior.
    
        Delegates all standard logging methods and configuration to the
        original loguru.logger instance.
        """
        def __init__(self):
            self._logger = _original_logger
            # Optional: Add default handlers specific to your package if needed,
            # although typically you'd let the main application configure loguru.
            # self._logger.add(sys.stderr, ...) # Example
    
        def __getattr__(self, name):
            """
            Delegate any attribute access (like .info, .debug, .add, .remove)
            to the underlying loguru logger instance.
            """
            return getattr(self._logger, name)
    
        # --- Add your custom methods here ---
    
        def log_and_notify(self, level: str, message: str, *args, **kwargs):
            """
            Logs a message and potentially triggers a notification (e.g., email, Slack).
            """
            # Ensure the level is valid (optional check)
            if level.upper() not in self._logger._levels: # Accessing protected member for example
                 self._logger.warning(f"Invalid level '{level}' provided to log_and_notify. Using 'info'.")
                 level = "info"
    
            # Log the message using the delegated method
            getattr(self._logger, level.lower())(message, *args, **kwargs)
    
            # Add your notification logic here
            # Example:
            # if level.upper() in ['CRITICAL', 'ERROR']:
            #    print(f"--- Sending notification for {level.upper()}: {message} ---")
            #    # send_email(...) or send_slack_message(...)
    
    
        def debug_with_tag(self, tag: str, message: str, *args, **kwargs):
            """
            Logs a debug message with a specific tag added to extra context.
            """
            extra = kwargs.pop("extra", {})
            extra["tag"] = tag
            self._logger.debug(message, *args, extra=extra, **kwargs)
    
        # --- You can also override existing methods if needed ---
        # Be careful when overriding to match the signature or use *args, **kwargs
        # def info(self, message: str, *args, **kwargs):
        #    """
        #    Overrides the standard info method to add default extra context.
        #    """
        #    extra = kwargs.pop("extra", {})
        #    extra["source"] = "my_package"
        #    self._logger.info(message, *args, extra=extra, **kwargs)
    
    
    # Create a single instance of your custom logger wrapper
    # This instance will be imported by __init__.py
    my_package_logger_instance = MyLogger()
    
    

    3. Expose your custom logger instance in my_package/__init__.py:

    # my_package/__init__.py
    
    # Import the custom logger instance from your internal module
    from ._logger import my_package_logger_instance
    
    # Assign it to the name 'logger' that users will import
    logger = my_package_logger_instance
    
    # Optionally define what gets imported with '*'
    __all__ = ["logger"]
    
    # Optional: Configure loguru here if your package is responsible for setup
    # This affects the underlying _original_logger which your wrapper uses.
    # logger.add("my_package.log", rotation="1 MB")
    

    4. How to use it:

    Now, any code outside my_package can import and use your custom logger like this:

    # main_application.py
    
    from my_package import logger
    import loguru # You can still import loguru directly if needed
    
    # Use standard loguru methods (delegated by your wrapper)
    logger.info("This is an informational message from my_package.")
    logger.debug("Debugging some value: %s", [1, 2, 3])
    logger.warning("Something might be wrong.")
    
    # Use your custom methods
    logger.log_and_notify("error", "An important process failed.")
    logger.debug_with_tag("config", "Loaded configuration settings.")
    
    # Configuration still works on the underlying loguru instance
    # You can do this either via your wrapper instance or the original
    # loguru.logger instance - they point to the same object for config/handlers.
    # logger.add("app.log", format="{time} {level} {message}", level="INFO")
    # loguru.logger.add("another.log")
    
    # Logging via the original loguru.logger also works and uses the same handlers
    # loguru.logger.info("This message goes through the same loguru core.")
    

    Explanation:

    • my_package/_logger.py: This file holds the definition of MyLogger (your wrapper class) and creates a single instance of it, my_package_logger_instance.
    • MyLogger: This class contains the original loguru.logger instance (self._logger = _original_logger).
    • __getattr__: This is the key Python "dunder" method that makes delegation easy. When you call logger.info(...), if info is not explicitly defined in MyLogger, Python calls logger.__getattr__('info'), which returns getattr(self._logger, 'info'). This effectively returns the original loguru.logger.info method, and Python then calls it with the provided arguments. This works for any attribute or method on the original logger instance (like debug, add, remove, opt, bind, etc.) unless you override it.
    • Custom Methods (log_and_notify, debug_with_tag): You define these directly on your MyLogger class. Inside these methods, you use self._logger to interact with the underlying Loguru instance, potentially adding custom logic before or after logging.
    • my_package/__init__.py: This file is executed when my_package is imported. It imports your my_package_logger_instance and assigns it to the name logger, making it available when users do from my_package import logger.

    This wrapper approach allows you to extend the functionality of Loguru's logger instance from within your package while fully leveraging Loguru's core features, configuration, and handler management which operate on that single global instance.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.