如何在Rust使用?运算符出错时记录含详细信息的错误到文件？

Hey there! Let's break this down clearly:

First off, the two lines of code you shared will NOT automatically log those detailed error details (filename, line number, function name, error code) to a file when they fail.

Why isn't this automatic? #

Rust's ? operator is built for one core job: propagating errors up the call stack. When it hits an Err(e), it just returns that error from the current function (assuming the function returns a Result type). It doesn't include any built-in logging or recording logic—this is intentional, keeping Rust's error handling lightweight and flexible so you can add exactly the behavior you need.

How to add automatic error logging with ? #

To get the behavior you want (auto-logging those details when ? triggers an error), you'll need to wrap your error handling to include that logging logic. Here's a practical, step-by-step implementation:

1. Create a custom error type to hold context #

First, we'll make an error type that wraps the original error and carries the context info (file, line, function):

use std::fmt;
use std::error::Error;

#[derive(Debug)]
struct LoggedError<E> {
    source: E,
    file: &'static str,
    line: u32,
    function: &'static str,
}

// Implement Error trait to support standard error handling
impl<E: Error> Error for LoggedError<E> {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&self.source)
    }
}

// Implement Display to make the error human-readable
impl<E: fmt::Display> fmt::Display for LoggedError<E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Error occurred in {}:{} (function {}): {}",
            self.file, self.line, self.function, self.source
        )
    }
}

2. Add a trait extension to Result for logging #

Next, we'll extend the Result type with a method that logs errors automatically before propagating them:

use std::fs::OpenOptions;
use std::io::Write;
use std::result::Result;

trait LogResult<T, E: Error> {
    fn log_on_error(self) -> Result<T, LoggedError<E>>;
}

impl<T, E: Error> LogResult<T, E> for Result<T, E> {
    fn log_on_error(self) -> Result<T, LoggedError<E>> {
        match self {
            Ok(value) => Ok(value),
            Err(original_error) => {
                // Grab the context info using Rust's built-in macros
                let file = file!();
                let line = line!();
                let function = function!();
                
                // Write the error details to a log file
                let mut log_file = OpenOptions::new()
                    .create(true)
                    .append(true)
                    .open("error_logs.txt")
                    .expect("Failed to open error log file");
                
                let log_entry = format!(
                    "[{}] {}:{} | Function: {} | Error: {}\n",
                    chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
                    file, line, function, original_error
                );
                writeln!(log_file, "{}", log_entry).expect("Failed to write to error log");
                
                // Return the wrapped error with context
                Err(LoggedError {
                    source: original_error,
                    file,
                    line,
                    function,
                })
            }
        }
    }
}

Note: I added a timestamp using the chrono crate here—you'll need to add chrono = "0.4" to your Cargo.toml if you want that, or remove the timestamp line if not.

3. Use it in your code #

Now you can chain .log_on_error() with ? to get automatic logging whenever an error is propagated:

fn do_some_function_may_return_error() -> Result<i32, std::io::Error> {
    // Simulate an error
    Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "No access to resource"))
}

fn do_another_function_may_return_error(a: i32) -> Result<String, std::io::Error> {
    // Simulate another error
    Err(std::io::Error::new(std::io::ErrorKind::NotFound, "Requested file missing"))
}

fn main() -> Result<(), LoggedError<std::io::Error>> {
    let a = do_some_function_may_return_error().log_on_error()?;
    let b = a.do_another_function_may_return_error().log_on_error()?;
    Ok(())
}

Quick extra tips #

• If you want to avoid typing .log_on_error() every time, you can create a custom macro like log? that combines the logging and propagation in one step.
• For production code, consider using established logging crates like log with file-rotate or env_logger instead of manual file writes—they handle things like log rotation, log levels, and formatting more robustly.

内容的提问来源于stack exchange，提问作者Jinshou He