[Python-ideas] Efficient debug logging

[Barry Scott]

A common pattern I use is to have logging calls for debug and information with my applications.
The logging calls can be separately enabled and disabled.

For example:

debug_log_enabled = False
def debugLog( msg ):
      If debug_log_enabled:
            print( ‘Debug: %s’ % (msg,) )

Then the caller can simple write:

def main():
      debugLog( ‘Start of main’ )

This is fine until the evaluation of the msg becomes expensive.

	debugLog( ‘info is %r’ % (expensiveFunction(),) )

What would be nice is to be able to avoid evaluation the tuple of arguments if debug is
disabled as this can be expensive. I can write this:

	if debug_log_enabled:  debugLog( ‘info is %r’ % (expensiveFunction(),) )

But that is a more code then I would like to write. And if the debug code is a performance problem cannot
be left in the production code.

I could combine the boolean and the log function by using a class to tidy up the implementation.

class DebugLog:
	def __init__( self, enabled = False ):
		self.enabled = enabled

	def __bool__( self ):
		return self.enabled

	def __call__( self, msg ):
		if self.enabled: print( ‘Debug: %s’ % (msg,) )

And call like this:

	dbg_log = DebugLog()

       If dbg_log: dbg_log( ‘a debug message’ )

But I’d like to only write:

	dbg_log( ‘a debug message’ )

And have the evaluation of the argument skipped unless its dbg_log is enabled.

I cannot see how to do this with python as it stands.

Something would have to be added to allow python to short circuit the argument tuple evaluation.

Maybe python can check for a special dunder on the class that know how to do this idiom, __if_true_call__?

Thoughts?

Barry