import logging
# 基本的日志記錄
logging.debug("這是一條調(diào)試信息")
logging.info("這是一條信息")
logging.warning("這是一條警告")
logging.error("這是一條錯誤")
logging.critical("這是一條嚴(yán)重錯誤")

import logging
# 創(chuàng)建logger
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)
# 記錄日志
logger.debug("調(diào)試消息")
logger.info("信息消息")
logger.warning("警告消息")

import logging
# 創(chuàng)建logger
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)
# 控制臺handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# 文件handler
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.DEBUG)
# 添加handler
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# 記錄日志
logger.debug("只記錄到文件")
logger.info("同時記錄到控制臺和文件")

import logging
# 創(chuàng)建formatter
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
# 創(chuàng)建handler并設(shè)置formatter
handler = logging.StreamHandler()
handler.setFormatter(formatter)
# 使用handler
logger = logging.getLogger('my_app')
logger.addHandler(handler)
# 記錄日志
logger.info("格式化的日志消息")

logging.debug("消息")      # 調(diào)試級別
logging.info("消息")       # 信息級別
logging.warning("消息")     # 警告級別
logging.error("消息")       # 錯誤級別
logging.critical("消息")   # 嚴(yán)重錯誤級別

import logging
# 設(shè)置日志級別
logging.basicConfig(level=logging.DEBUG)
logging.debug("調(diào)試信息：程序開始執(zhí)行")
logging.info("信息：加載配置文件")
logging.warning("警告：配置文件版本可能過時")
logging.error("錯誤：無法連接到數(shù)據(jù)庫")
logging.critical("嚴(yán)重錯誤：系統(tǒng)即將崩潰")

import logging
# 獲取logger
logger = logging.getLogger('app')
# 設(shè)置日志級別
logger.setLevel(logging.INFO)  # 只記錄INFO及以上級別
# 針對不同級別有不同處理
if some_critical_condition:
    logger.critical("關(guān)鍵問題發(fā)生，需要立即處理")
elif some_error_condition:
    logger.error("發(fā)生錯誤，影響功能正常運(yùn)行")
else:
    logger.info("系統(tǒng)運(yùn)行正常")

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

import logging
# 基本配置
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='my_app.log',
    filemode='a'
)
# 現(xiàn)在所有日志都會寫入文件
logging.debug("調(diào)試信息")
logging.info("信息")

import logging
# 生產(chǎn)環(huán)境配置
logging.basicConfig(
    level=logging.WARNING,
    format='%(asctime)s [%(levelname)s] %(message)s',
    filename='production.log'
)
# 開發(fā)環(huán)境配置
import sys
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s %(name)s %(levelname)s: %(message)s',
    stream=sys.stdout  # 輸出到控制臺
)

logger = logging.getLogger('logger_name')
logger.debug("消息")

import logging
# 創(chuàng)建不同模塊的logger
db_logger = logging.getLogger('my_app.database')
web_logger = logging.getLogger('my_app.web')
user_logger = logging.getLogger('my_app.user')
# 配置logger級別
db_logger.setLevel(logging.DEBUG)
web_logger.setLevel(logging.INFO)
user_logger.setLevel(logging.WARNING)
# 記錄日志
db_logger.debug("數(shù)據(jù)庫連接建立")
db_logger.info("執(zhí)行SQL查詢")
web_logger.info("收到HTTP請求")
user_logger.warning("用戶嘗試訪問無權(quán)限的頁面")

import logging
import os
# 基于模塊名創(chuàng)建logger
logger = logging.getLogger(__name__)
# 如果logger還沒有配置，進(jìn)行基本配置
if not logger.handlers:
    handler = logging.StreamHandler()
    formatter = logging.Formatter(
        '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
    )
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)
# 使用logger
logger.debug("Debug message")
logger.info("App started")
logger.error("Failed to process request")

# StreamHandler - 輸出到控制臺
console_handler = logging.StreamHandler()
# FileHandler - 輸出到文件
file_handler = logging.FileHandler('app.log')
# RotatingFileHandler - 輪轉(zhuǎn)文件
from logging.handlers import RotatingFileHandler
rotating_handler = RotatingFileHandler(
    'app.log',
    maxBytes=1024*1024,  # 1MB
    backupCount=5
)
# TimedRotatingFileHandler - 按時間輪轉(zhuǎn)
from logging.handlers import TimedRotatingFileHandler
timed_handler = TimedRotatingFileHandler(
    'app.log',
    when='midnight',
    backupCount=7
)

import logging
from logging.handlers import RotatingFileHandler
# 創(chuàng)建logger
logger = logging.getLogger('app')
logger.setLevel(logging.DEBUG)
# 控制臺handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# 文件handler
file_handler = RotatingFileHandler(
    'app.log',
    maxBytes=1024*1024,  # 1MB
    backupCount=3,
    encoding='utf-8'
)
file_handler.setLevel(logging.DEBUG)
# 添加handler
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# 測試日志
logger.debug("這是調(diào)試信息，只記錄到文件")
logger.info("這是信息，同時記錄到控制臺和文件")

