Python Logging 库超详细的解读

在软件开发过程中，日志记录是一项至关重要的任务。通过在代码中引入适当的日志记录，开发人员可以更容易地追踪应用程序的行为、排除错误并进行性能分析。Python 的 logging 库是一个强大的工具，提供了丰富的功能，使得日志记录变得更加灵活和可配置。本文将深入探讨 Python logging 库的各个方面，包括基本概念、配置方法、处理程序和格式化等内容。

基本概念

1. 日志级别

Python logging 库定义了几个标准的日志级别，用于表示日志消息的重要性。这些级别按从低到高的顺序分别是：

DEBUG: 最详细的信息，主要用于调试。
INFO: 用于确认事情按预期工作。
WARNING: 表示有一些意外情况，或者某些不常见的情况。
ERROR: 表示更严重的问题，但应用程序仍能继续运行。
CRITICAL: 表示严重错误，可能导致应用程序终止。

2. Logger

Logger 类是 logging 库的核心组件之一，用于创建和管理日志记录器。每个日志记录器都有一个名称，这个名称通常对应于模块名或者与应用程序的不同部分相关的标识符。通过使用 getLogger 方法，可以获取或创建一个具有特定名称的日志记录器。

 
pythonCopy codeimport logging
 
logger = logging.getLogger("my_logger")

3. Handler

Handler 对象负责将日志消息发送到指定的目的地。例如，可以使用 StreamHandler 将日志消息输出到标准输出，或者使用 FileHandler 将日志记录到文件中。

 
pythonCopy codestream_handler = logging.StreamHandler()
file_handler = logging.FileHandler("app.log")

4. Formatter

Formatter 对象用于定义日志消息的输出格式。通过将格式器分配给处理程序，可以自定义日志消息的显示方式。

 
pythonCopy codeformatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
stream_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

配置 Logging

1. 基本配置

最简单的配置方法是使用 basicConfig 函数，它接受一些关键字参数，例如 filename、level、format 等。这样的配置适用于简单的应用程序，但对于复杂的项目，更灵活的配置方式更为合适。

 
pythonCopy codeimport logging
 
logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

2. 使用配置文件

对于复杂的应用程序，使用配置文件来配置 logging 更为方便。可以通过 fileConfig 函数加载配置文件，其中配置文件采用 INI 格式。

 
pythonCopy codeimport logging.config
 
logging.config.fileConfig('logging.conf')

配置文件示例：

 
iniCopy code[loggers]
keys=root,sampleLogger
 
[handlers]
keys=consoleHandler
 
[formatters]
keys=sampleFormatter
 
[logger_root]
level=DEBUG
handlers=consoleHandler
 
[logger_sampleLogger]
level=DEBUG
handlers=consoleHandler
qualname=sampleLogger
propagate=0
 
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=sampleFormatter
args=(sys.stdout,)
 
