Python click option based logging in decorator - python-3.x

Question

Fresh start. I have a CLI application that uses click for handling argument parsing. For the main "executable" script I have a defined verbosity flag (-v, -vv, -vvv, ...) that controls logging verbosity. I want to "trace" function calls for specific functions. Down below is a sample that hopefully will make it clear.
import click
import logging
import functools
class MyLogger(object):
def __init__(self):
self.__logger = None
def init_logger(self, name, verbosity):
logging_levels = {0: logging.CRITICAL,
1: logging.ERROR,
2: logging.INFO,
3: logging.DEBUG}
logging.basicConfig(level=logging_levels.get(verbosity, logging.WARNING))
self.__logger = logging.getLogger(name)
#property
def logger(self):
return self.__logger
myLogger = MyLogger()
class TraceFunction(object):
def __init__(self, logger):
self.logger = logger
def __call__(self, function):
name = function.__name__
#functools.wraps(function)
def wrapped(*args, **kwargs):
self.logger.debug(f'{name}({list(*args)}, {dict(**kwargs)})')
result = function(*args, **kwargs)
self.logger.debug(f'{result}')
return result
return wrapped
# (1) #TraceFunction(myLogger.logger)
def echo(message):
return message.upper()
#click.command('echo')
#click.option('-e', '--echo', 'message', required=True, type=str)
def echo_command(message):
myLogger.logger.info('echo_command')
return echo(message)
#click.group()
#click.option('-v', 'verbosity', count=True)
def main(verbosity: int):
myLogger.init_logger(__name__, verbosity)
# (2) TraceFunction(myLogger.logger)(echo)
myLogger.logger.info('main')
if __name__ == '__main__':
main.add_command(echo_command)
main()
The above if executed will correctly produce the following output:
script.py -vv echo -e "Hello World"
INFO: __main__:main
INFO: __main__:echo_command
I want to "trace" the function: echo. More precisely I want to log the actual function call with the actual arguments and the returned value. Okay, a bit more than that but I needed a minimal sample. For this purpose I tried two things, labeled with (1) and (2) placed in comments.
#TraceFunction(myLogger.logger)
def echo(message):
return message.upper()
It flat out doesn't work as with my original question python will execute TraceFunction.call(echo) before in "main" I call init_logger that essentially would configure the logger itself. As a result in TraceFunction.call the logger is None and I get:
AttributeError: 'NoneType' object has no attribute 'debug'
Fine, I can register it later on, at least I thought with (2). Well the exception surely went away, however "wrapped" defined in call is never invoked and well once again nothing gets logged other than the already shown
script.py -vvv echo -e "Hello World"
INFO: __main__:main
INFO: __main__:echo_command
#Update
Going by afterburner's answer things go a bit further but it doesn't do what it's supposed to:
script.py -vvv echo -e "Hello World"
DEBUG:__main__:echo(['F','o','o'],{})
DEBUG:__main__:FOO
INFO: __main__:main
INFO: __main__:echo_command
Which well is expected. The expected output on the other hand would be:
script.py -vvv echo -e "Hello World"
INFO: __main__:main
INFO: __main__:echo_command
DEBUG:__main__:echo(['Hello World'],{})
DEBUG:__main__:HELLO WORLD

Answer 1

So, the main issue I can see is that you're not calling the wrapped function.
TraceFunction(myLogger.logger)(echo)
# vs
TraceFunction(myLogger.logger)(echo)()
I have also made a couple of changes to your code, but the main issue was the fact the wrapped function was never getting invoked.
class MyLogger(object):
def __init__(self):
self.__logger = None
def init_logger(self, name, verbosity):
# extract log level based on verbosity flag
logging_levels = [logging.CRITICAL, logging.INFO, logging.DEBUG]
logging.basicConfig(level=logging_levels[verbosity])
self.__logger = logging.getLogger(name)
#property
def logger(self):
return self.__logger
myLogger = MyLogger()
class TraceFunction(object):
def __init__(self, logger):
self.logger = logger
def __call__(self, function):
name = function.__name__
#functools.wraps(function)
def wrapped(*args, **kwargs):
# improved the formatting of arguments
nicely_formatted_args = ', '.join(args)
nicely_formatted_kwargs = ', '.join(kwargs)
arguments = nicely_formatted_args
if nicely_formatted_kwargs != '':
arguments = f'{arguments}, {nicely_formatted_kwargs}'
self.logger.debug(f'{name}({arguments})')
result = function(*args, **kwargs)
self.logger.debug(f'{result}')
return result
return wrapped
# (1) #TraceFunction(myLogger.logger)
def echo(message):
return message.upper()
#click.command('echo')
#click.option('-e', '--echo', 'message', required=True, type=str)
def echo_command(message):
myLogger.logger.info('echo_command')
return echo(message)
#click.group()
#click.option('-v', 'verbosity', count=True) # <- made verbosity a count argument so you can extract all of your levels based on -v -vv -vvv etc.
def main(verbosity):
myLogger.init_logger(__name__, verbosity)
# (2)
# Invoking the function with argument 'Foo'
TraceFunction(myLogger.logger)(echo)("Foo")
def run_logging():
main.add_command(echo_command)
main()
if __name__ == '__main__':
run_logging()

Answer 2

I managed to get it working but it sure is ugly... at least in its current form. The only needed change was:
#click.group()
#click.option('-v', 'verbosity', count=True)
def main(verbosity: int = 0):
global echo
myLogger.init_logger(__name__, verbosity)
echo = TraceFunction(myLogger.logger)(echo) # <<< !!!
myLogger.logger.info('main')
In doing so the output becomes:
INFO:__main__:main
INFO:__main__:echo_command
TRACE:__main__:echo(['Hello World'], {})
TRACE:__main__:HELLO WORLD
So the answer was, that I completely missed:
TraceFunction(myLogger.logger)(echo)
is fine, but I needed to assign it to the original echo function:
echo = TraceFunction(myLogger.logger)(echo)