Python脚本如何记录不同类型异常日志

本文目录导读：

1. 基础日志配置
2. 记录不同类型的异常
3. 自定义异常处理器
4. 带详细信息的异常日志记录
5. 装饰器方式记录异常
6. 完整的异常日志系统
7. 使用建议

我来帮你实现Python脚本中不同类型异常的日志记录,以下是几种常用的方法：

基础日志配置

import logging
import traceback
# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('app.log', encoding='utf-8'),
        logging.StreamHandler()  # 同时输出到控制台
    ]
)
logger = logging.getLogger(__name__)

记录不同类型的异常

def handle_exceptions():
    try:
        # 示例：不同类型的异常
        # 1. ValueError
        int("abc")
    except ValueError as e:
        logger.error(f"值错误: {e}", exc_info=True)  # 包含堆栈信息
    except TypeError as e:
        logger.error(f"类型错误: {e}")
    except FileNotFoundError as e:
        logger.error(f"文件未找到: {e}")
    except Exception as e:
        logger.critical(f"未预期的错误: {e}", exc_info=True)

自定义异常处理器

class ExceptionLogger:
    """异常日志记录器"""
    def __init__(self, logger):
        self.logger = logger
    def log_exception(self, exception, context=None):
        """记录异常信息"""
        error_info = {
            'exception_type': type(exception).__name__,
            'exception_message': str(exception),
            'stack_trace': traceback.format_exc(),
            'context': context or {}
        }
        # 根据异常类型使用不同日志级别
        if isinstance(exception, (ValueError, TypeError)):
            self.logger.warning(f"业务异常: {error_info}")
        elif isinstance(exception, (IOError, ConnectionError)):
            self.logger.error(f"系统异常: {error_info}")
        else:
            self.logger.critical(f"严重异常: {error_info}")
# 使用示例
handler = ExceptionLogger(logger)
try:
    # 业务逻辑
    result = 1 / 0
except Exception as e:
    handler.log_exception(e, {'user': 'admin', 'operation': 'division'})

带详细信息的异常日志记录

import sys
from datetime import datetime
def detailed_exception_log(exception, verbose=True):
    """详细记录异常信息"""
    exc_type, exc_value, exc_traceback = sys.exc_info()
    log_entry = {
        'timestamp': datetime.now().isoformat(),
        'error_type': exc_type.__name__,
        'error_message': str(exc_value),
        'file': exc_traceback.tb_frame.f_code.co_filename if exc_traceback else None,
        'line': exc_traceback.tb_lineno if exc_traceback else None,
        'function': exc_traceback.tb_frame.f_code.co_name if exc_traceback else None
    }
    if verbose:
        log_entry['stack_trace'] = traceback.format_exc()
        # 获取调用栈信息
        stack = []
        tb = exc_traceback
        while tb:
            stack.append({
                'file': tb.tb_frame.f_code.co_filename,
                'line': tb.tb_lineno,
                'function': tb.tb_frame.f_code.co_name
            })
            tb = tb.tb_next
        log_entry['stack_frames'] = stack
    return log_entry
# 使用示例
try:
    # 一些可能出错的代码
    x = [1, 2, 3]
    print(x[10])
except Exception as e:
    log_data = detailed_exception_log(e)
    logger.error(f"异常详情: {json.dumps(log_data, indent=2)}")

装饰器方式记录异常

import functools
def log_exceptions(logger_level='error'):
    """异常日志装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                # 获取日志级别
                log_func = getattr(logger, logger_level, logger.error)
                # 记录异常信息
                log_func(
                    f"函数 {func.__name__} 执行异常:\n"
                    f"参数: args={args}, kwargs={kwargs}\n"
                    f"错误: {e}\n"
                    f"堆栈: {traceback.format_exc()}"
                )
                raise
        return wrapper
    return decorator
# 使用示例
@log_exceptions(logger_level='critical')
def risky_operation(data):
    """可能抛出异常的函数"""
    return 1 / data
# 测试
try:
    risky_operation(0)
except ZeroDivisionError:
    pass  # 错误已被记录

完整的异常日志系统

import logging
import traceback
import json
from datetime import datetime
from functools import wraps
class AdvancedExceptionLogger:
    """高级异常日志系统"""
    def __init__(self, log_file='advanced_exception.log'):
        self.logger = logging.getLogger('AdvancedLogger')
        self.logger.setLevel(logging.DEBUG)
        # 文件处理器
        file_handler = logging.FileHandler(log_file, encoding='utf-8')
        file_handler.setLevel(logging.DEBUG)
        # 格式器
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        file_handler.setFormatter(formatter)
        self.logger.addHandler(file_handler)
    def log_exception(self, exception, context=None, severity='error'):
        """记录异常并返回结构化信息"""
        exc_type, exc_value, exc_traceback = sys.exc_info()
        # 构建结构化日志
        log_data = {
            'timestamp': datetime.now().isoformat(),
            'severity': severity,
            'exception': {
                'type': exc_type.__name__,
                'message': str(exc_value),
                'traceback': traceback.format_exc()
            },
            'context': context or {},
            'app_info': {
                'python_version': sys.version,
                'platform': sys.platform
            }
        }
        # 根据严重程度选择日志级别
        log_methods = {
            'debug': self.logger.debug,
            'info': self.logger.info,
            'warning': self.logger.warning,
            'error': self.logger.error,
            'critical': self.logger.critical
        }
        log_method = log_methods.get(severity, self.logger.error)
        log_method(f"异常日志: {json.dumps(log_data, ensure_ascii=False, indent=2)}")
        return log_data
# 使用示例
exception_logger = AdvancedExceptionLogger()
try:
    # 模拟不同类型异常
    data = {"key": "value"}
    print(data["non_existent_key"])
except KeyError as e:
    exception_logger.log_exception(
        e, 
        context={'function': 'data_processing', 'data_id': 123},
        severity='warning'
    )
except Exception as e:
    exception_logger.log_exception(e, severity='error')
finally:
    # 清理资源
    pass

使用建议

1. 选择合适的日志级别：

   • DEBUG: 调试信息
   • INFO: 正常操作信息
   • WARNING: 潜在问题
   • ERROR: 错误但不影响系统运行
   • CRITICAL: 严重错误

2. 记录足够的上下文信息：

   • 执行时间
   • 用户/操作信息
   • 参数值（注意敏感信息）
   • 系统状态

3. 避免记录敏感信息：

   • 密码、令牌
   • 个人身份信息
   • 信用卡号等

4. 日志管理：

   • 使用日志轮转
   • 定期清理旧日志
   • 设置合理的日志大小限制

这些方法可以帮助你有效地记录和分析不同类型的异常,便于问题排查和系统监控。