[formatter_sampleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=%Y-%m-%d %H:%M:%S

使用示例

下面是一个简单的使用 Python logging 库的示例：

 
pythonCopy codeimport logging
 
# 配置日志记录器
logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
# 创建一个日志记录器
logger = logging.getLogger("my_logger")
 
# 创建一个处理程序，并将其关联到日志记录器
stream_handler = logging.StreamHandler()
logger.addHandler(stream_handler)
 
# 创建一个格式器，并将其关联到处理程序
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
stream_handler.setFormatter(formatter)
 
# 记录不同级别的日志消息
logger.debug("This is a debug message.")
logger.info("This is an info message.")
logger.warning("This is a warning message.")
logger.error("This is an error message.")
logger.critical("This is a critical message.")

当涉及到 Python logging 库时，实际使用涉及许多方面，比如自定义处理程序、过滤器、使用不同的配置方式等。下面我们将展示一些更具体的示例，以便更全面地了解 logging 库的功能。

1. 自定义处理程序

除了使用内置的处理程序外，我们可以自定义处理程序来满足特定需求。例如，我们可以创建一个将日志消息发送到邮件的处理程序：

 
pythonCopy codeimport logging
import smtplib
from email.mime.text import MIMEText
 
class EmailHandler(logging.Handler):
    def __init__(self, mailhost, from_addr, to_addr, subject):
        super().__init__()
        self.mailhost = mailhost
        self.from_addr = from_addr
        self.to_addr = to_addr
        self.subject = subject
 
    def emit(self, record):
        msg = MIMEText(self.format(record))
        msg['Subject'] = self.subject
        msg['From'] = self.from_addr
        msg['To'] = self.to_addr
 
        with smtplib.SMTP(self.mailhost) as server:
            server.sendmail(self.from_addr, [self.to_addr], msg.as_string())
 
# 配置邮件处理程序
mail_handler = EmailHandler(mailhost='smtp.example.com',
                            from_addr='sender@example.com',
                            to_addr='recipient@example.com',
                            subject='Error in the application')
mail_handler.setLevel(logging.ERROR)
 
# 将邮件处理程序添加到日志记录器
logger.addHandler(mail_handler)
 
# 记录一条错误消息
logger.error("This is an error message sent via email.")

2. 过滤器

过滤器允许在消息到达处理程序之前进行进一步的控制。例如，我们可以使用过滤器仅记录特定模块的消息：

 
pythonCopy codeclass ModuleFilter(logging.Filter):
    def __init__(self, module_name):
        super().__init__()
        self.module_name = module_name
 
    def filter(self, record):
        return record.name.startswith(self.module_name)
 
# 创建一个过滤器实例
module_filter = ModuleFilter(module_name='my_module')
 
# 将过滤器添加到日志记录器
logger.addFilter(module_filter)
 
# 记录一条消息，但只有当消息来自 'my_module' 时才会被处理
logger.info("This message is from my_module.")
logger.info("This message is from another_module.")

3. 使用配置文件

通过使用配置文件，可以更方便地进行灵活的配置。以下是一个配置文件的示例：

 
iniCopy code[loggers]
keys=root,sampleLogger
 
[handlers]
keys=consoleHandler,fileHandler
 
[formatters]
keys=sampleFormatter
 
[logger_root]
level=DEBUG
handlers=consoleHandler
 
[logger_sampleLogger]
level=DEBUG
handlers=fileHandler
qualname=sampleLogger
propagate=0
 
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=sampleFormatter
args=(sys.stdout,)
 
[handler_fileHandler]
class=FileHandler
level=DEBUG
formatter=sampleFormatter
args=('app.log',)
 
[formatter_sampleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=%Y-%m-%d %H:%M:%S

通过加载这个配置文件，可以轻松地配置整个 logging 系统。

 
pythonCopy codeimport logging.config
 
logging.config.fileConfig('logging_config.ini')

这些示例突显了 Python logging 库的灵活性和可扩展性。通过了解这些概念和示例，你将能够更好地使用 logging 库来满足不同项目的需求。无论是简单的控制台输出，还是复杂的邮件通知系统，logging 库都能够提供强大的支持。

当使用 Python logging 库时，我们还可以探索其他功能，如日志记录器的继承、异常信息的记录、以及使用上下文管理器进行日志跟踪。以下是更多示例：

4. 日志记录器的继承

有时，我们希望创建一个子系统的日志记录器，继承父系统的配置但又能够单独设置。这可以通过创建子系统的日志记录器实现：

 
pythonCopy codeimport logging
 
# 配置根日志记录器
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
# 创建根日志记录器
root_logger = logging.getLogger()
 
# 创建子系统的日志记录器，继承根日志记录器的配置
subsystem_logger = logging.getLogger("subsystem")
 
# 记录消息到根日志记录器
root_logger.info("This is a message from the root logger.")
 
# 记录消息到子系统日志记录器
subsystem_logger.info("This is a message from the subsystem logger.")

5. 记录异常信息

在捕获异常时，我们可以使用 exc_info 参数来记录异常信息：

 
pythonCopy codeimport logging
 
try:
    # 一些可能引发异常的代码
    result = 1 / 0
except Exception as e:
    # 记录异常信息
    logging.error("An error occurred: %s", e, exc_info=True)

6. 使用上下文管理器进行日志跟踪

在某些情况下，我们可能希望在一段代码块中的所有日志消息中添加额外的上下文信息。这可以通过创建一个上下文管理器来实现：

 
pythonCopy codeimport logging
 
class ContextFilter(logging.Filter):
    def __init__(self, context):
        super().__init__()
        self.context = context
 
    def filter(self, record):
        record.context = self.context
        return True
 
# 创建上下文管理器
class LogContext:
    def __init__(self, context):
        self.context = context
 
    def __enter__(self):
        logging.getLogger().addFilter(ContextFilter(self.context))
 
    def __exit__(self, exc_type, exc_value, traceback):
        logging.getLogger().removeFilter(ContextFilter(self.context))
 
# 使用上下文管理器
with LogContext(context="Request ID: 12345"):
    logging.info("This log message includes additional context.")

通过这些示例，我们可以更全面地理解 Python logging 库的功能和灵活性。无论是在构建大型应用程序还是小型脚本，logging 库都提供了许多工具来方便地管理和记录日志。

当使用 Python logging 库时，还有一些高级功能和技巧可以使日志记录更加灵活和强大。以下是一些额外的示例：

7. 异步日志记录

在高性能应用程序中，同步记录日志可能会导致性能下降。使用异步处理器可以在不阻塞主线程的情况下进行日志记录：

 
pythonCopy codeimport logging
import queue
import threading
 
# 创建一个队列用于存储日志消息
log_queue = queue.Queue()
 
# 创建异步处理器
async_handler = logging.handlers.QueueHandler(log_queue)
 
# 将异步处理器添加到日志记录器
logger.addHandler(async_handler)
 
# 创建异步日志记录线程
def log_worker():
    while True:
        record = log_queue.get()
        if record is None:
            break
        logger.handle(record)
 
# 启动异步日志记录线程
log_thread = threading.Thread(target=log_worker, daemon=True)
log_thread.start()
 
# 记录日志消息（异步）
logger.info("This is an asynchronous log message.")

8. 使用配置字典进行动态配置

可以使用配置字典动态配置日志记录器，而不是在代码中硬编码配置。这对于根据不同环境或配置文件灵活调整日志配置非常有用：

 
pythonCopy codeimport logging.config
 
log_config = {
    'version': 1,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'level': 'DEBUG',
        },
    },
    'root': {
        'handlers': ['console'],
        'level': 'INFO',
    },
}
 
