Doppelte Protokollausgabe bei Verwendung des Python-Protokollierungsmoduls

Ich benutze Python Logger. Folgendes ist mein Code:

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

Das Problem ist, dass ich für jeden logger.infoAnruf mehrere Einträge in der Protokolldatei erhalte . Wie kann ich das lösen?

Das logging.getLogger()ist schon ein Singleton. ( Dokumentation )

Das Problem ist, dass bei jedem Aufruf myLogger()der Instanz ein weiterer Handler hinzugefügt wird, der zu doppelten Protokollen führt.

Vielleicht so etwas?

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

Seit Python 3.2 können Sie einfach überprüfen, ob bereits Handler vorhanden sind, und diese in diesem Fall löschen, bevor Sie neue Handler hinzufügen. Dies ist beim Debuggen sehr praktisch und der Code enthält Ihre Logger-Initialisierung

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

machte den Trick für mich

mit Python 2.7

Ich habe das bereits loggerals Singleton verwendet und überprüft if not len(logger.handlers), aber immer noch Duplikate erhalten : Es war die formatierte Ausgabe, gefolgt von der unformatierten.

Lösung in meinem Fall: logger.propagate = False

Dank an diese Antwort und die Dokumente .

Sie rufen Logger.myLogger()mehr als einmal an. Speichern Sie die Logger - Instanz es gibt irgendwo und Wiederverwendung , dass .

Beachten Sie außerdem, dass ein Standardwert erstellt StreamHandler(sys.stderr)wird , wenn Sie sich vor dem Hinzufügen eines Handlers anmelden .

Dies ist eine Ergänzung zu @ rm957377s Antwort, aber mit einer Erklärung, warum dies geschieht . Wenn Sie eine Lambda-Funktion in AWS ausführen, rufen sie Ihre Funktion innerhalb einer Wrapping-Instanz auf, die für mehrere Aufrufe am Leben bleibt. Das heißt, wenn Sie addHandler()den Code Ihrer Funktion aufrufen , werden dem Protokollierungs-Singleton bei jeder Ausführung der Funktion weiterhin doppelte Handler hinzugefügt. Der Protokollierungs-Singleton bleibt durch mehrere Aufrufe Ihrer Lambda-Funktion bestehen.

Um dies zu lösen, können Sie Ihre Handler löschen, bevor Sie sie einstellen über:

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

Ihr Logger sollte als Singleton arbeiten. Sie sollten es nicht mehr als einmal erstellen. Hier ist ein Beispiel, wie es aussehen könnte:

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

Die Implementierung von Logger ist bereits ein Singleton.

Mehrere Aufrufe von logging.getLogger ('someLogger') geben einen Verweis auf dasselbe Logger-Objekt zurück. Dies gilt nicht nur innerhalb desselben Moduls, sondern auch modulübergreifend, solange es sich im selben Python-Interpreter-Prozess befindet. Dies gilt für Verweise auf dasselbe Objekt. Darüber hinaus kann der Anwendungscode einen übergeordneten Logger in einem Modul definieren und konfigurieren und einen untergeordneten Logger in einem separaten Modul erstellen (aber nicht konfigurieren). Alle Logger-Aufrufe an das untergeordnete Protokoll werden an das übergeordnete Protokoll weitergeleitet. Hier ist ein Hauptmodul

Quelle - Verwenden der Anmeldung in mehreren Modulen

Die Art und Weise, wie Sie dies nutzen sollten, ist -

Nehmen wir an, wir haben im Hauptmodul einen Logger namens 'main_logger' erstellt und konfiguriert (der den Logger einfach konfiguriert und nichts zurückgibt ).

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

Wenn wir jetzt in einem Untermodul einen untergeordneten Logger erstellen , der der Namenshierarchie 'main_logger.sub_module_logger' folgt, müssen wir ihn nicht im Untermodul konfigurieren. Es reicht aus, nur den Logger nach der Namenshierarchie zu erstellen.

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

Außerdem wird kein doppelter Handler hinzugefügt.

In dieser Frage finden Sie eine ausführlichere Antwort.

Eine doppelte (oder dreifache oder ..- basierend auf der Anzahl der Neuladungen) Logger-Ausgabe kann auch auftreten, wenn Sie Ihr Modul über neu laden importlib.reload(aus dem gleichen Grund, wie in der akzeptierten Antwort erläutert). Ich füge diese Antwort nur als zukünftige Referenz hinzu, da ich eine Weile gebraucht habe, um herauszufinden, warum meine Ausgabe doppelt (dreifach) ist.

Eine einfache Problemumgehung ist wie

logger.handlers[:] = [handler]

Auf diese Weise vermeiden Sie, dass ein neuer Handler an die zugrunde liegende Liste "Handler" angehängt wird.

Fazit: In den meisten Fällen muss logger.getLogger () nur einmal pro Modul aufgerufen werden. Wenn Sie wie ich mehrere Klassen haben, könnte ich das so nennen:

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

Beide haben dann ihren eigenen vollständigen Paketnamen und ihre eigene Methode, wo sie protokolliert werden.

Sie können eine Liste aller Handler für den jeweiligen Logger abrufen, um so etwas zu tun

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)

Im obigen Beispiel prüfen wir, ob der Handler für eine angegebene Datei bereits mit dem Logger verknüpft ist. Wenn Sie jedoch auf die Liste aller Handler zugreifen können, können Sie entscheiden, nach welchen Kriterien Sie einen weiteren Handler hinzufügen möchten oder nicht.

Hatte heute dieses Problem. Da meine Funktionen @staticmethod waren, wurden die obigen Vorschläge mit random () aufgelöst.

Sieht ungefähr so ​​aus:

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