import logging
import sys
from logging.handlers import SMTPHandler
# 配置多輸出
logger = logging.getLogger('my_app')
# 控制臺輸出
console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.INFO)
console_format = logging.Formatter('%(levelname)s: %(message)s')
console.setFormatter(console_format)
# 文件輸出
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.DEBUG)
file_format = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(file_format)
# 郵件handler（僅用于嚴(yán)重錯誤）
mail_handler = SMTPHandler(
    mailhost=('smtp.example.com', 587),
    fromaddr='app@example.com',
    toaddrs=['admin@example.com'],
    subject='Application Error',
    credentials=('username', 'password'),
    secure=()
)
mail_handler.setLevel(logging.CRITICAL)
# 添加handler
logger.addHandler(console)
logger.addHandler(file_handler)
logger.addHandler(mail_handler)

web_logger/
├── main.py
├── logger_config.py
├── requirements.txt
└── logs/
    └── app.log

# logger_config.py
import logging
import logging.handlers
import os
from datetime import datetime
class WebLoggerConfig:
    def __init__(self, log_dir='logs'):
        self.log_dir = log_dir
        self.logger = logging.getLogger('web_server')
        self._setup_logger()
    def _setup_logger(self):
        # 確保日志目錄存在
        os.makedirs(self.log_dir, exist_ok=True)
        # 設(shè)置logger級別
        self.logger.setLevel(logging.DEBUG)
        # 清除現(xiàn)有的handler
        self.logger.handlers.clear()
        # 創(chuàng)建formatter
        detailed_formatter = logging.Formatter(
            '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        )
        # 控制臺handler
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.INFO)
        console_handler.setFormatter(detailed_formatter)
        # 文件handler - 主日志
        file_handler = logging.handlers.RotatingFileHandler(
            os.path.join(self.log_dir, 'app.log'),
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5,
            encoding='utf-8'
        )
        file_handler.setLevel(logging.DEBUG)
        file_handler.setFormatter(detailed_formatter)
        # 錯誤日志handler
        error_handler = logging.handlers.RotatingFileHandler(
            os.path.join(self.log_dir, 'error.log'),
            maxBytes=5*1024*1024,  # 5MB
            backupCount=3,
            encoding='utf-8'
        )
        error_handler.setLevel(logging.ERROR)
        error_handler.setFormatter(detailed_formatter)
        # 添加所有handler
        self.logger.addHandler(console_handler)
        self.logger.addHandler(file_handler)
        self.logger.addHandler(error_handler)
    def get_logger(self):
        return self.logger

# main.py
from logger_config import WebLoggerConfig
import random
import time
from datetime import datetime
# 初始化日志系統(tǒng)
logger_config = WebLoggerConfig()
logger = logger_config.get_logger()
def simulate_web_request(request_id):
    """模擬處理HTTP請求"""
    logger.info(f"收到請求 #{request_id}")
    # 模擬請求處理時間
    process_time = random.uniform(0.1, 2.0)
    time.sleep(process_time)
    # 模擬不同的響應(yīng)狀態(tài)
    status_code = random.choices(
        [200, 404, 500],
        weights=[0.8, 0.15, 0.05]
    )[0]
    # 記錄處理結(jié)果
    if status_code == 200:
        logger.debug(f"請求 #{request_id} 處理成功，耗時: {process_time:.2f}s")
        logger.info(f"響應(yīng) #{request_id}: {status_code} OK")
        return "OK"
    elif status_code == 404:
        logger.warning(f"請求 #{request_id}: 404 Not Found - 資源不存在")
        return "Not Found"
    else:
        logger.error(f"請求 #{request_id} 處理失敗，錯誤代碼: {status_code}")
        logger.error(f"詳細(xì)信息: 服務(wù)器內(nèi)部錯誤")
        return "Internal Server Error"
def main():
    """主程序"""
    logger.info("Web服務(wù)器啟動")
    logger.info("開始處理請求...")
    try:
        # 模擬處理100個請求
        for i in range(1, 101):
            result = simulate_web_request(i)
            # 每10個請求輸出統(tǒng)計信息
            if i % 10 == 0:
                logger.info(f"已處理 {i} 個請求")
    except KeyboardInterrupt:
        logger.warning("收到中斷信號，正在關(guān)閉服務(wù)器...")
    except Exception as e:
        logger.critical(f"服務(wù)器發(fā)生嚴(yán)重錯誤: {str(e)}", exc_info=True)
    finally:
        logger.info("Web服務(wù)器關(guān)閉")
if __name__ == "__main__":
    main()

# 安裝依賴（這個項(xiàng)目不需要額外依賴）
pip install -r requirements.txt
# 運(yùn)行程序
python main.py

