stringvar - Hacer que los registradores de Python envíen todos los mensajes a la salida estándar además del archivo de registro

stringvar python 3

Question

¿Hay alguna manera de hacer que el registro de Python utilizando el módulo de logging genere automáticamente las cosas a la salida estándar además del archivo de registro donde se supone que deben ir? Por ejemplo, me gustaría que todas las llamadas a logger.warning , logger.critical , logger.error vayan a sus lugares previstos pero, además, siempre se copien en la logger.critical logger.error . Esto es para evitar la duplicación de mensajes como:

mylogger.critical("something failed")
print "something failed"

Answer 1

Aquí hay una solución basada en la función de configuración dictConfig . En lugar de enviar todos los mensajes de registro a la salida estándar, envía mensajes con un nivel de registro ERROR y superior a stderr y todo lo demás a la salida estándar. Esto puede ser útil si otras partes del sistema están escuchando stderr / stdout.

import logging
import logging.config
import sys
class _ExcludeErrorsFilter(logging.Filter):
def filter(self, record):
"""Filters out log messages with log level ERROR (numeric value: 40) or higher."""
return record.levelno < 40
config = {
''version'': 1,
''filters'': {
''exclude_errors'': {
''()'': _ExcludeErrorsFilter
}
},
''formatters'': {
''my_formatter'': {
''format'': ''(%(process)d) %(asctime)s %(name)s (line %(lineno)s) | %(levelname)s %(message)s''
}
},
''handlers'': {
''console_stderr'': {
# Directs log messages with log level ERROR or higher to stderr
''class'': ''logging.StreamHandler'',
''level'': ''ERROR'',
''formatter'': ''my_formatter'',
''stream'': sys.stderr
},
''console_stdout'': {
# Directs log messages with log level lower than ERROR to stdout
''class'': ''logging.StreamHandler'',
''level'': ''DEBUG'',
''formatter'': ''my_formatter'',
''filters'': [''exclude_errors''],
''stream'': sys.stdout
},
''file'': {
# Directs all log messages to a file
''class'': ''logging.FileHandler'',
''level'': ''DEBUG'',
''formatter'': ''my_formatter'',
''filename'': ''my.log'',
''encoding'': ''utf8''
}
},
''root'': {
''level'': ''NOTSET'',
''handlers'': [''console_stderr'', ''console_stdout'', ''file'']
},
}
logging.config.dictConfig(config)

Answer 2

Es posible usar múltiples manejadores.

import logging
import auxiliary_module
# create logger with ''spam_application''
log = logging.getLogger(''spam_application'')
log.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
formatter = logging.Formatter(''%(asctime)s - %(name)s - %(levelname)s - %(message)s'')
# create file handler which logs even debug messages
fh = logging.FileHandler(''spam.log'')
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
log.addHandler(fh)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)
log.addHandler(ch)
log.info(''creating an instance of auxiliary_module.Auxiliary'')
a = auxiliary_module.Auxiliary()
log.info(''created an instance of auxiliary_module.Auxiliary'')
log.info(''calling auxiliary_module.Auxiliary.do_something'')
a.do_something()
log.info(''finished auxiliary_module.Auxiliary.do_something'')
log.info(''calling auxiliary_module.some_function()'')
auxiliary_module.some_function()
log.info(''done with auxiliary_module.some_function()'')
# remember to close the handlers
for handler in log.handlers:
handler.close()
log.removeFilter(handler)

Consulte: https://docs.python.org/2/howto/logging-cookbook.html

Answer 3

La forma más sencilla de iniciar sesión en un archivo y en stderr:

 import logging
logging.basicConfig(filename="logfile.txt")
stderrLogger=logging.StreamHandler()
stderrLogger.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
logging.getLogger().addHandler(stderrLogger)

Answer 4

La forma más sencilla:

import logging
import sys
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

Answer 5

Puede crear dos controladores para el archivo y la basicConfig y luego crear un registrador con el argumento de los handlers para basicConfig . Podría ser útil si tiene el mismo log_level y formato de salida para ambos controladores:

import logging
import sys
file_handler = logging.FileHandler(filename=''tmp.log'')
stdout_handler = logging.StreamHandler(sys.stdout)
handlers = [file_handler, stdout_handler]
logging.basicConfig(
level=logging.DEBUG,
format=''[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s'',
handlers=handlers
)
logger = logging.getLogger(''LOGGER_NAME'')

Answer 6

Toda la salida de registro es manejada por los manejadores; simplemente agregue un logging.StreamHandler() al registrador raíz.

Este es un ejemplo de configuración de un controlador de flujo (usando stdout lugar del stderr predeterminado) y agregarlo al registrador raíz:

import logging
import sys
root = logging.getLogger()
root.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter(''%(asctime)s - %(name)s - %(levelname)s - %(message)s'')
handler.setFormatter(formatter)
root.addHandler(handler)