# 使用配置字典进行配置
logging.config.dictConfig(log_config)
 
# 记录日志消息
logger.info("This log message is configured using a dictionary.")

9. 在 Flask 中使用

在 Flask 等框架中，可以方便地集成 logging 库。例如，在 Flask 应用中，可以通过以下方式配置日志记录器：

 
pythonCopy codefrom flask import Flask
import logging
 
app = Flask(__name__)
 
# 配置日志记录器
app.logger.setLevel(logging.DEBUG)
app.logger.addHandler(logging.StreamHandler())

这样，Flask 将使用配置的日志记录器来记录应用程序的日志消息。

10. 将日志记录到数据库

有时候，我们可能希望将日志消息存储到数据库中，以便后续分析。可以通过创建自定义处理程序来实现：

 
pythonCopy codeimport logging
import sqlite3
 
class DatabaseHandler(logging.Handler):
    def __init__(self, db_path):
        super().__init__()
        self.db_path = db_path
 
    def emit(self, record):
        log_entry = self.format(record)
 
        # 将日志消息插入数据库
        with sqlite3.connect(self.db_path) as conn:
            conn.execute("INSERT INTO log_table (log_entry) VALUES (?)", (log_entry,))
 
# 创建数据库处理程序
db_handler = DatabaseHandler(db_path='app_logs.db')
 
# 将数据库处理程序添加到日志记录器
logger.addHandler(db_handler)
 
# 记录日志消息，并将其存储到数据库中
logger.info("This log message will be stored in the database.")

这些示例展示了一些更高级的用法，使得 Python logging 库更加适应各种应用场景。无论您是在开发 Web 应用、大规模数据处理系统还是嵌入式设备上，logging 库都提供了丰富的功能，可以满足您的日志记录需求。

当涉及到 Python logging 库时，还有一些进阶的技巧和用法，例如使用装饰器记录函数调用、日志轮转、使用第三方库进行日志分析等。以下是一些额外的示例：

11. 使用装饰器记录函数调用

通过使用装饰器，可以轻松地记录函数的调用和执行时间：

 
pythonCopy codeimport logging
import time
 
