Verwenden der Anmeldung in mehreren Modulen

Ich habe ein kleines Python-Projekt mit der folgenden Struktur:

Project 
 -- pkg01
   -- test01.py
 -- pkg02
   -- test02.py
 -- logging.conf

Ich plane, das Standardprotokollierungsmodul zu verwenden, um Nachrichten an stdout und eine Protokolldatei zu drucken. Um das Protokollierungsmodul verwenden zu können, ist eine Initialisierung erforderlich.

import logging.config

logging.config.fileConfig('logging.conf')
logger = logging.getLogger('pyApp')

logger.info('testing')

Derzeit führe ich diese Initialisierung in jedem Modul durch, bevor ich mit der Protokollierung von Nachrichten beginne. Ist es möglich, diese Initialisierung nur einmal an einem Ort durchzuführen, sodass dieselben Einstellungen durch Protokollierung im gesamten Projekt wiederverwendet werden?

Es wird empfohlen, in jedem Modul einen Logger wie folgt zu definieren:

import logging
logger = logging.getLogger(__name__)

in der Nähe der Oberseite des Moduls und dann in anderem Code im Modul tun Sie z

logger.debug('My message with %s', 'variable data')

Wenn Sie die Protokollierungsaktivität innerhalb eines Moduls unterteilen müssen, verwenden Sie z

loggerA = logging.getLogger(__name__ + '.A')
loggerB = logging.getLogger(__name__ + '.B')

und melden Sie sich bei loggerAund loggerBnach Bedarf an.

Führen Sie in Ihrem Hauptprogramm oder Ihren Hauptprogrammen z.

def main():
    "your program code"

if __name__ == '__main__':
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    main()

oder

def main():
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    # your program code

if __name__ == '__main__':
    main()

Siehe hier für aus mehreren Modulen Anmeldung und hier für die Protokollierung Konfiguration für Code, der durch einen anderen Code als Bibliothek - Modul verwendet wird.

Update: Beim Aufrufen fileConfig()möchten Sie möglicherweise angeben, disable_existing_loggers=Falseob Sie Python 2.6 oder höher verwenden ( weitere Informationen finden Sie in den Dokumenten ). Der Standardwert ist die TrueAbwärtskompatibilität. Dadurch werden alle vorhandenen Protokollierer deaktiviert, es fileConfig()sei denn, sie oder ihre Vorfahren werden in der Konfiguration explizit benannt. Wenn der Wert auf gesetzt ist False, werden vorhandene Logger in Ruhe gelassen. Wenn Sie Python 2.7 / Python 3.2 oder höher verwenden, sollten Sie die dictConfig()API in Betracht ziehen, die besser ist als die bessere fileConfig()Kontrolle über die Konfiguration.

Tatsächlich ist jeder Logger ein untergeordnetes Element des Paketloggers des Elternteils (dh package.subpackage.moduleerbt die Konfiguration von package.subpackage). Sie müssen also nur den Root-Logger konfigurieren. Dies kann erreicht werden durch logging.config.fileConfig(Ihre eigene Konfiguration für Logger) oder logging.basicConfig(legt den Root-Logger fest). . Setup - Protokollierung im Eingabemodul ( __main__.pyoder was auch immer Sie zum Beispiel ausführen will main_script.py. __init__.pyfunktioniert auch)

using basicConfig:

# package/__main__.py
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

using fileConfig:

# package/__main__.py
import logging
import logging.config

logging.config.fileConfig('logging.conf')

und erstellen Sie dann jeden Logger mit:

# package/submodule.py
# or
# package/subpackage/submodule.py
import logging
log = logging.getLogger(__name__)

log.info("Hello logging!")

Weitere Informationen finden Sie im Advanced Logging Tutorial .

Ich mache es immer wie unten.

Verwenden Sie eine einzelne Python-Datei, um mein Protokoll als Singleton-Muster mit dem Namen ' log_conf.py' zu konfigurieren.

#-*-coding:utf-8-*-

import logging.config

def singleton(cls):
    instances = {}
    def get_instance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return get_instance()

@singleton
class Logger():
    def __init__(self):
        logging.config.fileConfig('logging.conf')
        self.logr = logging.getLogger('root')

Importieren Sie in einem anderen Modul einfach die Konfiguration.

