Zduplikowane dane wyjściowe dziennika podczas korzystania z modułu rejestrowania w języku Python

Używam rejestratora Pythona. Oto mój kod:

import os
import time
import datetime
import logging
class Logger :
   def myLogger(self):
      logger = logging.getLogger('ProvisioningPython')
      logger.setLevel(logging.DEBUG)
      now = datetime.datetime.now()
      handler=logging.FileHandler('/root/credentials/Logs/ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
      formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
      handler.setFormatter(formatter)
      logger.addHandler(handler)
      return logger

Problem polega na tym, że podczas każdego logger.infopołączenia otrzymuję wiele wpisów w pliku dziennika . Jak mogę to rozwiązać?

To logging.getLogger()już jest singleton. ( Dokumentacja )

Problem polega na tym, że za każdym razem, gdy dzwonisz myLogger(), dodaje on kolejną procedurę obsługi do instancji, co powoduje zduplikowane dzienniki.

Może coś takiego?

import os
import time
import datetime
import logging

loggers = {}

def myLogger(name):
    global loggers

    if loggers.get(name):
        return loggers.get(name)
    else:
        logger = logging.getLogger(name)
        logger.setLevel(logging.DEBUG)
        now = datetime.datetime.now()
        handler = logging.FileHandler(
            '/root/credentials/Logs/ProvisioningPython' 
            + now.strftime("%Y-%m-%d") 
            + '.log')
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        loggers[name] = logger

        return logger

Od Pythona 3.2 możesz po prostu sprawdzić, czy programy obsługi są już obecne, a jeśli tak, wyczyść je przed dodaniem nowych programów obsługi. Jest to bardzo wygodne podczas debugowania, a kod obejmuje inicjalizację programu rejestrującego

if (logger.hasHandlers()):
    logger.handlers.clear()

logger.addHandler(handler)

import datetime
import logging
class Logger :
    def myLogger(self):
       logger=logging.getLogger('ProvisioningPython')
       if not len(logger.handlers):
          logger.setLevel(logging.DEBUG)
          now = datetime.datetime.now()
          handler=logging.FileHandler('/root/credentials/Logs/ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
          formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
          handler.setFormatter(formatter)
          logger.addHandler(handler)
        return logger

zrobił dla mnie sztuczkę

za pomocą Pythona 2.7

Użyłem już loggerjako singletona i sprawdziłem if not len(logger.handlers), ale nadal otrzymałem duplikaty : było to sformatowane wyjście, a następnie niesformatowane.

Rozwiązanie w moim przypadku: logger.propagate = False

Podziękowania za tę odpowiedź i dokumenty .

Dzwonisz Logger.myLogger()więcej niż raz. Zapisz gdzieś zwracaną instancję rejestrującą i użyj jej ponownie .

Pamiętaj również, że jeśli zalogujesz się przed dodaniem jakiegokolwiek modułu obsługi, StreamHandler(sys.stderr)zostanie utworzony domyślny .

Implementacja loggera jest już singletonem.

Wielokrotne wywołania loggera.getLogger („someLogger”) zwracają odwołanie do tego samego obiektu rejestrującego. Dotyczy to nie tylko tego samego modułu, ale także między modułami, o ile jest to w tym samym procesie interpretera języka Python. Dotyczy to odniesień do tego samego obiektu; dodatkowo, kod aplikacji może definiować i konfigurować nadrzędny rejestrator w jednym module i tworzyć (ale nie konfigurować) podrzędny rejestrator w oddzielnym module, a wszystkie wywołania logera do dziecka będą przekazywane do rodzica. Oto główny moduł

Źródło - korzystanie z logowania w wielu modułach

Tak więc powinieneś to wykorzystać -

Załóżmy, że stworzyliśmy i skonfigurowaliśmy rejestrator o nazwie „main_logger” w głównym module (który po prostu konfiguruje rejestrator, nic nie zwraca).

# get the logger instance
logger = logging.getLogger("main_logger")
# configuration follows
...

Teraz w module podrzędnym, jeśli utworzymy rejestrator podrzędny zgodnie z hierarchią nazewnictwa „main_logger.sub_module_logger” , nie musimy go konfigurować w module podrzędnym. Wystarczy utworzyć rejestrator zgodnie z hierarchią nazewnictwa.

# get the logger instance
logger = logging.getLogger("main_logger.sub_module_logger")
# no configuration needed
# it inherits the configuration from the parent logger
...

I nie doda również zduplikowanej obsługi.

Zobacz to pytanie, aby uzyskać bardziej szczegółową odpowiedź.

To jest dodatek do odpowiedzi @ rm957377, ale z wyjaśnieniem, dlaczego tak się dzieje . Kiedy uruchamiasz funkcję lambda w AWS, wywołują twoją funkcję z wewnątrz instancji opakowującej, która pozostaje aktywna dla wielu wywołań. Oznacza to, że jeśli wywołasz addHandler()w kodzie funkcji, będzie ona nadal dodawać zduplikowane procedury obsługi do singletonu rejestrowania za każdym razem, gdy funkcja zostanie uruchomiona. Singleton rejestrowania utrzymuje się przez wiele wywołań funkcji lambda.

Aby rozwiązać ten problem, możesz wyczyścić programy obsługi przed ich ustawieniem za pomocą:

logging.getLogger().handlers.clear()
logging.getLogger().addHandler(...)

Twój rejestrator powinien działać jako singleton. Nie powinieneś go tworzyć więcej niż raz. Oto przykład, jak to może wyglądać:

import os
import time
import datetime
import logging
class Logger :
    logger = None
    def myLogger(self):
        if None == self.logger:
            self.logger=logging.getLogger('ProvisioningPython')
            self.logger.setLevel(logging.DEBUG)
            now = datetime.datetime.now()
            handler=logging.FileHandler('ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
            formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)
        return self.logger

s = Logger()
m = s.myLogger()
m2 = s.myLogger()
m.info("Info1")
m2.info("info2")

Podwójne (lub potrójne lub ... - w zależności od liczby przeładowań) wyjście loggera może się również zdarzyć, gdy przeładujesz moduł przez importlib.reload(z tego samego powodu, co wyjaśniono w zaakceptowanej odpowiedzi). Dodaję tę odpowiedź tylko dla przyszłego odniesienia, ponieważ zajęło mi trochę czasu, aby dowiedzieć się, dlaczego mój wynik jest podwójny (potrójny).

Jedno proste obejście jest podobne

logger.handlers[:] = [handler]

W ten sposób unika się dołączania nowego modułu obsługi do bazowej listy „programów obsługi”.

Podsumowując, w większości przypadków, gdy tak się dzieje, wystarczy wywołać logger.getLogger () tylko raz na moduł. Jeśli masz wiele zajęć, tak jak ja, mogę to tak nazwać:

LOGGER = logger.getLogger(__name__)

class MyClass1:
    log = LOGGER
    def __init__(self):
        self.log.debug('class 1 initialized')

class MyClass2:
    log = LOGGER
    def __init__(self):
        self.log.debug('class 2 initialized')

Oba będą miały własną pełną nazwę pakietu i metodę, w której są rejestrowane.

Możesz uzyskać listę wszystkich programów obsługi dla konkretnego rejestratora, więc możesz zrobić coś takiego

logger = logging.getLogger(logger_name)
handler_installed = False
for handler in logger:
    # Here your condition to check for handler presence
    if isinstance(handler, logging.FileHandler) and handler.baseFilename == log_filename:
        handler_installed = True
        break

if not handler_installed:
    logger.addHandler(your_handler)

W powyższym przykładzie sprawdzamy, czy handler dla określonego pliku jest już podpięty do loggera, ale mając dostęp do listy wszystkich handlerów możesz zdecydować, które kryteria powinieneś dodać, czy nie.

Miałem ten problem dzisiaj. Ponieważ moje funkcje były @staticmethod, powyższe sugestie zostały rozwiązane za pomocą random ().

Wygląda jak:

import random

logger = logging.getLogger('ProvisioningPython.{}'.format(random.random()))

from logging.handlers import RotatingFileHandler
import logging
import datetime

# stores all the existing loggers
loggers = {}

def get_logger(name):

    # if a logger exists, return that logger, else create a new one
    global loggers
    if name in loggers.keys():
        return loggers[name]
    else:
        logger = logging.getLogger(name)
        logger.setLevel(logging.DEBUG)
        now = datetime.datetime.now()
        handler = logging.FileHandler(
            'path_of_your_log_file' 
            + now.strftime("%Y-%m-%d") 
            + '.log')
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        loggers.update(dict(name=logger))
        return logger