Conteggio di riepilogo per la registrazione Python

Question

Alla fine del mio programma Python, mi piacerebbe essere in grado di ottenere un riepilogo del numero di elementi registrati tramite il modulo standard logging. Mi piacerebbe in particolare essere in grado di ottenere un conteggio per ogni nome specificato (e possibilmente i suoi figli). Per esempio. se ho:

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") 

Poi alla fine mi piacerebbe ottenere un riepilogo come ad esempio:

input: 5 
input.network: 2 
output: 1 

sto pensando, chiamando un metodo getcount() per un registratore o di un gestore.

Quale sarebbe un buon modo per raggiungere questo obiettivo? Immagino che coinvolgerebbe una sottoclasse di una delle classi nel modulo logging, ma non sono sicuro quale sarebbe il modo migliore per andare.

Answer 1

Utilizzando un decoratore potrebbe essere abbastanza elegante, non ho ancora testato questo, ma qualcosa di simile potrebbe funzionare:

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) 

sto realizzando che non volevi per registrare il numero di chiamate a ciascun metodo ma chiama ogni diverso logger. Comunque penso che un decoratore possa essere piuttosto elegante.

Non credo di aver dormito abbastanza, l'idea sarebbe quella di avvolgere le chiamate sul tuo registratore, sto mescolando l'uso di un decoratore con il modello di decoratore. (In realtà un mix del pattern e della sintassi sarebbe un'ottima risposta)

Ecco una soluzione più completa. Mi dispiace di aver capito che ero lo 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

Penso che il modello di decoratore potrebbe essere il metodo più pulito per implementarlo.

Passerai un'istanza di Logger nel LoggerDecorator che avrà la stessa interfaccia del registratore. Quando uno dei metodi viene chiamato, incrementa una variabile membro in modo appropriato. Quindi implementare il metodo getCount() sarà banale.

Qui è un riferimento attuazione decoratore in Python:

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