idle - lista de comandos python pdf

¿Cómo desactivo y vuelvo a habilitar el registro de la consola en Python?

Question

Estoy usando el módulo de logging de Python y quiero desactivar el registro de la consola por un tiempo, pero no funciona.

#!/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")

El código anterior muestra el "bla bla" en stdout y no sé cómo puedo desactivar de forma segura el controlador de la consola. ¿Cómo puedo estar seguro de que elimino temporalmente el manejador de flujo de la consola y no otro?

Answer 1

(Pregunta largamente muerta, pero para futuros buscadores)

Más cerca del código / intención del cartel original, esto funciona para mí en 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")

El problema que tuve que resolver fue eliminar el controlador de stdout después de agregar uno nuevo; el código del registrador aparece para volver a agregar automáticamente el stdout si no hay controladores presentes.

Answer 2

Administrador de contexto

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

Ejemplo de uso:

with DisableLogger():
do_something()

Answer 3

Aquí hay algunas respuestas muy buenas, pero aparentemente la más simple no se toma demasiado en cuenta (solo desde infinito).

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

Esto desactiva el registrador de raíz y, por lo tanto, todos los demás registradores. Realmente no lo he probado, pero también debería ser el más rápido.

Desde el código de inicio de sesión en Python 2.7 veo esto

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)

Lo que significa que cuando está deshabilitado no se llama a ningún controlador, y debería ser más eficiente filtrar a un valor muy alto o configurar un controlador no operativo, por ejemplo.

Answer 4

Encontré una solución para esto:

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

Esto evitará que el registro se envíe al registrador superior que incluye el registro de la consola.

Answer 5

No conozco muy bien el módulo de registro, pero lo estoy usando de la manera en que generalmente quiero desactivar solo los mensajes de depuración (o información). Puede usar Handler.setLevel() para establecer el nivel de registro en CRITICAL o superior.

Además, puede reemplazar sys.stderr y sys.stdout por un archivo abierto para escribir. Ver http://docs.python.org/library/sys.html#sys.stdout http://docs.python.org/library/sys.html#sys.stdout . Pero no lo recomendaría.

Answer 6

No es necesario desviar la salida estándar. Aquí hay una mejor manera de hacerlo:

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

Una forma aún más simple es:

logging.getLogger().setLevel(100)

Answer 7

Puedes usar:

logging.basicConfig(level=your_level)

donde your_level es uno de esos:

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

Por lo tanto, si establece su_level en logging.CRITICAL , recibirá solo mensajes críticos enviados por:

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

Configurando tu_level para el registro ..DEBUG mostrará todos los niveles de registro.

Para más detalles, eche un vistazo a los ejemplos de registro.

De la misma manera para cambiar el nivel para cada Manejador use la función Handler.setLevel() .

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 8

También podrías:

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

Answer 9

Yo suelo:

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

Answer 10

Para deshabilitar completamente el registro :

logging.disable(sys.maxint)

Para habilitar el registro :

logging.disable(logging.NOTSET)

Otras respuestas proporcionan soluciones que no resuelven completamente el problema, como

logging.getLogger().disabled = True

y, para algunos n mayores de 50,

logging.disable(n)

El problema con la primera solución es que solo funciona para el registrador de raíz. Otros registradores creados usando, digamos, logging.getLogger(__name__) no son deshabilitados por este método.

La segunda solución afecta todos los registros. Pero limita la producción a niveles superiores a los indicados, por lo que se podría anular al iniciar sesión con un nivel superior a 50.

Eso se puede prevenir

logging.disable(sys.maxint)

que por lo que puedo decir (después de revisar la source ) es la única forma de deshabilitar completamente el registro.