from log_conf import Logger

Logger.logr.info("Hello World")

Dies ist ein Singleton-Muster, das einfach und effizient protokolliert werden kann.

Einige dieser Antworten deuten darauf hin, dass Sie sich oben in einem Modul befinden

import logging
logger = logging.getLogger(__name__)

Nach meinem Verständnis wird dies als sehr schlechte Praxis angesehen . Der Grund dafür ist, dass die Dateikonfiguration standardmäßig alle vorhandenen Protokollierer deaktiviert. Z.B

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logger.info('Hi, foo')

class Bar(object):
    def bar(self):
        logger.info('Hi, bar')

Und in Ihrem Hauptmodul:

#main
import logging

# load my module - this now configures the logger
import my_module

# This will now disable the logger in my module by default, [see the docs][1] 
logging.config.fileConfig('logging.ini')

my_module.foo()
bar = my_module.Bar()
bar.bar()

Jetzt ist das in logging.ini angegebene Protokoll leer, da der vorhandene Protokollierer durch den Aufruf von fileconfig deaktiviert wurde.

Es ist zwar möglich, dies zu umgehen (disable_existing_Loggers = False), aber realistischerweise wissen viele Clients Ihrer Bibliothek nichts über dieses Verhalten und erhalten Ihre Protokolle nicht. Machen Sie es Ihren Kunden einfach, indem Sie logging.getLogger immer lokal aufrufen. Hut Tipp: Ich habe von diesem Verhalten auf der Website von Victor Lin erfahren .

Es empfiehlt sich daher, logging.getLogger immer lokal aufzurufen. Z.B

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logging.getLogger(__name__).info('Hi, foo')

class Bar(object):
    def bar(self):
        logging.getLogger(__name__).info('Hi, bar')    

Wenn Sie in Ihrer Hauptdatei fileconfig verwenden, setzen Sie disable_existing_loggers = False, nur für den Fall, dass Ihre Bibliotheksdesigner Logger-Instanzen auf Modulebene verwenden.

Eine einfache Möglichkeit, eine Instanz der Protokollierungsbibliothek in mehreren Modulen zu verwenden, war für mich die folgende Lösung:

base_logger.py

import logging

logger = logging
logger.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)

Andere Dateien

from base_logger import logger

if __name__ == '__main__':
    logger.info("This is an info message")

Eine andere Lösung einwerfen.

In der init .py meines Moduls habe ich so etwas wie:

# mymodule/__init__.py
import logging