def log_function_call(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        elapsed_time = end_time - start_time
 
        logging.info(f"{func.__name__} executed in {elapsed_time:.2f} seconds.")
        return result
 
    return wrapper
 
# 应用装饰器来记录函数调用
@log_function_call
def example_function():
    # 一些需要记录执行时间的代码
    time.sleep(2)
 
# 调用带有装饰器的函数
example_function()

12. 日志轮转

当日志文件达到一定大小时，进行日志轮转可以避免单个日志文件过大。可以使用 RotatingFileHandler 或 TimedRotatingFileHandler 来实现：

 
pythonCopy codeimport logging
from logging.handlers import RotatingFileHandler
 
# 创建 RotatingFileHandler 处理程序，设置每个日志文件最大为 1MB，保留 3 个旧日志文件
rotating_handler = RotatingFileHandler('app.log', maxBytes=1e6, backupCount=3)
 
# 将处理程序添加到日志记录器
logger.addHandler(rotating_handler)
 
# 记录一些日志消息
for i in range(10):
    logger.info(f"Log message {i}")

13. 使用第三方库进行日志分析

使用第三方库，如 loguru，可以使日志分析更加方便，提供更多的功能，如自动格式化、颜色化输出等：

 
pythonCopy codefrom loguru import logger
 
# 配置日志输出格式
logger.add("app.log", rotation="500 MB", level="INFO", format="{time:YYYY-MM-DD at HH:mm:ss} | {level: <8} | {message}")
 
# 记录一些日志消息
logger.info("This is an informational message.")
logger.warning("This is a warning message.")
logger.error("This is an error message.")

loguru 提供了直观的 API，可以轻松地配置和使用，同时支持很多强大的功能。

这些示例提供了更多的灵活性和高级用法，使得 Python logging 库适用于各种复杂的应用场景。通过深入了解这些功能，开发人员可以更好地利用 logging 库来满足不同项目的需求。

当涉及到 Python logging 库时，还有一些特殊场景和高级技巧可以探索。以下是一些额外的示例：

14. 使用 SocketHandler 进行远程日志记录

通过使用 SocketHandler，可以将日志消息发送到远程服务器，方便集中记录和分析：

 
pythonCopy codeimport logging
import logging.handlers
 
# 创建 SocketHandler 处理程序，将日志消息发送到指定的远程服务器和端口
socket_handler = logging.handlers.SocketHandler('localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT)
 
# 设置日志级别
socket_handler.setLevel(logging.INFO)
 
# 将处理程序添加到日志记录器
logger.addHandler(socket_handler)
 
# 记录一些日志消息
logger.info("This log message will be sent to the remote server.")

15. 在 Django 中使用

Django 框架集成了 Python logging 库，允许您轻松地配置和使用日志记录。在 Django 项目的 settings.py 文件中进行配置：

 
pythonCopy code# settings.py
 
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'django.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

16. 使用 MemoryHandler 缓存日志消息

通过使用 MemoryHandler，可以将日志消息暂时缓存到内存中，然后在满足特定条件时将其批量处理：

 
pythonCopy codeimport logging
import logging.handlers
 
# 创建 MemoryHandler 处理程序，将日志消息缓存到内存中
memory_handler = logging.handlers.MemoryHandler(capacity=1024, flushLevel=logging.ERROR, target=logging.StreamHandler())
 
# 设置日志级别
memory_handler.setLevel(logging.DEBUG)
 
# 将处理程序添加到日志记录器
logger.addHandler(memory_handler)
 
# 记录一些日志消息
for i in range(10):
    logger.debug(f"Log message {i}")
 
# 当发生错误时，将缓存的日志消息一次性输出
try:
    result = 1 / 0
except Exception as e:
    logger.error("An error occurred: %s", e)

这些示例涉及到一些特殊的使用场景，如远程日志记录、在 Django 中配置、以及缓存和一次性输出日志消息等。通过深入了解这些用法，您可以更好地适应不同的项目需求。

当涉及到 Python logging 库时，还有一些额外的用法和技巧，以下是一些建议：

17. 使用 QueueHandler 和 QueueListener 进行多进程日志记录

如果您的应用程序是多进程的，可以使用 QueueHandler 和 QueueListener 进行多进程日志记录。这可以确保在多个进程中记录的日志不会混淆：

 
pythonCopy codeimport logging
from logging.handlers import QueueHandler, QueueListener
 
# 创建队列
log_queue = multiprocessing.Queue()
 
# 创建 QueueHandler 处理程序
queue_handler = QueueHandler(log_queue)
 
# 将处理程序添加到日志记录器
logger.addHandler(queue_handler)
 
# 创建 QueueListener
queue_listener = QueueListener(log_queue, logging.StreamHandler())
 
# 启动 QueueListener
queue_listener.start()
 
# 记录日志消息
logger.info("This log message will be processed by QueueListener in a separate process.")
 
# 停止 QueueListener
queue_listener.stop()

18. 使用日志记录器的额外属性

日志记录器可以包含额外的属性，这些属性可以在日志消息中使用。例如，添加请求 ID 或用户 ID 可以方便地跟踪特定请求或用户的日志：

 
pythonCopy codeimport logging
 
# 创建日志记录器
logger = logging.getLogger(__name__)
 
# 添加额外属性
logger = logger.bind(request_id="12345", user_id="user123")
 
# 记录带有额外属性的日志消息
logger.info("Processing request.")

19. 使用 NullHandler 防止根日志记录器消息重复

在某些情况下，应用程序中的日志记录器可能会产生重复的消息。通过在根日志记录器上添加 NullHandler，可以防止这种情况发生：

 
pythonCopy codeimport logging
 
# 创建 NullHandler 处理程序
null_handler = logging.NullHandler()
 
# 将处理程序添加到根日志记录器
logging.getLogger().addHandler(null_handler)
 
# 其他日志记录器配置...

20. 在 Jupyter Notebook 中使用

在 Jupyter Notebook 中使用 logging 库时，可能需要调整配置以在输出单元格中查看日志消息。可以使用 RichHandler 等处理程序，以获得更好的可视化效果：

 
pythonCopy codeimport logging
from rich.logging import RichHandler
 
# 配置 logging，使用 RichHandler 处理程序
logging.basicConfig(level=logging.INFO, handlers=[RichHandler()])
 
# 记录一些日志消息
logging.info("This log message will be displayed with rich formatting.")

这些示例提供了一些高级用法和特定场景下的技巧，以进一步展示 Python logging 库的灵活性和适应性。无论是在多进程环境中、Jupyter Notebook 中，还是需要特定属性的日志记录，logging 库都提供了丰富的工具。通过深入了解这些用法，您可以更好地满足各种应用场景的需求。

21. 使用其他日志处理库

除了内置的 logging 库之外，还有一些其他第三方库可用于改善日志记录体验。例如，structlog 提供了更具灵活性的日志记录方式：

 
pythonCopy codeimport structlog
 
# 使用 structlog 进行配置
structlog.configure(
    processors=[
        structlog.stdlib.add_log_level,
        structlog.stdlib.add_logger_name,
        structlog.stdlib.PositionalArgumentsFormatter(),
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.JSONRenderer(),
    ]
)
 
# 记录日志消息
logger = structlog.get_logger()
logger.info("This log message is formatted using structlog.")

22. 使用 AIOHTTP 客户端记录异步请求日志

如果您的应用程序使用异步编程，例如使用 AIOHTTP 进行异步请求，您可以使用 aiohttp.ClientSession 来记录异步请求的日志：

 
pythonCopy codeimport logging
import aiohttp
 
# 创建异步日志记录器
async_logger = logging.getLogger("async_requests")
 
async def make_request(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            # 记录异步请求的日志
            await async_logger.info("Request completed successfully.", extra={"url": url})
 
# 运行异步请求
await make_request("https://example.com")

23. 在 Web 应用中记录请求和响应

对于 Web 应用，可能需要记录每个请求的详细信息，以便进行排查。您可以使用中间件来捕获请求和响应：

 
pythonCopy codefrom flask import Flask, request
import logging
 
app = Flask(__name__)
 
# 创建请求和响应日志记录器
request_logger = logging.getLogger("request_logger")
 
@app.before_request
def log_request_info():
    request_logger.info("Request received", extra={"method": request.method, "path": request.path})
 
@app.after_request
def log_response_info(response):
    request_logger.info("Response sent", extra={"status_code": response.status_code})
    return response

24. 配置日志记录器的上下文

通过使用 contextvars 模块，可以实现在不同上下文中配置日志记录器：

 
pythonCopy codeimport logging
import contextvars
 
# 创建上下文变量
user_id = contextvars.ContextVar("user_id", default=None)
 
# 创建日志记录器
logger = logging.getLogger(__name__)
 
def log_user_activity(activity):
    # 在上下文中添加用户 ID
    user_id.set("user123")
 
    # 记录用户活动
    logger.info(f"User activity: {activity}")
 
# 在不同上下文中调用 log_user_activity
with contextvars.copy_context():
    log_user_activity("logged in")
 
with contextvars.copy_context():
    log_user_activity("logged out")

这些示例提供了一些额外的用法和技巧，使得 Python logging 库更加适应特定的应用场景。通过进一步探索这些用法，你可以更好地满足复杂项目的日志记录需求。

以上是本文对loggeing库的详细解读，反正这是一款很优秀的库。使用起来吧

	pythonCopy codeimport logging

	logger = logging.getLogger("my_logger")

	pythonCopy codestream_handler = logging.StreamHandler()
	file_handler = logging.FileHandler("app.log")

	pythonCopy codeformatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
	stream_handler.setFormatter(formatter)
	file_handler.setFormatter(formatter)

	pythonCopy codeimport logging

	logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

	pythonCopy codeimport logging.config

	logging.config.fileConfig('logging.conf')

	iniCopy code[loggers]
	keys=root,sampleLogger

	[handlers]
	keys=consoleHandler

	[formatters]
	keys=sampleFormatter

	[logger_root]
	level=DEBUG
	handlers=consoleHandler

	[logger_sampleLogger]
	level=DEBUG
	handlers=consoleHandler
	qualname=sampleLogger
	propagate=0

	[handler_consoleHandler]
	class=StreamHandler
	level=DEBUG
	formatter=sampleFormatter
	args=(sys.stdout,)

	[formatter_sampleFormatter]
	format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
	datefmt=%Y-%m-%d %H:%M:%S

	pythonCopy codeimport logging

	# 配置日志记录器
	logging.basicConfig(filename='app.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

	# 创建一个日志记录器
	logger = logging.getLogger("my_logger")

	# 创建一个处理程序，并将其关联到日志记录器
	stream_handler = logging.StreamHandler()
	logger.addHandler(stream_handler)

	# 创建一个格式器，并将其关联到处理程序
	formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
	stream_handler.setFormatter(formatter)

	# 记录不同级别的日志消息
	logger.debug("This is a debug message.")
	logger.info("This is an info message.")
	logger.warning("This is a warning message.")
	logger.error("This is an error message.")
	logger.critical("This is a critical message.")

	pythonCopy codeimport logging
	import smtplib
	from email.mime.text import MIMEText

	class EmailHandler(logging.Handler):
	def __init__(self, mailhost, from_addr, to_addr, subject):
	super().__init__()
	self.mailhost = mailhost
	self.from_addr = from_addr
	self.to_addr = to_addr
	self.subject = subject

	def emit(self, record):
	msg = MIMEText(self.format(record))
	msg['Subject'] = self.subject
	msg['From'] = self.from_addr
	msg['To'] = self.to_addr

	with smtplib.SMTP(self.mailhost) as server:
	server.sendmail(self.from_addr, [self.to_addr], msg.as_string())

	# 配置邮件处理程序
	mail_handler = EmailHandler(mailhost='smtp.example.com',
	from_addr='sender@example.com',
	to_addr='recipient@example.com',
	subject='Error in the application')
	mail_handler.setLevel(logging.ERROR)

	# 将邮件处理程序添加到日志记录器
	logger.addHandler(mail_handler)

	# 记录一条错误消息
	logger.error("This is an error message sent via email.")

	pythonCopy codeclass ModuleFilter(logging.Filter):
	def __init__(self, module_name):
	super().__init__()
	self.module_name = module_name

	def filter(self, record):
	return record.name.startswith(self.module_name)

	# 创建一个过滤器实例
	module_filter = ModuleFilter(module_name='my_module')

	# 将过滤器添加到日志记录器
	logger.addFilter(module_filter)

	# 记录一条消息，但只有当消息来自 'my_module' 时才会被处理
	logger.info("This message is from my_module.")
	logger.info("This message is from another_module.")

	pythonCopy codeimport logging.config

	logging.config.fileConfig('logging_config.ini')

	pythonCopy codeimport logging

	# 配置根日志记录器
	logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

	# 创建根日志记录器
	root_logger = logging.getLogger()

	# 创建子系统的日志记录器，继承根日志记录器的配置
	subsystem_logger = logging.getLogger("subsystem")

	# 记录消息到根日志记录器
	root_logger.info("This is a message from the root logger.")

	# 记录消息到子系统日志记录器
	subsystem_logger.info("This is a message from the subsystem logger.")

	pythonCopy codeimport logging

	try:
	# 一些可能引发异常的代码
	result = 1 / 0
	except Exception as e:
	# 记录异常信息
	logging.error("An error occurred: %s", e, exc_info=True)

	pythonCopy codeimport logging

	class ContextFilter(logging.Filter):
	def __init__(self, context):
	super().__init__()
	self.context = context

	def filter(self, record):
	record.context = self.context
	return True

	# 创建上下文管理器
	class LogContext:
	def __init__(self, context):
	self.context = context

	def __enter__(self):
	logging.getLogger().addFilter(ContextFilter(self.context))

	def __exit__(self, exc_type, exc_value, traceback):
	logging.getLogger().removeFilter(ContextFilter(self.context))

	# 使用上下文管理器
	with LogContext(context="Request ID: 12345"):
	logging.info("This log message includes additional context.")

	pythonCopy codeimport logging
	import queue
	import threading

	# 创建一个队列用于存储日志消息
	log_queue = queue.Queue()

	# 创建异步处理器
	async_handler = logging.handlers.QueueHandler(log_queue)

	# 将异步处理器添加到日志记录器
	logger.addHandler(async_handler)

	# 创建异步日志记录线程
	def log_worker():
	while True:
	record = log_queue.get()
	if record is None:
	break
	logger.handle(record)

	# 启动异步日志记录线程
	log_thread = threading.Thread(target=log_worker, daemon=True)
	log_thread.start()

	# 记录日志消息（异步）
	logger.info("This is an asynchronous log message.")

	pythonCopy codeimport logging.config

	log_config = {
	'version': 1,
	'handlers': {
	'console': {
	'class': 'logging.StreamHandler',
	'level': 'DEBUG',
	},
	},
	'root': {
	'handlers': ['console'],
	'level': 'INFO',
	},
	}

	# 使用配置字典进行配置
	logging.config.dictConfig(log_config)

	# 记录日志消息
	logger.info("This log message is configured using a dictionary.")

	pythonCopy codefrom flask import Flask
	import logging

	app = Flask(__name__)

	# 配置日志记录器
	app.logger.setLevel(logging.DEBUG)
	app.logger.addHandler(logging.StreamHandler())

	pythonCopy codeimport logging
	import sqlite3

	class DatabaseHandler(logging.Handler):
	def __init__(self, db_path):
	super().__init__()
	self.db_path = db_path

	def emit(self, record):
	log_entry = self.format(record)

	# 将日志消息插入数据库
	with sqlite3.connect(self.db_path) as conn:
	conn.execute("INSERT INTO log_table (log_entry) VALUES (?)", (log_entry,))

	# 创建数据库处理程序
	db_handler = DatabaseHandler(db_path='app_logs.db')

	# 将数据库处理程序添加到日志记录器
	logger.addHandler(db_handler)

	# 记录日志消息，并将其存储到数据库中
	logger.info("This log message will be stored in the database.")

	pythonCopy codeimport logging
	import time

	def log_function_call(func):
	def wrapper(args, *kwargs):
	start_time = time.time()
	result = func(args, *kwargs)
	end_time = time.time()
	elapsed_time = end_time - start_time

	logging.info(f"{func.__name__} executed in {elapsed_time:.2f} seconds.")
	return result

	return wrapper

	# 应用装饰器来记录函数调用
	@log_function_call
	def example_function():
	# 一些需要记录执行时间的代码
	time.sleep(2)

	# 调用带有装饰器的函数
	example_function()

	pythonCopy codeimport logging
	from logging.handlers import RotatingFileHandler

	# 创建 RotatingFileHandler 处理程序，设置每个日志文件最大为 1MB，保留 3 个旧日志文件
	rotating_handler = RotatingFileHandler('app.log', maxBytes=1e6, backupCount=3)

	# 将处理程序添加到日志记录器
	logger.addHandler(rotating_handler)

	# 记录一些日志消息
	for i in range(10):
	logger.info(f"Log message {i}")

	pythonCopy codefrom loguru import logger

	# 配置日志输出格式
	logger.add("app.log", rotation="500 MB", level="INFO", format="{time:YYYY-MM-DD at HH:mm:ss} \| {level: <8} \| {message}")

	# 记录一些日志消息
	logger.info("This is an informational message.")
	logger.warning("This is a warning message.")
	logger.error("This is an error message.")

	pythonCopy codeimport logging
	import logging.handlers

	# 创建 SocketHandler 处理程序，将日志消息发送到指定的远程服务器和端口
	socket_handler = logging.handlers.SocketHandler('localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT)

	# 设置日志级别
	socket_handler.setLevel(logging.INFO)

	# 将处理程序添加到日志记录器
	logger.addHandler(socket_handler)

	# 记录一些日志消息
	logger.info("This log message will be sent to the remote server.")

	pythonCopy code# settings.py

	LOGGING = {
	'version': 1,
	'disable_existing_loggers': False,
	'handlers': {
	'file': {
	'level': 'DEBUG',
	'class': 'logging.FileHandler',
	'filename': 'django.log',
	},
	},
	'loggers': {
	'django': {
	'handlers': ['file'],
	'level': 'DEBUG',
	'propagate': True,
	},
	},
	}

	pythonCopy codeimport logging
	import logging.handlers

	# 创建 MemoryHandler 处理程序，将日志消息缓存到内存中
	memory_handler = logging.handlers.MemoryHandler(capacity=1024, flushLevel=logging.ERROR, target=logging.StreamHandler())

	# 设置日志级别
	memory_handler.setLevel(logging.DEBUG)

	# 将处理程序添加到日志记录器
	logger.addHandler(memory_handler)

	# 记录一些日志消息
	for i in range(10):
	logger.debug(f"Log message {i}")

	# 当发生错误时，将缓存的日志消息一次性输出
	try:
	result = 1 / 0
	except Exception as e:
	logger.error("An error occurred: %s", e)

	pythonCopy codeimport logging
	from logging.handlers import QueueHandler, QueueListener

	# 创建队列
	log_queue = multiprocessing.Queue()

	# 创建 QueueHandler 处理程序
	queue_handler = QueueHandler(log_queue)

	# 将处理程序添加到日志记录器
	logger.addHandler(queue_handler)

	# 创建 QueueListener
	queue_listener = QueueListener(log_queue, logging.StreamHandler())

	# 启动 QueueListener
	queue_listener.start()

	# 记录日志消息
	logger.info("This log message will be processed by QueueListener in a separate process.")

	# 停止 QueueListener
	queue_listener.stop()

	pythonCopy codeimport logging

	# 创建日志记录器
	logger = logging.getLogger(__name__)

	# 添加额外属性
	logger = logger.bind(request_id="12345", user_id="user123")

	# 记录带有额外属性的日志消息
	logger.info("Processing request.")

	pythonCopy codeimport logging

	# 创建 NullHandler 处理程序
	null_handler = logging.NullHandler()

	# 将处理程序添加到根日志记录器
	logging.getLogger().addHandler(null_handler)

	# 其他日志记录器配置...

	pythonCopy codeimport logging
	from rich.logging import RichHandler

	# 配置 logging，使用 RichHandler 处理程序
	logging.basicConfig(level=logging.INFO, handlers=[RichHandler()])

	# 记录一些日志消息
	logging.info("This log message will be displayed with rich formatting.")

	pythonCopy codeimport structlog

	# 使用 structlog 进行配置
	structlog.configure(
	processors=[
	structlog.stdlib.add_log_level,
	structlog.stdlib.add_logger_name,
	structlog.stdlib.PositionalArgumentsFormatter(),
	structlog.processors.TimeStamper(fmt="iso"),
	structlog.processors.JSONRenderer(),
	]
	)

	# 记录日志消息
	logger = structlog.get_logger()
	logger.info("This log message is formatted using structlog.")

	pythonCopy codeimport logging
	import aiohttp

	# 创建异步日志记录器
	async_logger = logging.getLogger("async_requests")

	async def make_request(url):
	async with aiohttp.ClientSession() as session:
	async with session.get(url) as response:
	# 记录异步请求的日志
	await async_logger.info("Request completed successfully.", extra={"url": url})

	# 运行异步请求
	await make_request("https://example.com")

	pythonCopy codefrom flask import Flask, request
	import logging

	app = Flask(__name__)

	# 创建请求和响应日志记录器
	request_logger = logging.getLogger("request_logger")

	@app.before_request
	def log_request_info():
	request_logger.info("Request received", extra={"method": request.method, "path": request.path})

	@app.after_request
	def log_response_info(response):
	request_logger.info("Response sent", extra={"status_code": response.status_code})
	return response