Come aggiungere un loglevel personalizzato alla funzione di registrazione di Python

Vorrei avere loglevel TRACE (5) per la mia applicazione, poiché non credo debug()sia sufficiente. Inoltre log(5, msg)non è quello che voglio. Come posso aggiungere un loglevel personalizzato a un logger Python?

Ho un mylogger.pycon il seguente contenuto:

import logging

@property
def log(obj):
    myLogger = logging.getLogger(obj.__class__.__name__)
    return myLogger

Nel mio codice lo uso nel modo seguente:

class ExampleClass(object):
    from mylogger import log

    def __init__(self):
        '''The constructor with the logger'''
        self.log.debug("Init runs")

Adesso vorrei chiamare self.log.trace("foo bar")

Grazie in anticipo per il vostro aiuto.

Modifica (8 dicembre 2016): ho cambiato la risposta accettata in pfa che è, IMHO, un'ottima soluzione basata sull'ottima proposta di Eric S.

@Eric S.

La risposta di Eric S. è eccellente, ma ho imparato dalla sperimentazione che ciò causerà sempre la stampa dei messaggi registrati al nuovo livello di debug, indipendentemente da ciò su cui è impostato il livello di log. Quindi, se si crea un nuovo numero di livello 9, se si chiama setLevel(50), i messaggi di livello inferiore verranno stampati erroneamente.

Per evitare che ciò accada, è necessaria un'altra riga all'interno della funzione "debugv" per verificare se il livello di registrazione in questione è effettivamente abilitato.

Esempio corretto che controlla se il livello di registrazione è abilitato:

import logging
DEBUG_LEVELV_NUM = 9 
logging.addLevelName(DEBUG_LEVELV_NUM, "DEBUGV")
def debugv(self, message, *args, **kws):
    if self.isEnabledFor(DEBUG_LEVELV_NUM):
        # Yes, logger takes its '*args' as 'args'.
        self._log(DEBUG_LEVELV_NUM, message, args, **kws) 
logging.Logger.debugv = debugv

Se si guarda il codice per class Loggerin logging.__init__.pyper Python 2.7, questo è ciò che tutte le funzioni di protocollo standard di do (.critical, .debug, etc.).

Apparentemente non posso pubblicare risposte alle risposte degli altri per mancanza di reputazione ... spero che Eric aggiorni il suo post se lo vede. =)

Ho preso la risposta "evita di vedere lambda" e ho dovuto modificare il punto in cui veniva aggiunto log_at_my_log_level. Anch'io ho visto il problema che Paul ha fatto "Non penso che funzioni. Non hai bisogno di logger come primo argomento in log_at_my_log_level?" Questo ha funzionato per me

import logging
DEBUG_LEVELV_NUM = 9 
logging.addLevelName(DEBUG_LEVELV_NUM, "DEBUGV")
def debugv(self, message, *args, **kws):
    # Yes, logger takes its '*args' as 'args'.
    self._log(DEBUG_LEVELV_NUM, message, args, **kws) 
logging.Logger.debugv = debugv

Combinando tutte le risposte esistenti con un sacco di esperienza di utilizzo, penso di aver escogitato un elenco di tutte le cose che devono essere fatte per garantire un utilizzo completo del nuovo livello. I passaggi seguenti presuppongono che tu stia aggiungendo un nuovo livello TRACEcon valore logging.DEBUG - 5 == 5:

1. logging.addLevelName(logging.DEBUG - 5, 'TRACE') deve essere invocato per ottenere il nuovo livello registrato internamente in modo che possa essere referenziato per nome.
2. Il nuovo livello deve essere aggiunto come attributo loggingse stesso per consistenza: logging.TRACE = logging.DEBUG - 5.
3. Un metodo chiamato tracedeve essere aggiunto al loggingmodulo. Si dovrebbe comportarsi proprio come debug, infoecc
4. Un metodo chiamato tracedeve essere aggiunto alla classe logger attualmente configurata. Poiché non è garantito al 100% logging.Logger, usa logging.getLoggerClass()invece.

Tutti i passaggi sono illustrati nel metodo seguente:

