Recuento de resumen para el registro de Python

Question

Al final de mi programa de Python, me gustaría poder obtener un resumen de la cantidad de elementos registrados a través del módulo estándar logging. Me gustaría obtener un recuento específico para cada nombre especificado (y posiblemente sus hijos). P.ej. si tengo:

input_logger = getLogger('input') 
input_logger.debug("got input1") 
input_logger.debug("got input2") 
input_logger.debug("got input3") 

network_input_logger = getLogger('input.network') 
network_input_logger.debug("got network input1") 
network_input_logger.debug("got network input2") 

getLogger('output') 
output_logger.debug("sent output1") 

Luego, al final me gustaría obtener un resumen tales como:

input: 5 
input.network: 2 
output: 1 

estoy pensando, llamando a un método para getcount() un registrador o un controlador.

¿Cuál sería una buena manera de lograrlo? Me imagino que implicaría una subclase de una de las clases en el módulo logging, pero no estoy seguro de cuál sería la mejor manera de hacerlo.

Answer 1

El uso de un decorador podría ser bastante elegante, no he probado esto, pero algo como esto podría funcionar:

class myDecorator(object): 
    def __init__(self, inner): 
     self.inner = inner 
     self.log = {} 

    def __getattr__(self,name): 
     self.log[name] = self.log.get(name,0)+1 
     return getattr(self.inner,name) 

    def __setattr__(self,name,value): 
     setattr(self.inner,name,value) 

Me estoy dando cuenta de que usted no desea registrar el número de llamadas a cada método pero llama a cada registrador diferente. De todos modos, creo que un decorador podría ser muy elegante.

No creo que haya dormido lo suficiente, la idea sería envolver las llamadas a su registrador, estoy mezclando el uso de un decorador con el patrón de decorador. (En realidad, una combinación del patrón y la sintaxis sería una gran respuesta)

Aquí hay una solución más completa. Lo siento, me di cuenta de que era el someone that was wrong on the internet.

class LoggerLogger(object): 
    def __init__(self,inner,name): 
     self.inner = inner 
     self.calls = 0 
    def __call__(self,*args,**kwargs): 
     self.calls += 1 
     return self.inner(*args,**kwargs) 


def loggerDecorator(func): 
    def inner(name): 
     logger = func(name) 
     logger.debug = LoggerLogger(logger.debug,name) 
    return inner 

getLogger = loggerDecorator(getLogger) 

Answer 2

Creo que el patrón de decorador podría ser el método más limpio para implementar esto.

Pasará una instancia de Logger al LoggerDecorator que tendrá la misma interfaz que el registrador. Cuando se llama a uno de los métodos, se incrementa una variable miembro según corresponda. Entonces implementar el método getCount() será trivial.

Aquí es una referencia en la implementación de decorador en Python:

http://wiki.python.org/moin/DecoratorPattern