Come disabilitare e riattivare la registrazione della console in Python?

Question

Sto usando il modulo python logging e voglio disabilitare la registrazione della console per un po 'di tempo ma non funziona.

    #!/usr/bin/python 
    import logging 

    logger = logging.getLogger() # this gets the root logger 
    # ... here I add my own handlers 
    #logger.removeHandler(sys.stdout) 
    #logger.removeHandler(sys.stderr) 

    print logging.handlers 
    # this will print [<logging.StreamHandler instance at ...>] 
    # but I may have other handlers there that I want to keep 

    logger.debug("bla bla") 

Il codice di cui sopra mostra il "bla bla", a stdout e non so come posso tranquillamente disabilitare il gestore console. Come posso essere sicuro di rimuovere temporaneamente lo streamhandler della console e non un altro?

Answer 1

ho trovato una soluzione per questo:

logger = logging.getLogger('my-logger') 
logger.propagate = False 
# now if you use logger it will not log to console. 

Questo consentirà di evitare la registrazione di essere inviare al logger superiore che include la registrazione della console.

Answer 2

Non conosco il modulo di registrazione molto bene, ma lo sto utilizzando nel modo in cui di solito desidero disabilitare solo i messaggi di debug (o informazioni). È possibile utilizzare Handler.setLevel() per impostare il livello di registrazione su CRITICO o superiore.

Inoltre, è possibile sostituire sys.stderr e sys.stdout con un file aperto per la scrittura. Vedi http://docs.python.org/library/sys.html#sys.stdout. Ma non lo consiglierei.

Answer 3

Non è necessario deviare lo stdout. Qui è migliore modo per farlo:

import logging 
class MyLogHandler(logging.Handler): 
    def emit(self, record): 
     pass 

logging.getLogger().addHandler(MyLogHandler()) 

Un modo ancora più semplice è:

logging.getLogger().setLevel(100) 

Answer 4

è possibile utilizzare:

logging.basicConfig(level=your_level) 

dove your_level è uno di quelli:

 'debug': logging.DEBUG, 
     'info': logging.INFO, 
     'warning': logging.WARNING, 
     'error': logging.ERROR, 
     'critical': logging.CRITICAL 

Quindi, se si imposta your_level a logging.CRITICAL, si otterrà solo messaggi critici inviati da:

logging.critical('This is a critical error message') 

Impostazione your_level a logging.DEBUG mostrerà tutti i livelli di registrazione.

Per ulteriori informazioni, si prega di dare un'occhiata a logging examples.

Allo stesso modo per modificare il livello per ogni Handler utilizzare Handler.setLevel() funzione.

import logging 
import logging.handlers 

LOG_FILENAME = '/tmp/logging_rotatingfile_example.out' 

# Set up a specific logger with our desired output level 
my_logger = logging.getLogger('MyLogger') 
my_logger.setLevel(logging.DEBUG) 

# Add the log message handler to the logger 
handler = logging.handlers.RotatingFileHandler(
      LOG_FILENAME, maxBytes=20, backupCount=5) 

handler.setLevel(logging.CRITICAL) 

my_logger.addHandler(handler) 

Answer 5

io uso:

logger = logging.getLogger() 
logger.disabled = True 
... whatever you want ... 
logger.disabled = False 

Answer 6

(domanda morto da tempo, ma per i ricercatori futuri)

Più vicino a codice/intento del manifesto originale, questo funziona per me sotto python 2.6

#!/usr/bin/python 
import logging 

logger = logging.getLogger() # this gets the root logger 

lhStdout = logger.handlers[0] # stdout is the only handler initially 

# ... here I add my own handlers 
f = open("/tmp/debug","w")   # example handler 
lh = logging.StreamHandler(f) 
logger.addHandler(lh) 

logger.removeHandler(lhStdout) 

logger.debug("bla bla") 

Il Gotcha ho dovuto lavorare fuori è stato quello di rimuovere il gestore stdout dopo l'aggiunta di una nuova; il codice logger sembra riaggiungere automaticamente lo stdout se non sono presenti gestori.

Answer 7

Ci sono alcune risposte davvero belle qui, ma a quanto pare il più semplice non è preso troppo in considerazione (solo da infinito).

root_logger = logging.getLogger() 
root_logger.disabled = True 

Disabilita il logger root e quindi tutti gli altri logger. Non ho ancora provato, ma dovrebbe essere anche il più veloce.

Dal codice di registrazione in python 2.7 Vedo questo

def handle(self, record): 
    """ 
    Call the handlers for the specified record. 

    This method is used for unpickled records received from a socket, as 
    well as those created locally. Logger-level filtering is applied. 
    """ 
    if (not self.disabled) and self.filter(record): 
     self.callHandlers(record) 

Il che significa che quando è disattivata alcun gestore si chiama, e dovrebbe essere più efficiente che il filtraggio ad un valore molto elevato o l'impostazione di una no- op handler per esempio.

Answer 8

Contesto direttore

import logging 
class DisableLogger(): 
    def __enter__(self): 
     logging.disable(logging.CRITICAL) 
    def __exit__(self, a, b, c): 
     logging.disable(logging.NOTSET) 

Esempio di utilizzo:

with DisableLogger(): 
    do_something() 

Answer 9

Si potrebbe anche:

handlers = app.logger.handlers 
# detach console handler 
app.logger.handlers = [] 
# attach 
app.logger.handlers = handlers 

Answer 10

Per disattivare completamente la registrazione:

logging.disable(sys.maxint) 

Per attivare la registrazione:

logging.disable(logging.NOTSET) 

---

Altre risposte fornire arounds di lavoro che non risolvono completamente il problema, come ad esempio

logging.getLogger().disabled = True 

e, per un po 'più grande di n 50,

logging.disable(n) 

Il problema con la prima soluzione è che funziona solo per il root logger. Altri logger creati usando, per esempio, logging.getLogger(__name__) non sono disabilitati con questo metodo.

La seconda soluzione ha effetto su tutti i registri. Ma limita uscita a livelli superiori a quella data, così si potrebbe ignorare che accedendo con un livello superiore a 50.

che possono essere prevenute da

logging.disable(sys.maxint) 

che, per quanto posso dire (dopo aver esaminato il source) è l'unico modo per disabilitare completamente la registrazione.