def get_module_logger(mod_name):
  logger = logging.getLogger(mod_name)
  handler = logging.StreamHandler()
  formatter = logging.Formatter(
        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
  handler.setFormatter(formatter)
  logger.addHandler(handler)
  logger.setLevel(logging.DEBUG)
  return logger

Dann brauche ich in jedem Modul einen Logger:

# mymodule/foo.py
from [modname] import get_module_logger
logger = get_module_logger(__name__)

Wenn die Protokolle fehlen, können Sie ihre Quelle nach dem Modul unterscheiden, von dem sie stammen.

Sie könnten sich auch so etwas einfallen lassen!

def get_logger(name=None):
    default = "__app__"
    formatter = logging.Formatter('%(levelname)s: %(asctime)s %(funcName)s(%(lineno)d) -- %(message)s',
                              datefmt='%Y-%m-%d %H:%M:%S')
    log_map = {"__app__": "app.log", "__basic_log__": "file1.log", "__advance_log__": "file2.log"}
    if name:
        logger = logging.getLogger(name)
    else:
        logger = logging.getLogger(default)
    fh = logging.FileHandler(log_map[name])
    fh.setFormatter(formatter)
    logger.addHandler(fh)
    logger.setLevel(logging.DEBUG)
    return logger

Jetzt können Sie mehrere Logger in demselben Modul und im gesamten Projekt verwenden, wenn das oben Gesagte in einem separaten Modul definiert und in andere Module importiert wird, in denen eine Protokollierung erforderlich ist.

a=get_logger("__app___")
b=get_logger("__basic_log__")
a.info("Starting logging!")
b.debug("Debug Mode")

@ Yarkees Lösung schien besser. Ich möchte noch etwas hinzufügen -

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances.keys():
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


class LoggerManager(object):
    __metaclass__ = Singleton

    _loggers = {}

    def __init__(self, *args, **kwargs):
        pass

    @staticmethod
    def getLogger(name=None):
        if not name:
            logging.basicConfig()
            return logging.getLogger()
        elif name not in LoggerManager._loggers.keys():
            logging.basicConfig()
            LoggerManager._loggers[name] = logging.getLogger(str(name))
        return LoggerManager._loggers[name]    


log=LoggerManager().getLogger("Hello")
log.setLevel(level=logging.DEBUG)

LoggerManager kann also für die gesamte Anwendung steckbar sein. Hoffe, es macht Sinn und Wert.

Es gibt mehrere Antworten. Am Ende hatte ich eine ähnliche, aber andere Lösung, die für mich Sinn macht. Vielleicht macht sie auch für Sie Sinn. Mein Hauptziel war es, Protokolle nach ihrer Ebene an Handler übergeben zu können (Protokolle auf Debug-Ebene an die Konsole, Warnungen und höher an Dateien):

from flask import Flask
import logging
from logging.handlers import RotatingFileHandler

app = Flask(__name__)

# make default logger output everything to the console
logging.basicConfig(level=logging.DEBUG)

rotating_file_handler = RotatingFileHandler(filename="logs.log")
rotating_file_handler.setLevel(logging.INFO)

app.logger.addHandler(rotating_file_handler)

hat eine nette util-Datei namens logger.py erstellt:

import logging

def get_logger(name):
    return logging.getLogger("flask.app." + name)

Die flask.app ist ein fest codierter Wert in der Flasche. Der Anwendungslogger beginnt immer mit flask.app als Modulnamen.

Jetzt kann ich es in jedem Modul im folgenden Modus verwenden:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Dadurch wird mit minimalem Aufwand ein neues Protokoll für "app.flask.MODULE_NAME" erstellt.

Die beste Vorgehensweise wäre, ein Modul separat zu erstellen, das nur eine Methode enthält, deren Aufgabe es ist, der aufrufenden Methode einen Logger-Handler zuzuweisen. Speichern Sie diese Datei als m_logger.py

import logger, logging

def getlogger():
    # logger
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    # create console handler and set level to debug
    #ch = logging.StreamHandler()
    ch = logging.FileHandler(r'log.txt')
    ch.setLevel(logging.DEBUG)
    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    # add formatter to ch
    ch.setFormatter(formatter)
    # add ch to logger
    logger.addHandler(ch)
    return logger

Rufen Sie jetzt die Methode getlogger () auf, wenn ein Logger-Handler benötigt wird.

from m_logger import getlogger
logger = getlogger()
logger.info('My mssg')

Neu in Python, daher weiß ich nicht, ob dies ratsam ist, aber es funktioniert hervorragend, wenn Boilerplate nicht neu geschrieben wird.

Ihr Projekt muss eine init .py haben, damit es als Modul geladen werden kann

# Put this in your module's __init__.py
import logging.config
import sys

# I used this dictionary test, you would put:
# logging.config.fileConfig('logging.conf')
# The "" entry in loggers is the root logger, tutorials always 
# use "root" but I can't get that to work
logging.config.dictConfig({
    "version": 1,
    "formatters": {
        "default": {
            "format": "%(asctime)s %(levelname)s %(name)s %(message)s"
        },
    },
    "handlers": {
        "console": {
            "level": 'DEBUG',
            "class": "logging.StreamHandler",
            "stream": "ext://sys.stdout"
        }
    },
    "loggers": {
        "": {
            "level": "DEBUG",
            "handlers": ["console"]
        }
    }
})

def logger():
    # Get the name from the caller of this function
    return logging.getLogger(sys._getframe(1).f_globals['__name__'])

sys._getframe(1)Vorschlag kommt von hier

So verwenden Sie Ihren Logger in einer anderen Datei:

from [your module name here] import logger

logger().debug("FOOOOOOOOO!!!")

Vorsichtsmaßnahmen:

1. Sie müssen Ihre Dateien als Module ausführen, sonst import [your module]funktioniert es nicht:
   • python -m [your module name].[your filename without .py]
2. Der Name des Loggers für den Einstiegspunkt Ihres Programms lautet __main__, aber bei jeder verwendeten Lösung tritt __name__dieses Problem auf.