記錄器配置以記錄到文件並打印到標准輸出

Question

我正在使用 Python 的日志記錄模塊將一些調試字符串記錄到一個運行良好的文件中。 現在另外，我想使用這個模塊將字符串打印到標准輸出。 我該怎么做呢？ 為了將我的字符串記錄到文件中，我使用以下代碼：

import logging
import logging.handlers
logger = logging.getLogger("")
logger.setLevel(logging.DEBUG)
handler = logging.handlers.RotatingFileHandler(
    LOGFILE, maxBytes=(1048576*5), backupCount=7
)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)

然后調用一個記錄器函數

logger.debug("I am written to the file")

在這里感謝您的幫助！

Answer 1

只需獲取根記錄器的句柄並添加StreamHandler 。 StreamHandler寫入標准錯誤。 不確定您是否真的需要 stdout 而不是 stderr，但這是我在設置 Python 記錄器時使用的，我還添加了FileHandler 。 然后我所有的日志都去這兩個地方（這聽起來像你想要的）。

import logging
logging.getLogger().addHandler(logging.StreamHandler())

如果要輸出到stdout而不是stderr ，只需將其指定給StreamHandler構造函數。

import sys
# ...
logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))

您還可以向其中添加Formatter ，以便所有日志行都有一個共同的標題。

IE：

import logging
logFormatter = logging.Formatter("%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s]  %(message)s")
rootLogger = logging.getLogger()

fileHandler = logging.FileHandler("{0}/{1}.log".format(logPath, fileName))
fileHandler.setFormatter(logFormatter)
rootLogger.addHandler(fileHandler)

consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(logFormatter)
rootLogger.addHandler(consoleHandler)

打印為以下格式：

2012-12-05 16:58:26,618 [MainThread  ] [INFO ]  my message

Answer 2

logging.basicConfig()從 Python 3.3 開始可以采用關鍵字參數handlers ，這大大簡化了日志記錄設置，尤其是在使用相同的格式化程序設置多個處理程序時：

handlers - 如果指定，這應該是已創建的處理程序的迭代，以添加到根記錄器。 任何尚未設置格式化程序的處理程序都將被分配在此函數中創建的默認格式化程序。

因此，整個設置可以通過一個這樣的調用來完成：

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.FileHandler("debug.log"),
        logging.StreamHandler()
    ]
)

（或者根據原始問題的要求使用import sys + StreamHandler(sys.stdout) - StreamHandler 的默認設置是寫入 stderr。如果要自定義日志格式並添加文件名/行、線程信息等內容，請查看LogRecord 屬性.)

上面的設置只需要在腳本開頭附近進行一次。 您可以稍后使用代碼庫中所有其他位置的日志記錄，如下所示：

logging.info('Useful message')
logging.error('Something bad happened')
...

注意：如果它不起作用，其他人可能已經以不同的方式初始化了日志系統。 評論建議在調用basicConfig()之前執行logging.root.handlers = [] 。

Answer 3

添加不帶參數的 StreamHandler 會轉到 stderr 而不是 stdout。 如果其他進程依賴於標准輸出轉儲（即在編寫 NRPE 插件時），請確保明確指定標准輸出，否則您可能會遇到一些意想不到的麻煩。

這是一個重用假設值和問題中的 LOGFILE 的快速示例：

import logging
from logging.handlers import RotatingFileHandler
from logging import handlers
import sys

log = logging.getLogger('')
log.setLevel(logging.DEBUG)
format = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")

ch = logging.StreamHandler(sys.stdout)
ch.setFormatter(format)
log.addHandler(ch)

fh = handlers.RotatingFileHandler(LOGFILE, maxBytes=(1048576*5), backupCount=7)
fh.setFormatter(format)
log.addHandler(fh)

Answer 4

