Günlük dosyasına ek olarak Python kaydedicilerinin tüm iletileri stdout'a çıkarması

loggingModülü kullanarak Python günlüğü otomatik olarak stdout şeyler çıktı gitmek için gereken günlük dosyasına ek yapmak için bir yolu var mı ? Örneğin, ben tüm aramaları istiyorum logger.warning, logger.critical, logger.errorhedeflenen yerlere gitmek ama ek olarak daima kopyalanabilir stdout. Bu, aşağıdaki gibi mesajların kopyalanmasını önlemek içindir:

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

Tüm günlük çıktıları işleyiciler tarafından işlenir; sadece logging.StreamHandler()kök kaydediciye a ekleyin .

Akış işleyicisini yapılandırmak ( stdoutvarsayılan yerine kullanmak stderr) ve kök kaydediciye eklemek için bir örnek :

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)

Stdout'a giriş yapmanın en basit yolu:

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

Birden fazla işleyici kullanmak mümkündür.

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)

Lütfen bakınız: https://docs.python.org/2/howto/logging-cookbook.html

Dosya ve stdout için iki işleyici oluşturabilir ve sonra handlersargümanıyla bir günlükçü oluşturabilirsiniz basicConfig. Her iki işleyici için aynı log_level ve format çıktısına sahipseniz yararlı olabilir:

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')

Dosyaya ve stderr'e giriş yapmanın en basit yolu:

import logging

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

İşte güçlü ancak zayıf belgelenmiş logging.config.dictConfigyönteme dayanan bir çözüm . Her günlük iletisini göndermek yerine, stdoutgünlük düzeyi ERRORve daha yüksek olan iletileri stderrve diğer her şeyi gönderir stdout. Sistemin diğer bölümleri dinliyorsa stderrveya bu yararlı olabilir 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': {
        # Modify log message format here or replace with your custom formatter class
        'my_formatter': {
            'format': '(%(process)d) %(asctime)s %(name)s (line %(lineno)s) | %(levelname)s %(message)s'
        }
    },
    'handlers': {
        'console_stderr': {
            # Sends log messages with log level ERROR or higher to stderr
            'class': 'logging.StreamHandler',
            'level': 'ERROR',
            'formatter': 'my_formatter',
            'stream': sys.stderr
        },
        'console_stdout': {
            # Sends 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': {
            # Sends all log messages to a file
            'class': 'logging.FileHandler',
            'level': 'DEBUG',
            'formatter': 'my_formatter',
            'filename': 'my.log',
            'encoding': 'utf8'
        }
    },
    'root': {
        # In general, this should be kept at 'NOTSET'.
        # Otherwise it would interfere with the log levels set for each handler.
        'level': 'NOTSET',
        'handlers': ['console_stderr', 'console_stdout', 'file']
    },
}

logging.config.dictConfig(config)

Hiç kimse düzgün bir iki astar paylaşmadığından, kendimi paylaşacağım:

logging.basicConfig(filename='logs.log', level=logging.DEBUG, format="%(asctime)s:%(levelname)s: %(message)s")
logging.getLogger().addHandler(logging.StreamHandler())

İşte son derece basit bir örnek:

import logging
l = logging.getLogger("test")

# Add a file logger
f = logging.FileHandler("test.log")
l.addHandler(f)

# Add a stream logger
s = logging.StreamHandler()
l.addHandler(s)

# Send a test message to both -- critical will always log
l.critical("test msg")

Çıktı, stdout'ta ve dosyada "test msg" gösterecektir.