Utilizzo della registrazione in più moduli

Ho un piccolo progetto Python che ha la seguente struttura:

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

Ho intenzione di utilizzare il modulo di registrazione predefinito per stampare i messaggi su stdout e un file di registro. Per utilizzare il modulo di registrazione, è necessaria un'inizializzazione:

import logging.config

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

logger.info('testing')

Al momento, eseguo questa inizializzazione in ogni modulo prima di iniziare a registrare i messaggi. È possibile eseguire questa inizializzazione solo una volta in una posizione tale da riutilizzare le stesse impostazioni registrandosi in tutto il progetto?

La migliore pratica è, in ogni modulo, avere un logger definito in questo modo:

import logging
logger = logging.getLogger(__name__)

vicino alla parte superiore del modulo e quindi in un altro codice del modulo, ad es

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

Se è necessario suddividere l'attività di registrazione all'interno di un modulo, utilizzare ad es

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

e accedere a loggerAe loggerB, se del caso.

Nel tuo programma o programmi principali, ad esempio:

def main():
    "your program code"

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

o

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

if __name__ == '__main__':
    main()

Vedere qui per la registrazione da più moduli e qui per la configurazione della registrazione per il codice che verrà utilizzato come modulo di libreria da altro codice.

Aggiornamento: quando chiami fileConfig(), potresti voler specificare disable_existing_loggers=Falsese stai usando Python 2.6 o successivo (vedi i documenti per maggiori informazioni). Il valore predefinito è Trueper la compatibilità con le versioni precedenti, che causa la disabilitazione di tutti i logger esistenti a fileConfig()meno che loro o il loro antenato non siano esplicitamente nominati nella configurazione. Con il valore impostato su False, i logger esistenti vengono lasciati soli. Se si utilizza Python 2.7 / Python 3.2 o versioni successive, è consigliabile prendere in considerazione l' dictConfig()API, che è migliore rispetto fileConfig()a quando offre un maggiore controllo sulla configurazione.

In realtà ogni logger è figlio del logger dei pacchetti del genitore (ovvero package.subpackage.moduleeredita la configurazione da package.subpackage), quindi tutto ciò che devi fare è solo configurare il logger di root. Ciò può essere ottenuto da logging.config.fileConfig(la tua configurazione per i logger) o logging.basicConfig(imposta il logger di root) . Setup logging nel tuo modulo di accesso ( __main__.pyo qualunque cosa tu voglia eseguire, per esempio main_script.py. __init__.pyFunziona anche)

utilizzando basicConfig:

# package/__main__.py
import logging
import sys

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

utilizzando fileConfig:

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

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

e quindi creare ogni logger usando:

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

log.info("Hello logging!")

Per ulteriori informazioni, consultare Tutorial per la registrazione avanzata .

Lo faccio sempre come di seguito.

Usa un singolo file Python per configurare il mio registro come modello singleton che si chiama ' log_conf.py'

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

In un altro modulo, basta importare la configurazione.

from log_conf import Logger

Logger.logr.info("Hello World")

Questo è un modello singleton per registrare, in modo semplice ed efficiente.

Molte di queste risposte suggeriscono che nella parte superiore di un modulo lo fai

import logging
logger = logging.getLogger(__name__)

Comprendo che questa è considerata una cattiva pratica . Il motivo è che la configurazione del file disabiliterà tutti i logger esistenti per impostazione predefinita. Per esempio

#my_module
import logging

logger = logging.getLogger(__name__)

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

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

E nel tuo modulo principale:

#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()

Ora il registro specificato in logging.ini sarà vuoto, poiché il logger esistente è stato disabilitato dalla chiamata fileconfig.

Mentre è certamente possibile aggirare questo (disable_existing_Loggers = False), realisticamente molti client della tua libreria non conosceranno questo comportamento e non riceveranno i tuoi log. Semplifica i tuoi clienti chiamando sempre logging.getLogger localmente. Suggerimento per il cappello: ho imparato questo comportamento dal sito Web di Victor Lin .

Pertanto, è buona norma chiamare sempre logging.getLogger localmente. Per esempio

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

Inoltre, se si utilizza fileconfig nel proprio main, impostare disable_existing_loggers = False, nel caso in cui i progettisti della libreria utilizzino le istanze del logger a livello di modulo.

Per me un modo semplice di utilizzare un'istanza di registrazione della libreria in più moduli era la seguente soluzione:

base_logger.py

import logging

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

Altri file

from base_logger import logger

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

Lancio in un'altra soluzione.

In init .py del mio modulo ho qualcosa del tipo:

# 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

Quindi in ogni modulo ho bisogno di un logger, faccio:

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

Quando mancano i registri, è possibile differenziare la loro origine dal modulo da cui provengono.

Potresti anche inventarti qualcosa del genere!

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

Ora è possibile utilizzare più logger nello stesso modulo e nell'intero progetto se quanto sopra è definito in un modulo separato e importato in altri moduli in cui è richiesta la registrazione.

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

@ La soluzione di Yarkee sembrava migliore. Vorrei aggiungere qualcosa in più -

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)

Quindi LoggerManager può essere collegabile a tutta l'applicazione. Spero abbia senso e valore.

Ci sono diverse risposte ho finito con una soluzione simile ma diversa che ha senso per me, forse avrà senso anche per te. Il mio obiettivo principale era quello di essere in grado di passare i registri ai gestori in base al loro livello (registri di livello di debug alla console, avvisi e soprattutto ai file):

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)

creato un bel file util chiamato logger.py:

import logging

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

flask.app è un valore hardcoded in flask. il logger dell'applicazione inizia sempre con flask.app come nome del modulo.

ora, in ogni modulo, sono in grado di usarlo nella seguente modalità:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Ciò creerà un nuovo registro per "app.flask.MODULE_NAME" con il minimo sforzo.

La migliore pratica sarebbe quella di creare un modulo separatamente che ha un solo metodo il cui compito è quello di dare un gestore logger al metodo chiamante. Salva questo file come 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

Ora chiama il metodo getlogger () ogni volta che è necessario il gestore del logger.

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

Nuovo su Python, quindi non so se questo sia consigliabile, ma funziona benissimo per non riscrivere il boilerplate.

Il tuo progetto deve avere un init .py in modo che possa essere caricato come modulo

# 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)il suggerimento viene da qui

Quindi per usare il tuo logger in qualsiasi altro file:

from [your module name here] import logger

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

Avvertenze:

1. È necessario eseguire i file come moduli, altrimenti import [your module]non funzionerà:
   • python -m [your module name].[your filename without .py]
2. Il nome del logger per il punto di ingresso del programma sarà __main__, ma qualsiasi soluzione che utilizza __name__avrà quel problema.