這是一個完整的、包裝精美的解決方案，基於Waterboy 的回答和其他各種來源。 它支持記錄到控制台和日志文件，允許不同的日志級別設置，提供彩色輸出並且易於配置（也可作為Gist使用）：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# -------------------------------------------------------------------------------
#                                                                               -
#  Python dual-logging setup (console and log file),                            -
#  supporting different log levels and colorized output                         -
#                                                                               -
#  Created by Fonic <https://github.com/fonic>                                  -
#  Date: 04/05/20                                                               -
#                                                                               -
#  Based on:                                                                    -
#  https://stackoverflow.com/a/13733863/1976617                                 -
#  https://uran198.github.io/en/python/2016/07/12/colorful-python-logging.html  -
#  https://en.wikipedia.org/wiki/ANSI_escape_code#Colors                        -
#                                                                               -
# -------------------------------------------------------------------------------

# Imports
import os
import sys
import logging

# Logging formatter supporting colorized output
class LogFormatter(logging.Formatter):

    COLOR_CODES = {
        logging.CRITICAL: "\033[1;35m", # bright/bold magenta
        logging.ERROR:    "\033[1;31m", # bright/bold red
        logging.WARNING:  "\033[1;33m", # bright/bold yellow
        logging.INFO:     "\033[0;37m", # white / light gray
        logging.DEBUG:    "\033[1;30m"  # bright/bold black / dark gray
    }

    RESET_CODE = "\033[0m"

    def __init__(self, color, *args, **kwargs):
        super(LogFormatter, self).__init__(*args, **kwargs)
        self.color = color

    def format(self, record, *args, **kwargs):
        if (self.color == True and record.levelno in self.COLOR_CODES):
            record.color_on  = self.COLOR_CODES[record.levelno]
            record.color_off = self.RESET_CODE
        else:
            record.color_on  = ""
            record.color_off = ""
        return super(LogFormatter, self).format(record, *args, **kwargs)

# Setup logging
def setup_logging(console_log_output, console_log_level, console_log_color, logfile_file, logfile_log_level, logfile_log_color, log_line_template):

    # Create logger
    # For simplicity, we use the root logger, i.e. call 'logging.getLogger()'
    # without name argument. This way we can simply use module methods for
    # for logging throughout the script. An alternative would be exporting
    # the logger, i.e. 'global logger; logger = logging.getLogger("<name>")'
    logger = logging.getLogger()

    # Set global log level to 'debug' (required for handler levels to work)
    logger.setLevel(logging.DEBUG)

    # Create console handler
    console_log_output = console_log_output.lower()
    if (console_log_output == "stdout"):
        console_log_output = sys.stdout
    elif (console_log_output == "stderr"):
        console_log_output = sys.stderr
    else:
        print("Failed to set console output: invalid output: '%s'" % console_log_output)
        return False
    console_handler = logging.StreamHandler(console_log_output)

    # Set console log level
    try:
        console_handler.setLevel(console_log_level.upper()) # only accepts uppercase level names
    except:
        print("Failed to set console log level: invalid level: '%s'" % console_log_level)
        return False

    # Create and set formatter, add console handler to logger
    console_formatter = LogFormatter(fmt=log_line_template, color=console_log_color)
    console_handler.setFormatter(console_formatter)
    logger.addHandler(console_handler)

    # Create log file handler
    try:
        logfile_handler = logging.FileHandler(logfile_file)
    except Exception as exception:
        print("Failed to set up log file: %s" % str(exception))
        return False

    # Set log file log level
    try:
        logfile_handler.setLevel(logfile_log_level.upper()) # only accepts uppercase level names
    except:
        print("Failed to set log file log level: invalid level: '%s'" % logfile_log_level)
        return False

    # Create and set formatter, add log file handler to logger
    logfile_formatter = LogFormatter(fmt=log_line_template, color=logfile_log_color)
    logfile_handler.setFormatter(logfile_formatter)
    logger.addHandler(logfile_handler)

    # Success
    return True

