Design a Logger with Independent Handlers

Problem Statement

Design an in-process logging library where a central Logger broadcasts log records to multiple independent LogHandler instances (e.g., console, rotating file, or remote telemetry).

Your design must satisfy the following core requirements:

1. Immutable Log Records: A LogRecord created by the logger must be immutable so that one handler cannot alter data seen by another handler.
2. Isolated Failures: If a handler encounters an unhandled exception or network failure during emit, it must not disrupt the calling application or prevent other handlers from receiving the log record.
3. Safe Runtime Reconfiguration: Handlers can be registered or deregistered at runtime without causing race conditions or deadlocks with active logging calls.
4. Bounded Backpressure: Asynchronous handlers should buffer records up to a configurable capacity. When the buffer is full, the handler must execute a defined overflow strategy (e.g., drop newest, drop oldest, or block with timeout).

Interface

from enum import Enum
from typing import Any, Dict, Optional

class LogLevel(Enum):
    DEBUG = 10
    INFO = 20
    WARN = 30
    ERROR = 40

class OverflowPolicy(Enum):
    DROP_NEWEST = "DROP_NEWEST"
    DROP_OLDEST = "DROP_OLDEST"
    BLOCK = "BLOCK"

class LogRecord:
    # Represents an immutable log event
    def __init__(self, level: LogLevel, message: str, timestamp: float, metadata: Optional[Dict[str, Any]] = None):
        ...

class LogHandler:
    def __init__(self, min_level: LogLevel = LogLevel.INFO):
        ...
        
    def emit(self, record: LogRecord) -> None:
        """Process the log record. Must handle errors internally."""
        raise NotImplementedError
        
    def close(self) -> None:
        """Flush buffers and release resources."""
        pass

class Logger:
    def __init__(self, min_level: LogLevel = LogLevel.INFO):
        ...
        
    def add_handler(self, name: str, handler: LogHandler) -> None:
        ...
        
    def remove_handler(self, name: str) -> Optional[LogHandler]:
        ...
        
    def log(self, level: LogLevel, message: str, **kwargs: Any) -> None:
        ...

Example Usage

logger = Logger(min_level=LogLevel.DEBUG)

# Console handler prints to stdout
console = ConsoleHandler(min_level=LogLevel.INFO)
# Faulty handler always throws an exception
faulty = FaultyNetworkHandler(min_level=LogLevel.DEBUG)

logger.add_handler("console", console)
logger.add_handler("faulty", faulty)

# Should not throw an exception despite faulty handler failing
logger.log(LogLevel.INFO, "User signed in", user_id=42)

# Dynamically remove faulty handler
logger.remove_handler("faulty")

Edge Cases & Considerations

• Concurrent Mutation: A thread removing a handler while another thread is iterating through handlers to dispatch logs.
• Metadata Mutation: Passing a mutable dictionary into kwargs should not allow external callers or downstream handlers to mutate the record's payload.
• Slow Handlers: Ensure slow handlers (e.g., remote HTTP POST) do not block fast handlers (e.g., console output).