Rust错误处理增强库err-context使用指南

err-context是一个Rust错误处理增强库，它专注于为错误链添加上下文信息，使调试过程更加高效。这个库特别适合需要追踪错误来源和传播路径的复杂应用。

核心功能

• 为错误添加上下文信息
• 构建清晰的错误传播链
• 保持原始错误不变的同时增加调试信息
• 与标准库的std::error::Error trait无缝集成

基本用法

首先添加依赖：

[dependencies]
err-context = "0.3"

基本示例

use err_context::{ResultExt, AnyError};

fn read_config() -> Result<String, AnyError> {
    std::fs::read_to_string("config.toml")
        .context("Failed to read config file")
}

fn parse_config() -> Result<(), AnyError> {
    let config = read_config()?;
    // 解析配置...
    Ok(())
}

fn main() {
    if let Err(e) = parse_config() {
        eprintln!("Error: {}", e);
        // 输出类似：
        // Error: Failed to read config file: No such file or directory (os error 2)
    }
}

高级特性

自定义上下文

use err_context::BoxedError;

fn process_data(data: &str) -> Result<(), BoxedError> {
    if data.is_empty() {
        return Err("Empty input data".into())
            .context("Validation failed");
    }
    
    // 处理数据...
    Ok(())
}

错误链遍历

fn print_error_chain(e: &dyn std::error::Error) {
    eprintln!("Error: {}", e);
    
    let mut source = e.source();
    while let Some(s) = source {
        eprintln!("Caused by: {}", s);
        source = s.source();
    }
}

与anyhow集成

use err_context::ResultExt;
use anyhow::Result;

fn read_file(path: &str) -> Result<String> {
    std::fs::read_to_string(path)
        .context(format!("Failed to read file: {}", path))
}

实际应用场景

数据库操作

use err_context::{ResultExt, AnyError};
use sqlx::PgPool;

async fn get_user(pool: &PgPool, user_id: i32) -> Result<User, AnyError> {
    sqlx::query_as!(
        User,
        "SELECT * FROM users WHERE id = $1",
        user_id
    )
    .fetch_one(pool)
    .await
    .context("Failed to fetch user from database")?
    .context(format!("User with ID {} not found", user_id))
}

Web服务错误处理

use err_context::ResultExt;
use actix_web::{web, HttpResponse, Responder};

async fn get_user_handler(
    pool: web::Data<PgPool>,
    user_id: web::Path<i32>
) -> impl Responder {
    match get_user(&pool, user_id.into_inner()).await {
        Ok(user) => HttpResponse::Ok().json(user),
        Err(e) => {
            eprintln!("Error: {}", e);
            HttpResponse::InternalServerError().finish()
        }
    }
}

完整示例demo

下面是一个完整的Web服务示例，展示err-context在实际项目中的应用：

use std::fmt;
use err_context::{ResultExt, AnyError, BoxedError};
use actix_web::{get, App, HttpResponse, HttpServer, Responder, web};
use serde::{Serialize, Deserialize};
use sqlx::postgres::PgPoolOptions;

// 用户数据结构
#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: i32,
    name: String,
    email: String,
}

// 自定义错误类型
#[derive(Debug)]
enum AppError {
    DbError(String),
    ValidationError(String),
    NotFound(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::DbError(msg) => write!(f, "Database error: {}", msg),
            AppError::ValidationError(msg) => write!(f, "Validation error: {}", msg),
            AppError::NotFound(msg) => write!(f, "Not found: {}", msg),
        }
    }
}

impl std::error::Error for AppError {}

// 数据库操作
async fn get_user(pool: &sqlx::PgPool, user_id: i32) -> Result<User, BoxedError> {
    // 查询用户
    let user = sqlx::query_as!(
        User,
        "SELECT id, name, email FROM users WHERE id = $1",
        user_id
    )
    .fetch_one(pool)
    .await
    .context("Failed to execute database query")?;
    
    // 验证用户数据
    if user.name.is_empty() {
        return Err(AppError::ValidationError("User name cannot be empty".into()))
            .context("Invalid user data");
    }
    
    Ok(user)
}

// Web处理函数
#[get("/users/{id}")]
async fn user_handler(
    pool: web::Data<sqlx::PgPool>,
    user_id: web::Path<i32>
) -> impl Responder {
    match get_user(&pool, user_id.into_inner()).await {
        Ok(user) => HttpResponse::Ok().json(user),
        Err(e) => {
            // 打印完整错误链
            println!("Error chain:");
            let mut current: &dyn std::error::Error = &e;
            println!("- {}", current);
            while let Some(source) = current.source() {
                println!("- caused by: {}", source);
                current = source;
            }
            
            HttpResponse::InternalServerError().json("Internal server error")
        }
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 初始化数据库连接池
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://user:password@localhost/db")
        .await
        .context("Failed to connect to database")?;

    // 启动Web服务器
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))
            .service(user_handler)
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

最佳实践

1. 在错误传播的关键节点添加上下文
2. 保持上下文信息简洁但足够明确
3. 避免过度包装错误导致链条过长
4. 在顶层处理错误时打印完整错误链

err-context通过简单的API为Rust的错误处理提供了强大的上下文追踪能力，特别适合中大型项目中的错误管理和调试。