# Main function
def main():

    # Setup logging
    script_name = os.path.splitext(os.path.basename(sys.argv[0]))[0]
    if (not setup_logging(console_log_output="stdout", console_log_level="warning", console_log_color=True,
                        logfile_file=script_name + ".log", logfile_log_level="debug", logfile_log_color=False,
                        log_line_template="%(color_on)s[%(created)d] [%(threadName)s] [%(levelname)-8s] %(message)s%(color_off)s")):
        print("Failed to setup logging, aborting.")
        return 1

    # Log some messages
    logging.debug("Debug message")
    logging.info("Info message")
    logging.warning("Warning message")
    logging.error("Error message")
    logging.critical("Critical message")

# Call main function
if (__name__ == "__main__"):
    sys.exit(main())

---

關於 Microsoft Windows 的注意事項：
要使顏色真正出現在 Microsoft Windows 上，還需要額外的步驟。 有兩個選項（均在 Microsoft Windows 10 上成功測試）：

1) 使用以下代碼啟用 ANSI 終端模式（通過設置標志ENABLE_VIRTUAL_TERMINAL_PROCESSING使終端能夠解釋轉義序列；更多信息請參見此處、此處、此處和此處）：

# Enable ANSI terminal mode on Microsoft Windows
def windows_enable_ansi_terminal_mode():
    if (sys.platform != "win32"):
        return None
    try:
        import ctypes
        kernel32 = ctypes.windll.kernel32
        result = kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
        if (result == 0): raise Exception
        return True
    except:
        return False

2) 使用 Python 包colorama （過濾發送到stdout和stderr的輸出並將轉義序列轉換為本地 Windows API 調用）：

import colorama
colorama.init()

Answer 5

在設置任何其他處理程序或記錄任何消息之前，使用stream=sys.stdout作為參數運行basicConfig ，或者手動添加一個StreamHandler將消息推送到標准輸出到根記錄器（或任何其他你想要的記錄器，就此而言） .

Answer 6

使用不同級別和格式記錄到stdout和rotating file ：

import logging
import logging.handlers
import sys

if __name__ == "__main__":

    # Change root logger level from WARNING (default) to NOTSET in order for all messages to be delegated.
    logging.getLogger().setLevel(logging.NOTSET)

    # Add stdout handler, with level INFO
    console = logging.StreamHandler(sys.stdout)
    console.setLevel(logging.INFO)
    formater = logging.Formatter('%(name)-13s: %(levelname)-8s %(message)s')
    console.setFormatter(formater)
    logging.getLogger().addHandler(console)

    # Add file rotating handler, with level DEBUG
    rotatingHandler = logging.handlers.RotatingFileHandler(filename='rotating.log', maxBytes=1000, backupCount=5)
    rotatingHandler.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    rotatingHandler.setFormatter(formatter)
    logging.getLogger().addHandler(rotatingHandler)

    log = logging.getLogger("app." + __name__)

    log.debug('Debug message, should only appear in the file.')
    log.info('Info message, should appear in file and stdout.')
    log.warning('Warning message, should appear in file and stdout.')
    log.error('Error message, should appear in file and stdout.')

Answer 7

在多個 Python 包中一遍又一遍地使用 Waterboy 的代碼后，我最終將其轉換為一個小的獨立 Python 包，您可以在此處找到它：

https://github.com/acschaefer/duallog

該代碼有據可查且易於使用。 只需下載.py文件並將其包含在您的項目中，或通過pip install duallog安裝整個包。

Answer 8

我已經通過以下模塊同時處理了將日志和打印重定向到磁盤、stdout 和 stderr 上的文件（要點也可在此處獲得）：

import logging
import pathlib
import sys

from ml.common.const import LOG_DIR_PATH, ML_DIR


def create_log_file_path(file_path, root_dir=ML_DIR, log_dir=LOG_DIR_PATH):
    path_parts = list(pathlib.Path(file_path).parts)
    relative_path_parts = path_parts[path_parts.index(root_dir) + 1:]
    log_file_path = pathlib.Path(log_dir, *relative_path_parts)
    log_file_path = log_file_path.with_suffix('.log')
    # Create the directories and the file itself
    log_file_path.parent.mkdir(parents=True, exist_ok=True)
    log_file_path.touch(exist_ok=True)
    return log_file_path