def addLoggingLevel(levelName, levelNum, methodName=None):
    """
    Comprehensively adds a new logging level to the `logging` module and the
    currently configured logging class.

    `levelName` becomes an attribute of the `logging` module with the value
    `levelNum`. `methodName` becomes a convenience method for both `logging`
    itself and the class returned by `logging.getLoggerClass()` (usually just
    `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is
    used.

    To avoid accidental clobberings of existing attributes, this method will
    raise an `AttributeError` if the level name is already an attribute of the
    `logging` module or if the method name is already present 

    Example
    -------
    >>> addLoggingLevel('TRACE', logging.DEBUG - 5)
    >>> logging.getLogger(__name__).setLevel("TRACE")
    >>> logging.getLogger(__name__).trace('that worked')
    >>> logging.trace('so did this')
    >>> logging.TRACE
    5

    """
    if not methodName:
        methodName = levelName.lower()

    if hasattr(logging, levelName):
       raise AttributeError('{} already defined in logging module'.format(levelName))
    if hasattr(logging, methodName):
       raise AttributeError('{} already defined in logging module'.format(methodName))
    if hasattr(logging.getLoggerClass(), methodName):
       raise AttributeError('{} already defined in logger class'.format(methodName))

    # This method was inspired by the answers to Stack Overflow post
    # http://stackoverflow.com/q/2183233/2988730, especially
    # http://stackoverflow.com/a/13638084/2988730
    def logForLevel(self, message, *args, **kwargs):
        if self.isEnabledFor(levelNum):
            self._log(levelNum, message, args, **kwargs)
    def logToRoot(message, *args, **kwargs):
        logging.log(levelNum, message, *args, **kwargs)

    logging.addLevelName(levelNum, levelName)
    setattr(logging, levelName, levelNum)
    setattr(logging.getLoggerClass(), methodName, logForLevel)
    setattr(logging, methodName, logToRoot)

Questa domanda è piuttosto vecchia, ma ho appena affrontato lo stesso argomento e ho trovato un modo simile a quelli già citati che mi sembra un po 'più pulito. Questo è stato testato su 3.4, quindi non sono sicuro che i metodi utilizzati esistano nelle versioni precedenti:

from logging import getLoggerClass, addLevelName, setLoggerClass, NOTSET

VERBOSE = 5

class MyLogger(getLoggerClass()):
    def __init__(self, name, level=NOTSET):
        super().__init__(name, level)

        addLevelName(VERBOSE, "VERBOSE")

    def verbose(self, msg, *args, **kwargs):
        if self.isEnabledFor(VERBOSE):
            self._log(VERBOSE, msg, args, **kwargs)

setLoggerClass(MyLogger)

Chi ha iniziato la cattiva pratica di utilizzare metodi interni ( self._log) e perché ogni risposta è basata su questo ?! La soluzione pitonica sarebbe quella di usare self.loginvece in modo da non dover pasticciare con nessuna roba interna:

import logging

SUBDEBUG = 5
logging.addLevelName(SUBDEBUG, 'SUBDEBUG')

def subdebug(self, message, *args, **kws):
    self.log(SUBDEBUG, message, *args, **kws) 
logging.Logger.subdebug = subdebug

logging.basicConfig()
l = logging.getLogger()
l.setLevel(SUBDEBUG)
l.subdebug('test')
l.setLevel(logging.DEBUG)
l.subdebug('test')

Trovo più semplice creare un nuovo attributo per l'oggetto logger che passa la funzione log (). Penso che il modulo logger fornisca addLevelName () e log () proprio per questo motivo. Quindi non sono necessarie sottoclassi o nuovi metodi.

import logging

@property
def log(obj):
    logging.addLevelName(5, 'TRACE')
    myLogger = logging.getLogger(obj.__class__.__name__)
    setattr(myLogger, 'trace', lambda *args: myLogger.log(5, *args))
    return myLogger

adesso

mylogger.trace('This is a trace message')

dovrebbe funzionare come previsto.

Anche se abbiamo già molte risposte corrette, il seguente è secondo me più pitonico:

import logging

from functools import partial, partialmethod

logging.TRACE = 5
logging.addLevelName(logging.TRACE, 'TRACE')
logging.Logger.trace = partialmethod(logging.Logger.log, logging.TRACE)
logging.trace = partial(logging.log, logging.TRACE)

Se si desidera utilizzare mypysul codice, si consiglia di aggiungere # type: ignoreper eliminare gli avvisi dall'aggiunta di attributi.

Penso che dovrai sottoclassare la Loggerclasse e aggiungere un metodo chiamato traceche sostanzialmente chiama Logger.logcon un livello inferiore a DEBUG. Non l'ho provato, ma questo è ciò che indicano i documenti .

Suggerimenti per la creazione di un logger personalizzato:

1. Non usare _log, usa log(non devi controllare isEnabledFor)
2. il modulo di registrazione dovrebbe essere quello che crea l'istanza del logger personalizzato poiché fa un po 'di magia getLogger, quindi dovrai impostare la classe tramitesetLoggerClass
3. Non è necessario definire __init__per il logger, class se non si memorizza nulla

# Lower than debug which is 10
TRACE = 5
class MyLogger(logging.Logger):
    def trace(self, msg, *args, **kwargs):
        self.log(TRACE, msg, *args, **kwargs)

Quando si chiama questo logger, usare setLoggerClass(MyLogger)per renderlo il logger predefinito dagetLogger

logging.setLoggerClass(MyLogger)
log = logging.getLogger(__name__)
# ...
log.trace("something specific")

Avrai bisogno di setFormatter, setHandlere setLevel(TRACE)su handlere su logse stesso per vedere effettivamente questa traccia di basso livello

Questo ha funzionato per me:

import logging
logging.basicConfig(
    format='  %(levelname)-8.8s %(funcName)s: %(message)s',
)
logging.NOTE = 32  # positive yet important
logging.addLevelName(logging.NOTE, 'NOTE')      # new level
logging.addLevelName(logging.CRITICAL, 'FATAL') # rename existing

log = logging.getLogger(__name__)
log.note = lambda msg, *args: log._log(logging.NOTE, msg, args)
log.note('school\'s out for summer! %s', 'dude')
log.fatal('file not found.')

Il problema lambda / funcName è stato risolto con logger._log come sottolineato da @marqueed. Penso che l'uso di lambda sembri un po 'più pulito, ma lo svantaggio è che non può accettare argomenti di parole chiave. Non l'ho mai usato io stesso, quindi nessun problema.

  NOTA setup: la scuola è finita per l'estate! tipo
  Installazione FATALE: file non trovato.

Nella mia esperienza, questa è la soluzione completa del problema dell'operazione ... per evitare di vedere "lambda" come la funzione in cui viene emesso il messaggio, vai più a fondo:

MY_LEVEL_NUM = 25
logging.addLevelName(MY_LEVEL_NUM, "MY_LEVEL_NAME")
def log_at_my_log_level(self, message, *args, **kws):
    # Yes, logger takes its '*args' as 'args'.
    self._log(MY_LEVEL_NUM, message, args, **kws)
logger.log_at_my_log_level = log_at_my_log_level

Non ho mai provato a lavorare con una classe logger autonoma, ma penso che l'idea di base sia la stessa (usa _log).

Aggiunta all'esempio di Mad Physicists per ottenere il nome del file e il numero di riga corretti:

def logToRoot(message, *args, **kwargs):
    if logging.root.isEnabledFor(levelNum):
        logging.root._log(levelNum, message, args, **kwargs)

basato sulla risposta appuntata, ho scritto un piccolo metodo che crea automaticamente nuovi livelli di registrazione

