Interop with Loguru

[autoferrit]

I have my logging setup to use rich's nice error handling with loguru. Though i have a few minor issues. When I am using a try/except block I can easily enough import the console I setup in my logging.py to spit out a nicely formatted error message. But when another exception is raised somewhere in the code, it is not using rich's output. here is my logging.py

# Futures
from __future__ import annotations

# Standard Library
import logging

from pprint import pformat

# Third Party
import loguru

from loguru import logger as loguru_logger
from loguru._defaults import LOGURU_FORMAT  # noqa
from rich.console import Console
from rich.logging import RichHandler


BO_FORMAT = (
    "\n<blue>{name}</blue>:<cyan>{function}</cyan>:<yellow>{line}</yellow>\n"
    "<level>{message}</level>"
)


class InterceptHandler(logging.Handler):
    """Logging intercept handler."""

    def emit(self, record: logging.LogRecord) -> None:  # pragma: no cover
        """Log the message."""
        try:
            level: int | str = logger.level(record.levelname).name
        except ValueError:
            level = record.levelno

        frame, depth = logging.currentframe(), 2
        while frame.f_code.co_filename == logging.__file__:
            frame = frame.f_back  # type: ignore
            depth += 1

        log = logger.bind(request_id="app")
        log.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())


def _format_record(record: dict[str, dict[str, str]]) -> str:
    """
    Set custom format for loguru loggers.

    Uses pformat for log any data like request/response body during debug. Works with
    logging if loguru handler it.

    """
    format_string = BO_FORMAT

    if record["extra"].get("payload") is not None:
        record["extra"]["payload"] = pformat(
            record["extra"]["payload"], indent=4, compact=False
        )
        format_string += "\n<level>{extra[payload]}</level>"

    format_string += "{exception}\n"
    return format_string


console = Console(
    force_terminal=True,
    force_interactive=True,
    # width=120,
    emoji=True,
    markup=True,
    color_system="truecolor",
    stderr=False,
)


def _get_logger() -> loguru.Logger:
    """Set up the logger."""
    # set format
    loguru_logger.configure(
        handlers=[
            # {"sink": sys.stdout, "level": logging.DEBUG, "format": _format_record}
            {
                "sink": RichHandler(
                    markup=True,
                    rich_tracebacks=True,
                    tracebacks_show_locals=True,
                    console=console,
                ),
                "format": _format_record,
            }
        ]
    )

    # works with uvicorn>=0.11.6
    loggers = (
        logging.getLogger(name)
        for name in logging.root.manager.loggerDict  # type: ignore # noqa
        if name.startswith("uvicorn.")
    )
    for uvicorn_logger in loggers:
        uvicorn_logger.handlers = []

    logging.getLogger("uvicorn").handlers = [InterceptHandler()]

    return loguru_logger


logger = _get_logger()

Is there anything I could be doing differently so that when any exception comes up, rich can catch it and work it's magic on the output?