def set_up_logs(file_path, mode='a', level=logging.INFO):
    log_file_path = create_log_file_path(file_path)
    logging_handlers = [logging.FileHandler(log_file_path, mode=mode),
                        logging.StreamHandler(sys.stdout)]
    logging.basicConfig(
        handlers=logging_handlers,
        format='%(asctime)s %(name)s %(levelname)s %(message)s',
        level=level
    )


class OpenedFileHandler(logging.FileHandler):

    def __init__(self, file_handle, filename, mode):
        self.file_handle = file_handle
        super(OpenedFileHandler, self).__init__(filename, mode)

    def _open(self):
        return self.file_handle


class StandardError:
    def __init__(self, buffer_stderr, buffer_file):
        self.buffer_stderr = buffer_stderr
        self.buffer_file = buffer_file

    def write(self, message):
        self.buffer_stderr.write(message)
        self.buffer_file.write(message)


class StandardOutput:
    def __init__(self, buffer_stdout, buffer_file):
        self.buffer_stdout = buffer_stdout
        self.buffer_file = buffer_file

    def write(self, message):
        self.buffer_stdout.write(message)
        self.buffer_file.write(message)


class Logger:
    def __init__(self, file_path, mode='a', level=logging.INFO):
        self.stdout_ = sys.stdout
        self.stderr_ = sys.stderr

        log_file_path = create_log_file_path(file_path)
        self.file_ = open(log_file_path, mode=mode)

        logging_handlers = [OpenedFileHandler(self.file_, log_file_path,
                                              mode=mode),
                            logging.StreamHandler(sys.stdout)]
        logging.basicConfig(
            handlers=logging_handlers,
            format='%(asctime)s %(name)s %(levelname)s %(message)s',
            level=level
        )

    # Overrides write() method of stdout and stderr buffers
    def write(self, message):
        self.stdout_.write(message)
        self.stderr_.write(message)
        self.file_.write(message)

    def flush(self):
        pass

    def __enter__(self):
        sys.stdout = StandardOutput(self.stdout_, self.file_)
        sys.stderr = StandardError(self.stderr_, self.file_)

    def __exit__(self, exc_type, exc_val, exc_tb):
        sys.stdout = self.stdout_
        sys.stderr = self.stderr_
        self.file_.close()

編寫為上下文管理器，您可以通過添加額外的行來簡單地將功能添加到您的 python 腳本中：

from logger import Logger

...

if __name__ == '__main__':
    with Logger(__file__):
        main()

Answer 9

盡管該問題專門要求logger configuration ，但有一種替代方法不需要對logging configuration 進行任何更改，也不需要重定向stdout 。

也許有點簡單，但它有效：

def log_and_print(message: str, level: int, logger: logging.Logger):
    logger.log(level=level, msg=message)  # log as normal
    print(message)  # prints to stdout by default

我們現在調用log_and_print(message='something', level=logging.DEBUG, logger=logger) logger.debug('something')

我們也可以稍微擴展一下，所以它只在必要時將 s打印到stdout ：

def log_print(message: str, level: int, logger: logging.Logger):
    # log the message normally
    logger.log(level=level, msg=message)
    # only print to stdout if the message is not logged to stdout
    msg_logged_to_stdout = False
    current_logger = logger
    while current_logger and not msg_logged_to_stdout:
        is_enabled = current_logger.isEnabledFor(level)
        logs_to_stdout = any(
            getattr(handler, 'stream', None) == sys.stdout
            for handler in current_logger.handlers
        )
        msg_logged_to_stdout = is_enabled and logs_to_stdout
        if not current_logger.propagate:
            current_logger = None
        else:
            current_logger = current_logger.parent            
    if not msg_logged_to_stdout:
        print(message)
    

這將檢查記錄器及其父級以查找流到stdout的任何處理程序，並檢查記錄器是否已針對指定級別啟用。

請注意，這尚未針對性能進行優化。

Answer 10

對於 2.7，請嘗試以下操作：

fh = logging.handlers.RotatingFileHandler(LOGFILE, maxBytes=(1048576*5), backupCount=7)