Python rejestrowanie wielu plików przy użyciu tego samego rejestratora

Question

Oto mój scenariusz: chcę zalogować aktywność mojego_module. Należy to zrobić, w zależności od metody wykonanej (powiedzmy INPUT i OUTPUT), do dwóch różnych plików.

Mam dwa menedżery, każdy z nich wskazuje inny plik (my_in_.log & my_out_.log) z tym samym poziomem dziennika. Chciałbym wiedzieć, czy mogę użyć tego samego rejestratora, aby to osiągnąć, lub muszę zdefiniować dwa rejestratory. Moja config jest:

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

Czy muszę zdefiniować rejestratora za handler/przeznaczenia? (ponieważ chcę rejestrować różne informacje w różnych plikach) Czy istnieje sposób wskazania programowi rejestrującemu, który program obsługi zrobi to? Mam na myśli, że mam dwa programy obsługi dla jednego rejestratora, a następnie wybieram tylko jedną procedurę obsługi, aby zarejestrować jedną metodę.

Thx dużo!

Answer 1

Wreszcie zdecydowałem się zdefiniować dwa rejestratory, ponieważ:

• Są dla różnych purposses. W moim przypadku jeden loguje żądanie wejściowe do usługi sieciowej, a drugi loguje odpowiedź. I używają do tego różnych plików

• Używam pliku konfiguracji rejestrowania, w przednim serwisie sieciowym. Dodanie/usunięcie procedur obsługi przed logowaniem wiadomości nie jest właściwym podejściem, jak powiedział @mike. Thx to @drekyn też!

Oto mój plik konfiguracyjny logowania, tylko w celach informacyjnych, jeśli ktoś jest zainteresowany:

[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= 

zobaczenia!

Answer 2

Należy utworzyć instancję obsługi dla każdego miejsca docelowego, do którego chcesz wysłać dziennik, a następnie dodać 2 procedury obsługi do rejestratora. Poniższa powinien działać (nie testowałem go jednak):

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

Oczywiście dodać wszystkie opcje konfiguracyjne i formatowania może być konieczne. Zasadniczo jest to po prostu pokazanie, że kiedy tworzysz moduł obsługi dziennika, możesz dodać go do programu rejestrującego. Od tego momentu Twoje rekordy dziennika będą wysyłane do każdego programu obsługi dodanego do programu rejestrującego.

Answer 3

co chcesz jest

1. utworzyć 2 NON rejestratory korzenia.
2. make obsługi dla każdego z nich, punkt do innego pliku

3. add obsługi do odpowiedniego rejestratora

   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) 
   

następnie

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

Należy pamiętać, że jeśli tworzysz rejestrator ROOT i inny rejestrator, dziennik główny rejestruje wszystko, co ten inny kontroler próbuje zarejestrować.

Innymi słowy, jeśli

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) 

następnie

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