Is there a way to make writing Python logger more like writing print statements?

Question

I recently using python, and the code I've been writing is starting to get large enough that I'm beginning to toggle on and off print statements, so I looked around to see what SO reccommended, and it every time the community votes that one should use logging, instead of print but discussions and documentation on how to configure it to be easy to use are confusing and hard to follow.

However, I'm finding the logger version of writing statments is more time consuming, and harder for a human to parse and just plain gross to look at:

print (‘First value is:‘, val1, ‘Second value is‘, val2)

vs

logger.info(‘value 1 is: %s , value 2 is: %s’, val1, val2)

Other than rolling my own debugging levels with something along the line of:

DEBUGGING = True

def debug (msg):
   if DEBUGGING:
      print (msg)

Is there something I can do to make logging statements simpler to read an write? or another package I should try?

Answer 1

Two options.

1) stdlib logging is long in the tooth. Try a different library. I like structlog. This is key/value logging:

>>> import structlog
>>> log = structlog.get_logger()
>>> log.info('some event', val1='first value', val2='second value')
2018-08-16 21:01.02 some event                   val1=first value val2=second value

2) You can actually just continue using print calls, if you want. This is actually recommended best practice for the popular Twelve-Factor App methodology, where log events are just lines on stdout. Usually each line is a serialised json object, but that's not the only sensible choice.

A twelve-factor app never concerns itself with routing or storage of its output stream. It should not attempt to write to or manage logfiles. Instead, each running process writes its event stream, unbuffered, to stdout.

The idea here is that there are already powerful and flexible logging solutions available, at the OS level, and we should just leverage those rather than reinvent the wheel. For example, you can just run your app piped into syslog:

./myapp.py | logger -t myapp &

Answer 2

If it's just syntax-sugar you want, something like

def info (logger, *args):
    logger.info("".join(str(item) for item in args))

will let you write it almost like print:

info(my_logger, 'First value is:', val1, 'Second value is', val2)

It would be possible to monkeypatch the logger methods to do this for you, but it's probably not a good idea -- changing the behavior stdlib objects tends to anger the next person who picks up your code. If you want to keep the general appearance of a regular logger but not earn bad karma you could add a simple shim class to do the assembly:

class LogShim (object):

    def __init__(self, logger):
        self.logger = logger

    def log(self, level, *msg):
        if self.logger.isEnabledFor(level):
            concatenated =  " ".join(str(a) for a in msg)
            self.logger.log(level, concatenated)

    def debug(self, *msg):
        self.logger.log(logging.DEBUG, *msg)

    def info(self, *msg):
        self.log(logging.INFO, *msg)

    def warning(self, *msg):
        self.log(logging.WARNING, *msg)

    def error(self, *msg):
        self.log(logging.ERROR, *msg)

    def critical(self, *msg):
        self.log(logging.CRITICAL, *msg)

And then use it like a logger:

my_logger = logging.getLogger()
my_shim = LogShim(my_logger)
my_shim.debug("here", "are", 4, "items")