Je ne peux pas comprendre comment enregistrer les messages de niveau info sur stdout, mais tout le reste sur stderr. J'ai déjà lu ceci http://docs.python.org/library/logging.html . Toute suggestion?
Le script suivant, log1.py
:
import logging, sys
class SingleLevelFilter(logging.Filter):
def __init__(self, passlevel, reject):
self.passlevel = passlevel
self.reject = reject
def filter(self, record):
if self.reject:
return (record.levelno != self.passlevel)
else:
return (record.levelno == self.passlevel)
h1 = logging.StreamHandler(sys.stdout)
f1 = SingleLevelFilter(logging.INFO, False)
h1.addFilter(f1)
rootLogger = logging.getLogger()
rootLogger.addHandler(h1)
h2 = logging.StreamHandler(sys.stderr)
f2 = SingleLevelFilter(logging.INFO, True)
h2.addFilter(f2)
rootLogger.addHandler(h2)
logger = logging.getLogger("my.logger")
logger.setLevel(logging.DEBUG)
logger.debug("A DEBUG message")
logger.info("An INFO message")
logger.warning("A WARNING message")
logger.error("An ERROR message")
logger.critical("A CRITICAL message")
lors de l'exécution, produit les résultats suivants.
C:\temp> log1.py Un message DEBUG Un message INFO Un message WARNING Un message ERROR Un message CRITIQUE
Comme vous vous en doutez, puisque sur un terminal sys.stdout
et sys.stderr
sont identiques. Maintenant, redirige stdout vers un fichier, tmp
:
C:\temp> log1.py> tmp Un message DEBUG Un message WARNING Un message ERROR Un message CRITICAL
Le message INFO n'a donc pas été imprimé sur le terminal, mais les messages dirigés vers sys.stderr
ont ont été imprimés. Voyons ce qu'il y a dans tmp
:
C:\temp> tapez tmp Un message INFO
Cette approche semble donc faire ce que vous voulez.
En général, je pense qu'il est logique de rediriger les messages inférieurs à WARNING
vers stdout , au lieu de seulement INFO
messages.
Sur la base de l'excellente réponse de Vinay Sajip , j'ai trouvé ceci:
class MaxLevelFilter(Filter):
'''Filters (lets through) all messages with level < LEVEL'''
def __init__(self, level):
self.level = level
def filter(self, record):
return record.levelno < self.level # "<" instead of "<=": since logger.setLevel is inclusive, this should be exclusive
MIN_LEVEL= DEBUG
#...
stdout_hdlr = StreamHandler(sys.stdout)
stderr_hdlr = StreamHandler(sys.stderr)
lower_than_warning= MaxLevelFilter(WARNING)
stdout_hdlr.addFilter( lower_than_warning ) #messages lower than WARNING go to stdout
stdout_hdlr.setLevel( MIN_LEVEL )
stderr_hdlr.setLevel( max(MIN_LEVEL, WARNING) ) #messages >= WARNING ( and >= STDOUT_LOG_LEVEL ) go to stderr
#...
Puisque ma modification a été rejetée, voici ma réponse. La réponse de @ goncalopp est bonne mais n'est pas autonome ou ne fonctionne pas immédiatement. Voici ma version améliorée:
import sys, logging
class LogFilter(logging.Filter):
"""Filters (lets through) all messages with level < LEVEL"""
# http://stackoverflow.com/a/24956305/408556
def __init__(self, level):
self.level = level
def filter(self, record):
# "<" instead of "<=": since logger.setLevel is inclusive, this should
# be exclusive
return record.levelno < self.level
MIN_LEVEL = logging.DEBUG
stdout_hdlr = logging.StreamHandler(sys.stdout)
stderr_hdlr = logging.StreamHandler(sys.stderr)
log_filter = LogFilter(logging.WARNING)
stdout_hdlr.addFilter(log_filter)
stdout_hdlr.setLevel(MIN_LEVEL)
stderr_hdlr.setLevel(max(MIN_LEVEL, logging.WARNING))
# messages lower than WARNING go to stdout
# messages >= WARNING (and >= STDOUT_LOG_LEVEL) go to stderr
rootLogger = logging.getLogger()
rootLogger.addHandler(stdout_hdlr)
rootLogger.addHandler(stderr_hdlr)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# Example Usage
>>> logger.debug("A DEBUG message")
>>> logger.info("An INFO message")
>>> logger.warning("A WARNING message")
>>> logger.error("An ERROR message")
>>> logger.critical("A CRITICAL message")
Essayez ce patch de singe ~~
import sys
import logging
import threading
def _logging_handle(self, record):
self.STREAM_LOCKER = getattr(self, "STREAM_LOCKER", threading.RLock())
if self.stream in (sys.stdout, sys.stderr) and record.levelname in self.FIX_LEVELS:
try:
self.STREAM_LOCKER.acquire()
self.stream = sys.stdout
self.old_handle(record)
self.stream = sys.stderr
finally:
self.STREAM_LOCKER.release()
else:
self.old_handle(record)
def patch_logging_stream(*levels):
"""
writing some logging level message to sys.stdout
example:
patch_logging_stream(logging.INFO, logging.DEBUG)
logging.getLogger('root').setLevel(logging.DEBUG)
logging.getLogger('root').debug('test stdout')
logging.getLogger('root').error('test stderr')
"""
stream_handler = logging.StreamHandler
levels = levels or [logging.DEBUG, logging.INFO]
stream_handler.FIX_LEVELS = [logging.getLevelName(i) for i in levels]
if hasattr(stream_handler, "old_handle"):
stream_handler.handle = stream_handler.old_handle
stream_handler.old_handle = stream_handler.handle
stream_handler.handle = _logging_handle
Tester
#
patch_logging_stream(logging.INFO, logging.DEBUG)
logging.getLogger('root').setLevel(logging.DEBUG)
logging.getLogger('root').debug('test root stdout')
logging.getLogger('root').error('test root stderr')
Sortie de test
$ python3 test_patch_logging.py 2>/dev/null
DEBUG:root:test root stdout
$ python3 test_patch_logging.py 1>/dev/null
ERROR:root:test root stderr
Gestionnaire le plus simple pour envoyer une sortie colorée à stderr:
class ColorStderr(logging.StreamHandler):
def __init__(self):
class AddColor(logging.Formatter):
def format(self, record: logging.LogRecord):
msg = super().format(record)
# Green/Cyan/Yellow/Red/Redder based on log level:
color = '\033[1;' + ('32m', '36m', '33m', '31m', '41m')[
min(4,int(4 * record.levelno / logging.FATAL))]
return color + record.levelname + '\033[1;0m: ' + msg
super().__init__(sys.stderr)
self.setFormatter(AddColor())
Utiliser avec:
logging.basicConfig(level=logging.INFO, handlers=[ColorStderr()])
Ou vous pouvez même appliquer le formateur directement au gestionnaire de journaux actuel, sans avoir besoin de ColorStderr
:
logging.getLogger().handlers[0].setFormatter(AddColor())