def set_custom_logging_levels(config={}):
    """
        Assign custom levels for logging
            config: is a dict, like
            {
                'EVENT_NAME': EVENT_LEVEL_NUM,
            }
        EVENT_LEVEL_NUM can't be like already has logging module
        logging.DEBUG       = 10
        logging.INFO        = 20
        logging.WARNING     = 30
        logging.ERROR       = 40
        logging.CRITICAL    = 50
    """
    assert isinstance(config, dict), "Configuration must be a dict"

    def get_level_func(level_name, level_num):
        def _blank(self, message, *args, **kws):
            if self.isEnabledFor(level_num):
                # Yes, logger takes its '*args' as 'args'.
                self._log(level_num, message, args, **kws) 
        _blank.__name__ = level_name.lower()
        return _blank

    for level_name, level_num in config.items():
        logging.addLevelName(level_num, level_name.upper())
        setattr(logging.Logger, level_name.lower(), get_level_func(level_name, level_num))

config potrebbe essere così:

new_log_levels = {
    # level_num is in logging.INFO section, that's why it 21, 22, etc..
    "FOO":      21,
    "BAR":      22,
}

In alternativa all'aggiunta di un metodo extra alla classe Logger, consiglierei di utilizzare il Logger.log(level, msg)metodo.

import logging

TRACE = 5
logging.addLevelName(TRACE, 'TRACE')
FORMAT = '%(levelname)s:%(name)s:%(lineno)d:%(message)s'


logging.basicConfig(format=FORMAT)
l = logging.getLogger()
l.setLevel(TRACE)
l.log(TRACE, 'trace message')
l.setLevel(logging.DEBUG)
l.log(TRACE, 'disabled trace message')

Non ho capito bene; con python 3.5, almeno, funziona:

import logging


TRACE = 5
"""more detail than debug"""

logging.basicConfig()
logging.addLevelName(TRACE,"TRACE")
logger = logging.getLogger('')
logger.debug("n")
logger.setLevel(logging.DEBUG)
logger.debug("y1")
logger.log(TRACE,"n")
logger.setLevel(TRACE)
logger.log(TRACE,"y2")
    

produzione:

DEBUG: root: y1

TRACE: root: y2

Nel caso in cui qualcuno desideri un modo automatizzato per aggiungere un nuovo livello di registrazione al modulo di registrazione (o una copia di esso) dinamicamente, ho creato questa funzione, espandendo la risposta di @ pfa:

def add_level(log_name,custom_log_module=None,log_num=None,
                log_call=None,
                   lower_than=None, higher_than=None, same_as=None,
              verbose=True):
    '''
    Function to dynamically add a new log level to a given custom logging module.
    <custom_log_module>: the logging module. If not provided, then a copy of
        <logging> module is used
    <log_name>: the logging level name
    <log_num>: the logging level num. If not provided, then function checks
        <lower_than>,<higher_than> and <same_as>, at the order mentioned.
        One of those three parameters must hold a string of an already existent
        logging level name.
    In case a level is overwritten and <verbose> is True, then a message in WARNING
        level of the custom logging module is established.
    '''
    if custom_log_module is None:
        import imp
        custom_log_module = imp.load_module('custom_log_module',
                                            *imp.find_module('logging'))
    log_name = log_name.upper()
    def cust_log(par, message, *args, **kws):
        # Yes, logger takes its '*args' as 'args'.
        if par.isEnabledFor(log_num):
            par._log(log_num, message, args, **kws)
    available_level_nums = [key for key in custom_log_module._levelNames
                            if isinstance(key,int)]

    available_levels = {key:custom_log_module._levelNames[key]
                             for key in custom_log_module._levelNames
                            if isinstance(key,str)}
    if log_num is None:
        try:
            if lower_than is not None:
                log_num = available_levels[lower_than]-1
            elif higher_than is not None:
                log_num = available_levels[higher_than]+1
            elif same_as is not None:
                log_num = available_levels[higher_than]
            else:
                raise Exception('Infomation about the '+
                                'log_num should be provided')
        except KeyError:
            raise Exception('Non existent logging level name')
    if log_num in available_level_nums and verbose:
        custom_log_module.warn('Changing ' +
                                  custom_log_module._levelNames[log_num] +
                                  ' to '+log_name)
    custom_log_module.addLevelName(log_num, log_name)

    if log_call is None:
        log_call = log_name.lower()

    setattr(custom_log_module.Logger, log_call, cust_log)
    return custom_log_module