import logging
# 定義自定義級別
logging.addLevelName(35, "TRACE")  # 比DEBUG更低的級別
logging.addLevelName(45, "NOTICE")  # 介于INFO和WARNING之間
def trace(self, message, *args, **kwargs):
    """TRACE級別方法"""
    if self.isEnabledFor(35):
        self._log(35, message, args, **kwargs)
def notice(self, message, *args, **kwargs):
    """NOTICE級別方法"""
    if self.isEnabledFor(45):
        self._log(45, message, args, **kwargs)
# 添加方法到Logger類
logging.Logger.trace = trace
logging.Logger.notice = notice
# 使用自定義級別
logger = logging.getLogger('app')
logger.trace("詳細(xì)的跟蹤信息")
logger.debug("調(diào)試信息")
logger.notice("需要注意的事項(xiàng)")
logger.info("常規(guī)信息")

import logging
class ContextAdapter(logging.LoggerAdapter):
    """帶上下文的Logger適配器"""
    def __init__(self, logger, extra=None):
        super().__init__(logger, extra or {})
    def process(self, msg, kwargs):
        # 為每條消息添加上下文
        kwargs['extra'] = kwargs.get('extra', {})
        kwargs['extra'].update(self.extra)
        return msg, kwargs
# 使用示例
logger = logging.getLogger('web_service')
adapter = ContextAdapter(logger, {
    'request_id': 'req-12345',
    'user_id': 'user-67890',
    'ip_address': '192.168.1.1'
})
# 記錄日志
adapter.info("用戶登錄成功")
adapter.error("數(shù)據(jù)庫連接失敗")
# 輸出示例：
# 2024-01-01 12:00:00 [INFO] web_service: 用戶登錄成功
#   request_id=req-12345 user_id=user-67890 ip_address=192.168.1.1

import logging
import logging.handlers
import queue
import time
from threading import Thread
class AsyncLogging:
    def __init__(self):
        self.log_queue = queue.Queue(-1)  # 無限隊(duì)列
        self.setup_logger()
    def setup_logger(self):
        # 配置logger
        logger = logging.getLogger('async_app')
        logger.setLevel(logging.DEBUG)
        # 創(chuàng)建QueueHandler
        queue_handler = logging.handlers.QueueHandler(self.log_queue)
        logger.addHandler(queue_handler)
        # 創(chuàng)建QueueListener
        file_handler = logging.FileHandler('async_app.log')
        file_handler.setFormatter(logging.Formatter(
            '%(asctime)s - %(levelname)s - %(message)s'
        ))
        # 啟動監(jiān)聽器線程
        self.listener = logging.handlers.QueueListener(
            self.log_queue,
            file_handler,
            respect_handler_level=True
        )
        self.listener.start()
        # 保存logger
        self.logger = logger
    def stop(self):
        """停止異步日志"""
        self.logger.info("正在關(guān)閉異步日志系統(tǒng)")
        self.listener.stop()
    def get_logger(self):
        return self.logger
# 使用異步日志
async_logger = AsyncLogging()
logger = async_logger.get_logger()
# 模擬高并發(fā)場景
def worker(worker_id):
    for i in range(10):
        logger.info(f"Worker {worker_id} 處理任務(wù) {i}")
        time.sleep(0.1)
# 創(chuàng)建多個線程
threads = []
for i in range(5):
    t = Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()
# 等待所有線程完成
for t in threads:
    t.join()
# 停止異步日志
async_logger.stop()

import logging
import json
from datetime import datetime
class JSONFormatter(logging.Formatter):
    """JSON格式的日志格式化器"""
    def format(self, record):
        log_data = {
            'timestamp': datetime.fromtimestamp(record.created).isoformat(),
            'level': record.levelname,
            'logger': record.name,
            'message': record.getMessage(),
            'module': record.module,
            'function': record.funcName,
            'line': record.lineno,
            'thread': record.thread,
            'process': record.process
        }
        # 添加異常信息
        if record.exc_info:
            log_data['exception'] = self.formatException(record.exc_info)
        # 添加額外的字段
        if hasattr(record, 'extra_data'):
            log_data.update(record.extra_data)
        return json.dumps(log_data, ensure_ascii=False)
# 配置結(jié)構(gòu)化日志
logger = logging.getLogger('structured')
logger.setLevel(logging.DEBUG)
# 文件handler
file_handler = logging.FileHandler('structured.log')
file_handler.setFormatter(JSONFormatter())
# 控制臺handler
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter(
    '%(levelname)s: %(message)s'
))
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# 記錄結(jié)構(gòu)化日志
logger.info("用戶登錄", extra={
    'user_id': '12345',
    'ip': '192.168.1.1',
    'device': 'mobile'
})
logger.error("數(shù)據(jù)庫操作失敗", exc_info=True)