Using BraceMessage and DollarMessage for Logging Formatting

in

Alright, logging. It’s not just for debugging anymore! With Python’s built-in logging module, you can now format your log messages like a boss. You don’t have to use those ***** % signs and curly braces anymore. Say hello to BraceMessage and DollarMessage the cool kids of logging formatting.

First things first, let’s create our classes:

# Creating a class for formatting log messages using curly braces
class BraceMessage:
    # Initializing the class with a format string, positional arguments, and keyword arguments
    def __init__(self, fmt, /, *args, **kwargs):
        self.fmt = fmt
        self.args = args
        self.kwargs = kwargs
    
    # Defining a string representation of the class
    def __str__(self):
        # Using the format method to format the message with the given arguments
        return self.fmt.format(*self.args, **self.kwargs)

# Creating a class for formatting log messages using dollar signs
class DollarMessage:
    # Initializing the class with a format string and keyword arguments
    def __init__(self, fmt, /, **kwargs):
        self.fmt = fmt
        self.kwargs = kwargs
    
    # Defining a string representation of the class
    def __str__(self):
        # Importing the Template class from the string module
        from string import Template
        # Using the substitute method to format the message with the given arguments
        return Template(self.fmt).substitute(**self.kwargs)

Now you might be wondering what the ***** is going on here. Let’s break it down:

– BraceMessage and DollarMessage are classes that allow us to format our log messages using {} or $ signs instead of % signs.
– The __init__ method initializes the message string (fmt), as well as any arguments (*args) and keyword arguments (**kwargs).
– The __str__ method is where the magic happens. For BraceMessage, we simply call format() on our fmt string with *args and **kwargs passed in. For DollarMessage, we use Python’s Template class to substitute our kwargs into our fmt string.

So how do you actually use these classes? Let’s say you have a logger object called my_logger:

# Import the necessary modules
import logging
from wherever import BraceMessage as __  # Importing the BraceMessage class from the "wherever" module

# Create a logger object
my_logger = logging.getLogger(__name__)
my_logger.setLevel(logging.DEBUG)  # Set the logging level to DEBUG

# Example usage of BraceMessage
my_logger.debug(__('This is a message with {0} placeholders', 2, name='placeholders'))  # Using the BraceMessage class to format a message with placeholders and passing in arguments and keyword arguments

# Example usage of DollarMessage
class Point: pass  # Creating a Point class
...
p = Point()  # Instantiating a Point object
p.x = 0.5  # Assigning a value to the x attribute
p.y = 0.5  # Assigning a value to the y attribute
my_logger.debug(__('This is a message with coordinates: ($point.x:.2f), ($point.y:.2f)', point=p))  # Using the DollarMessage class to substitute the values of the x and y attributes into the message using Python's Template class. The .2f specifies that the values should be formatted as floats with 2 decimal places.

And that’s it! You can now format your log messages using {} or $ signs instead of % signs, making them easier to read and understand. Plus, you don’t have to worry about escaping any special characters like backslashes or quotes.

So go ahead, unleash the power of BraceMessage and DollarMessage in your Python logging game!

SICORPS