How can I print stack trace that collected by anyhow or thiserror?

[tomocrafter]

I would like to make my app that prints error to stdout with tracing when handler returned Result::Err. but seems like returning Result type from handler just turns into response with IntoResponse trait.

How can I make it prints stack trace or prints struct with debug when handler returned Result::Err?

or, is there anything best practice to use anyhow and thiserror with axum (I would like to hear that not uses those crates if exists!)?

Thank you.

[davidpdrsn]

You have to make a newtype wrapper for anyhow::Error and implement IntoResponse for it an print the stack trace in that implementation.

[tomocrafter]

Thank you for quick reply!
I definitely try that. Is there anyone who implemented that and publsihed code ? If so, I would like to see that.

[davidpdrsn]

Not that I know off.

[jetaggart]

In case this helps, this is what I came up with:

async fn get_something(
    Extension(something): Extension<Something>,
) -> Result<impl IntoResponse, AppError> {
    something.fails().await?;
    Ok(Json(json!("{}")))
}

enum AppError {
    InternalServerError(anyhow::Error),
    ValidationError,
}

impl From<anyhow::Error> for AppError {
    fn from(inner: anyhow::Error) -> Self {
        AppError::InternalServerError(inner)
    }
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, error_message) = match self {
            AppError::InternalServerError(inner) => {
                tracing::debug!("stacktrace: {}", inner.backtrace());
                (StatusCode::INTERNAL_SERVER_ERROR, "something went wrong")
            }
            AppError::ValidationError => {
                (StatusCode::UNPROCESSABLE_ENTITY, "validation errors")
            }
        };

        let body = Json(json!({
            "error": error_message,
        }));

        (status, body).into_response()
    }
}

[freopen]

That approach doesn't work for anyhow macros like bail!() and ensure!() because they are replaced with return Err(anyhow_error); so no implicit .into() is happening like with ? operator. Is there an easy way to make macros work too?

[jplatte]

No, there is no way to use functions that return anyhow::Result as a handler directly.

[kbarros]

Thanks, this is really helpful. I wonder if an example like this should be included in the docs at https://docs.rs/axum/latest/axum/error_handling/index.html?

[davidpdrsn]

Thanks, this is really helpful. I wonder if an example like this should be included in the docs at https://docs.rs/axum/latest/axum/error_handling/index.html?

No I don't think so. That module is about handling errors from services or middleware. Not handlers which always return responses.

[davidpdrsn]

We could perhaps add it here https://github.com/tokio-rs/axum/blob/main/examples/anyhow-error-response/src/main.rs

[kbarros]

I think the current example is fully sufficient, but what might be missing is discoverability of that example. Is there a prominent place to link to it?

[davidpdrsn]

Not sure. It is very common to have examples in the root and the readme also points to them.

Where would you link it?

[kbarros]

I'm not sure. In my case, I started with the top level Axum docs. Even though I'm new to both Rust and web services, the example code was already enough for me to get running! I stumbled on errors, though, because the "Error handling" section links to the error_handling docs, and I didn't realize that that module is specific to services (I don't really even know what services are). Maybe the top-level Axum docs could be expanded, saying something like

To respond to errors in standard handlers, it is straightforward to define conversions from existing error types [link to Anyhow example]. Errors in custom services or middleware can also be handled [link to error_handling module docs].