Python che registra più file usando lo stesso logger

Question

Questo è il mio scenario: voglio registrare l'attività di my_module. Questo deve essere fatto, a seconda del metodo eseguito (diciamo, INPUT e OUTPUT), a due file diversi.

Quindi ho due gestori, ognuno dei quali punta a un file diverso (my_in_.log & my_out_.log), con lo stesso livello di registro. Vorrei sapere se posso usare lo stesso registratore per ottenere questo o devo definire due logger. Il mio config è:

[loggers] 
keys=root, my_log 

[handlers] 
keys=my_in_hand, my_out_hand 

[formatters] 
keys=generic_form 


... 


[logger_my_log] 
level=NOTSET 
handlers=my_in_hand, my_out_hand 
qualname=ws_log 

[handler_my_in_hand] 
class=handlers.TimeRotatingFileHandler 
level=NOTSET 
formatter=generic_form 
args=('my_in_.log', 'h', 1, 0, None, False, True) 

[handler_my_out_hand] 
class=handlers.TimeRotatingFileHandler 
level=NOTSET 
formatter=generic_form 
args=('my_out_.log', 'h', 1, 0, None, False, True) 

Devo definire un logger per handler/destinazione? (perché voglio registrare informazioni diverse in file diversi) C'è un modo per indicare al registratore quale gestore lo farà? Voglio dire, ho due gestori per un logger, quindi scelgo un solo gestore per registrare un metodo.

Grazie mille!

Answer 1

ho finalmente deciso di definire due taglialegna, perché:

• Sono per diverse purposses. Nel mio caso, uno registra la richiesta di input in un servizio Web e l'altro registra la risposta. E usano diversi file

• Sto usando un file di configurazione di registrazione, in un servizio web frontale. Aggiungere/rimuovere i gestori prima di registrare i messaggi non è l'approccio corretto, come ha affermato @mike. Grazie a @drekyn!

Ecco il mio file di configurazione di registrazione, solo per riferimento, se qualcuno è interessato a:

[loggers] 
keys=root, ws_in_log, ws_out_log 

[handlers] 
keys=consoleHandler, ws_in_hand, ws_out_hand 

[formatters] 
keys=generic_form 

[logger_root] 
handlers=consoleHandler 
level=NOTSET 

[logger_ws_in_log] 
level=NOTSET 
handlers=ws_in_hand 
qualname=ws_in_log 

[logger_ws_out_log] 
level=NOTSET 
handlers=ws_out_hand 
qualname=ws_out_log 

[handler_ws_in_hand] 
class=logging.handlers.TimedRotatingFileHandler 
level=NOTSET 
formatter=generic_form 
args=('/path/ws_in_.log', 'h', 1, 0, None, False, True) 

[handler_ws_out_hand] 
class=logging.handlers.TimedRotatingFileHandler 
level=NOTSET 
formatter=generic_form 
args=('/path/em/ws_out_.log', 'h', 1, 0, None, False, True) 

[handler_consoleHandler] 
class=StreamHandler 
level=DEBUG 
formatter=generic_form 
args=(sys.stdout,) 

[formatter_generic_form] 
format='%(asctime)s - %(levelname)s - %(message)s' 
datefmt='%Y-%m-%d %H:%M:%S' 
class= 

vederti!

Answer 2

È necessario creare un'istanza di un gestore per ogni destinazione a cui si desidera inviare il registro, quindi aggiungere i 2 gestori al registratore. Il seguente dovrebbe funzionare (non ha testarlo però):

logger = logging.getLogger() 
handler1 = logging.TimedRotatingFileHandler() 
handler2 = logging.TimedRotatingFileHandler() 
logger.addHandler(handler1) 
logger.addHandler(handler2) 

Naturalmente aggiungere tutte le opzioni di configurazione e di formattazione potrebbe essere necessario. Fondamentalmente è solo per mostrarti che quando installi il gestore di logging puoi aggiungerlo al logger. Da quel momento in poi, i record del registro verranno emessi per ogni gestore aggiunto al registratore.

Answer 3

ciò che si desidera è di

1. creare 2 logger non root. handler
2. make per ciascuno di essi, scegliere file diverso

3. gestore metti in adeguata logger

   logger1 = logging.getLogger('general_logger') 
   logger2 = logging.getLogger('some_other_logger') 
   
   log_handler1 = logging.handlers.RotatingFileHandler(file_1, *args) 
   log_handler2 = logging.handlers.RotatingFileHandler(file_2, *args) 
   
   logger1.addHandler(log_handler1) 
   logger2.addHandler(log_handler2) 
   

poi

logger1.info("this will be logged to file_1 ") 
    logger2.info("this will be logged to file_2 ") 

Si prega di notare che se si crea un logger principale e un logger diverso, logger root registrerà tutto ciò che questo diverso controller sta tentando di registrare.

In altre parole, se

root_logger = logging.getLogger() 
    logger2 = logging.getLogger('some_other_logger') 

    root_log_handler = logging.handlers.RotatingFileHandler(file_1, *args) 
    log_handler2 = logging.handlers.RotatingFileHandler(file_2, *args) 

    root_logger.addHandler(root_log_handler) 
    logger2.addHandler(log_handler2) 

poi

root_logger.info("this will be logged to file_1 ") 
    logger2.info("this will be logged to file_1 AND file_2 ")