messaggi di log che compaiono due volte con Python Logging

Sto usando la registrazione di Python e, per qualche motivo, tutti i miei messaggi vengono visualizzati due volte.

Ho un modulo per configurare la registrazione:

# BUG: It's outputting logging messages twice - not sure why - it's not the propagate setting.
def configure_logging(self, logging_file):
    self.logger = logging.getLogger("my_logger")
    self.logger.setLevel(logging.DEBUG)
    self.logger.propagate = 0
    # Format for our loglines
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    # Setup console logging
    ch = logging.StreamHandler()
    ch.setLevel(logging.DEBUG)
    ch.setFormatter(formatter)
    self.logger.addHandler(ch)
    # Setup file logging as well
    fh = logging.FileHandler(LOG_FILENAME)
    fh.setLevel(logging.DEBUG)
    fh.setFormatter(formatter)
    self.logger.addHandler(fh)

Successivamente, chiamo questo metodo per configurare la registrazione:

if __name__ == '__main__':
    tom = Boy()
    tom.configure_logging(LOG_FILENAME)
    tom.buy_ham()

E poi, ad esempio, il modulo buy_ham, chiamerei:

self.logger.info('Successfully able to write to %s' % path)

E per qualche motivo, tutti i messaggi vengono visualizzati due volte. Ho commentato uno dei gestori di flusso, sempre la stessa cosa. Un po 'strano, non sono sicuro del motivo per cui sta accadendo ... lol. Supponendo che mi sia perso qualcosa di ovvio.

Salute, Victor

Stai chiamando configure_loggingdue volte (forse nel __init__metodo di Boy): getLoggerrestituirà lo stesso oggetto, ma addHandlernon controlla se un gestore simile è già stato aggiunto al logger.

Prova a tracciare le chiamate a quel metodo ed eliminarne uno. Oppure imposta un flag logging_initializedinizializzato a Falsenel __init__metodo di Boye cambia configure_loggingper non fare nulla se logging_initializedè True, e per impostarlo Truedopo aver inizializzato il logger.

Se il tuo programma crea diverse Boyistanze, dovrai cambiare il modo in cui fai le cose con una configure_loggingfunzione globale che aggiunge i gestori e il Boy.configure_loggingmetodo inizializza solo l' self.loggerattributo.

Un altro modo per risolvere questo problema è controllare l'attributo handlers del tuo logger:

logger = logging.getLogger('my_logger')
if not logger.handlers:
    # create the handlers and call logger.addHandler(logging_handler)

Se stai riscontrando questo problema e non stai aggiungendo il gestore due volte, vedi la risposta di abarnert qui

Dai documenti :

Nota: se colleghi un gestore a un logger e uno o più dei suoi antenati, potrebbe emettere lo stesso record più volte. In generale, non dovresti aver bisogno di collegare un gestore a più di un logger - se lo colleghi semplicemente al logger appropriato che è il più alto nella gerarchia del logger, allora vedrà tutti gli eventi registrati da tutti i logger discendenti, a condizione che la loro propagazione l'impostazione viene lasciata impostata su True. Uno scenario comune è collegare i gestori solo al logger di root e lasciare che la propagazione si occupi del resto.

Quindi, se vuoi un gestore personalizzato su "test" e non vuoi che i suoi messaggi vadano anche al gestore root, la risposta è semplice: disattiva il flag di propagazione:

logger.propagate = False

Il gestore viene aggiunto ogni volta che chiami dall'esterno. Prova a rimuovere il gestore dopo aver terminato il lavoro:

self.logger.removeHandler(ch)

Sono un principiante di Python, ma questo sembrava funzionare per me (Python 2.7)

while logger.handlers:
     logger.handlers.pop()

Nel mio caso dovrei impostare logger.propagate = Falseper evitare la doppia stampa.

Nel codice sottostante, se rimuovi logger.propagate = False, vedrai una doppia stampa.

import logging
from typing import Optional

_logger: Optional[logging.Logger] = None

def get_logger() -> logging.Logger:
    global _logger
    if _logger is None:
        raise RuntimeError('get_logger call made before logger was setup!')
    return _logger

def set_logger(name:str, level=logging.DEBUG) -> None:
    global _logger
    if _logger is not None:
        raise RuntimeError('_logger is already setup!')
    _logger = logging.getLogger(name)
    _logger.handlers.clear()
    _logger.setLevel(level)
    ch = logging.StreamHandler()
    ch.setLevel(level)
    # warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning)
    ch.setFormatter(_get_formatter())
    _logger.addHandler(ch)
    _logger.propagate = False # otherwise root logger prints things again


def _get_formatter() -> logging.Formatter:
    return logging.Formatter(
        '[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s')

Una chiamata alle logging.debug()chiamate logging.basicConfig()se non sono installati gestori root. Ciò stava accadendo per me in un framework di test in cui non potevo controllare l'ordine di attivazione dei test case. Il mio codice di inizializzazione stava installando il secondo. L'impostazione predefinita utilizza logging.BASIC_FORMAT che non volevo.

Sembra che se si invia qualcosa al logger (accidentalmente) e poi lo si configura, è troppo tardi. Ad esempio, nel mio codice avevo

logging.warning("look out)"

...
ch = logging.StreamHandler(sys.stdout)
root = logging.getLogger()
root.addHandler(ch)

root.info("hello")

Otterrei qualcosa del tipo (ignorando le opzioni di formato)

look out
hello
hello

e tutto è stato scritto due volte su stdout. Credo che ciò sia dovuto al fatto che la prima chiamata a logging.warningcrea automaticamente un nuovo gestore, quindi ho aggiunto esplicitamente un altro gestore. Il problema è andato via quando ho rimosso la prima logging.warningchiamata accidentale .

Stavo ottenendo una strana situazione in cui i registri della console erano raddoppiati ma i miei registri dei file non lo erano. Dopo un sacco di scavi ho capito.

Tieni presente che i pacchetti di terze parti possono registrare i logger. Questo è qualcosa a cui prestare attenzione (e in alcuni casi non può essere prevenuto). In molti casi il codice di terze parti controlla se sono presenti root esistenti gestori di logger ; e se non c'è, registrano un nuovo gestore della console.

La mia soluzione a questo era registrare il mio logger della console a livello di root:

rootLogger = logging.getLogger()  # note no text passed in--that's how we grab the root logger
if not rootLogger.handlers:
        ch = logging.StreamHandler()
        ch.setLevel(logging.INFO)
        ch.setFormatter(logging.Formatter('%(process)s|%(levelname)s] %(message)s'))
        rootLogger.addHandler(ch)