How to use rich logger without enforced wrapping?

[ssbarnea]

While replacing the standard python logger with a rich one I discovered that longer lines get wrapped and that normal lines do get extra padding at the end, both being undesired actions, especially as same logging result can be sent to files or other apps for further processing.

I tried adding width=0 to Console instance used for logger but that basically broke it and produced no output. None seems to be reserved to auto-detection. I also tried putting a very big value but that produced very long spam lines, even when called with console=False

LOGGING_CONSOLE = Console(
    file=sys.stderr,
    force_terminal=False,
    width=300)

How can I make the rich logging not add extra padding and avoid any wrapping?

[willmcgugan]

If you are using RichHandler, then you can't change that behaviour. It's designed to format it for the terminal and wrapping is necessary for neat columns.

If you want to also log to a file, you can configure a FileHandler (or any other logging handler(s)) in conjunction with the Rich handler.

[ssbarnea]

As "final" console width cannot be always be known at the time logging happens (CI is best example, where you want to produce nice output, but you never known the width, as this will endup being rendered in a browser).

This means that we either need a new handler that does not wrap or another option to disable wrapping in current one. Considering the "0" value is not currently used, it could make sense to use it to disable wrapping. Still, as did not look on how is implemented yet, I will likely wait for you to say if is doable or not.

I do love the richhandler, it would a pity not to be able to make use of it.

[willmcgugan]

It's not possible to disable hard wrapping in the Rich logging handler because it would break the columns. If this is a requirement for you I would suggest implementing your own handler based on rich/logging.py.

[ssbarnea]

I was already able to created a custom FluidLogRender class that does not make use of Table(Columns) and had partial success with it.

Still, I am still facing some issues related to some wrapping coming from other places. For example I found that Text() has an implicit no_wrap=None (same as False) which is called from various places. I tried to hack Rich to temporary make no_wrap=True but it was not enough.

Maybe you could give me a hint on how to render the text without any wrapping to occur.

[Toreno96]

Thank you very much @ssbarnea!

While the rich as a whole is amazing library, I wasn't really fond of the RichHandler formatting (I simply wanted some coloring, that's all), and I gave up after trying for definitely too long to hack the original implementation.

You did amazing work at providing the solution 💪

[ssbarnea]

Thanks @Toreno96 for the kind word. To be honest I still hope I will be able to persuade @willmcgugan to get this fluidlogger into rich itself. The reason I want this is because packaging another library just for these few lines of code is not a joy.

It seems that these 85 lines did not need any maintenance in more than an year and I would be more than happy to be the one assigned to address issues if reported, just to avoid having to ask other projects to add an extra library. It is hard for me not to remember nightmares from npm registry where people created packages for even a 3 line function.

[Toreno96]

@willmcgugan Could you share what are the arguments against integrating this into rich? 🙏

[willmcgugan]

I'm not apposed to a fluid logger in principle. But frankly its not for me to say why it shouldn't go in, you will need to make the case why it should.

As soon as I add that, I will get issue after issue for requests for flags and options, because everyones needs differ.

@ssbarnea 's implementation is unnecessarily convoluted. You don't need to derive from RichHandler or create a log render object, when you can create a logging Handler of your own and print a Text instance . In a few lines of code you can have a custom handler that does exactly what you need. Start from the Python docs -- don't hack RichHandler, and it will be much easier.

Ultimately, its an uphill battle to expect me to maintain a FluidLogHandler, when rolling your own is trivial.

[davidparsson]

This is how i managed to print log lines that are colored by another formatter:

import logging

from rich.console import Console
from rich.text import Text


class FluidRichHandler(logging.Handler):
    def __init__(self, console: Console) -> None:
        super().__init__()
        self._console = console

    def emit(self, record: logging.LogRecord) -> None:
        log_line = self.format(record)
        self._console.print(Text.from_ansi(log_line))

[anvaari]

Maybe simple workaround is this use custome handler like this. You can modify format to format other things to

import logging
from rich.console import Console


rprint = Console(soft_wrap=True).print
class MyRichLogHandler(logging.Handler):
    LEVEL_MAPPING = {
        logging.DEBUG: "[blue]DEBUG[/blue]",
        logging.INFO: "[green]INFO[/green]",
        logging.WARNING: "[yellow]WARNING[/yellow]",
        logging.ERROR: "[red]ERROR[/red]",
        logging.CRITICAL: "[bold red]CRITICAL[/bold red]",
    }
    def emit(self, record):
        msg = self.format(record)
        rprint(msg)

    def format(self, record):
        levelname = self.LEVEL_MAPPING.get(record.levelno, str(record.levelno))
        
        file_name_line = (
            f"[link file://{record.filename}#{record.lineno}]"
            f"{record.filename}:{record.lineno}"
            f"[/link file://{record.filename}#{record.lineno}]")
        
        record.levelname = levelname
        record.filename = file_name_line
        return super().format(record)

You can modify format method to format other things too.

in this example if you set base_log_format = %(asctime)s - %(levelname)s in %(filename)s: %(message)s", the `filename wil be link to that number of error in the file which long belong to.