Implementing Rust newtype for errors in axum

goddtriffin8 bulan yang lalu

Great post. I do the same thing for all of my Rust web servers too. I don't use anyhow though, prefer rolling everything myself - which as you call out is a pain after a while.

ruptwelve8 bulan yang lalu

`Anyhow` is a great thing to get you started. But ultimately you wanna use some bespoke errors, and just roll your own!

vsgherzi8 bulan yang lalu

would you get backtraces with this implementation? I've been increasingly frustrated with axum. It hits my custom error where I print something like "sqlx database failed" but when there's lots of traffic it's hard to determine which of the hundreds of queries actually failed. What I really want is the top part of a backtrace or at least a line number. I know anyhow gives bts but will it actually be useful when used like this?

Anyone else have ideas on how to solve this?

dlahoda8 bulan yang lalu

i do not see problems with axum.

we wrote some macro(with muncher) which allows strongly typed and yet dry per method error, error split of public part vs internal log only(with backtrace crate trace capture), full openapi support(via schemars) and we do not use anyhow.

whole article is rot and bad advice.

vsgherzi8 bulan yang lalu

mind sharing a link?

dlahoda8 bulan yang lalu

end result is here https://zo-devnet.n1.xyz/docs - well documented strongly typed errors for API. most eveolved

https://zo-devnet.n1.xyz/docs#tag/default/post/action - mixes binary encoding, headers, and numeric errors embeeding (http goes to binary tx format).

all strongly typed without duplicated boilerplate.

inside - ad hoc error assembly - display_doc,derive_more, backtrace - no anyhow, not thiserror, no snafu.

fail fast and panic a lot, covered by proptests(toward fuzzytests).

used https://github.com/target-san/scoped-panic-hook to catch panics as exceptions.

was thinking to use https://github.com/iex-rs/lithium

panics = bugs or undefinenide behavour.

dlahoda8 bulan yang lalu

used like this

``` pub async fn account_pubkey( GetAccountPubkey { account_id }: GetAccountPubkey, State(st): State<AppState>, ) -> Response!(RegistrationKey; not_found: UserNotFound) { ```

``` pub async fn action( SubmitAction {}: SubmitAction, State(st): State<AppState>, TypedHeader(content_type): TypedHeader<headers::ContentType>, body: axum::body::Bytes, ) -> Result< axum::body::Bytes, ApiError!(unsupported_media_type: AcceptedMediaType, payload_too_large: PayloadTooLarge), > { ```

as you see limitation of ast macro - single entity per code. to do more - need proc macro.

default response is json

``` #[macro_export] macro_rules! Response { ($ty:ty) => { Result<::axum::Json<$ty>, $crate::http::error::Error<()>> }; ($ty:ty; $($var:ident : $e:ty),) => { Result<::axum::Json<$ty>, nord_core::ApiError!($($var : $e),)> }; } ```

use ApiError for other mime types

``` #[macro_export] macro_rules! ApiError { ( $($var:ident : $e:ty),* $(,)? ) => { nord_core::ApiError!({ $($var : $e,)* }) }; () => { $crate::http::error::Error::<()> }; ({ $($var:ident : $e:ty),* $(,)? }) => { nord_core::ApiError!( @internal bad_request: $crate::http::error::Infallible, not_found: $crate::http::error::Infallible, forbidden: $crate::http::error::Infallible, unsupported_media_type: $crate::http::error::Infallible, payload_too_large: $crate::http::error::Infallible, not_implemented: $crate::http::error::Infallible, | $($var : $e,)* ) }; ( @internal bad_request: $bad_request:ty, not_found: $not_found:ty, forbidden: $forbidden:ty, unsupported_media_type: $unsupported_media_type:ty, payload_too_large: $payload_too_large:ty, not_implemented: $not_implemented:ty, | // empty ) => { $crate::http::error::Error<( $bad_request, $not_found, $forbidden, $unsupported_media_type, $payload_too_large, $not_implemented, )> }; ( @internal bad_request: $_:ty, not_found: $not_found:ty, forbidden: $forbidden:ty, unsupported_media_type: $unsupported_media_type:ty, payload_too_large: $payload_too_large:ty, not_implemented: $not_implemented:ty, | bad_request: $bad_request:ty, $($rest:tt)* ) => { nord_core::ApiError!( @internal bad_request: $bad_request, not_found: $not_found, forbidden: $forbidden, unsupported_media_type: $unsupported_media_type, payload_too_large: $payload_too_large, not_implemented: $not_implemented, | $($rest)* ) };

.... crazy a lot of repeated code of recursive tt muncher

```

error can be custom:

``` #[derive(Debug, serde::Serialize, serde::Deserialize, schemars::JsonSchema)] pub struct AcceptedMediaType { pub expected: String, }

impl ExpectedMimeType for AcceptedMediaType { fn expected(&self) -> &str { &self.expected } }

impl AcceptedMediaType { pub fn new(value: headers::ContentType) -> Self { Self { expected: value.to_string(), } } } ```

each method has its own error as needed.

openapi integration ```

impl<ST: StatusTypes> aide::OperationOutput for Error<ST> { type Inner = Self;

    fn inferred_responses(
        cx: &mut aide::generate::GenContext,
        op: &mut aide::openapi::Operation,
    ) -> Vec<(Option<u16>, aide::openapi::Response)> {
        [
            <ST::BadRequest as OperationOutputInternal>::operation_response(cx, op)
                .map(|x| (Some(400), x)),
              ....
            <ST::UnsupportedMediaType as OperationOutputInternal>::operation_response(cx, op).map(
                |mut x| {
                    use aide::openapi::{
                        Header, ParameterSchemaOrContent, ReferenceOr, SchemaObject,
                    };
                    let header = Header {
                        description: Some("Expected request media type".into()),
                        style: Default::default(),
                        required: true,
                        deprecated: None,
                        format: ParameterSchemaOrContent::Schema(SchemaObject {
                            json_schema: schemars::schema::Schema::Object(
                                schemars::schema_for!(String).schema,
                            ),
                            external_docs: None,
                            example: None,
                        }),
                        example: Some(serde_json::json!(
                            mime::APPLICATION_OCTET_STREAM.to_string()
                        )),
                        examples: Default::default(),
                        extensions: Default::default(),
                    };
                    x.headers
                        .insert(header::ACCEPT.to_string(), ReferenceOr::Item(header));
                    (Some(415), x)
                },
            ),
            ...
            <ST::NotImplemented as OperationOutputInternal>::operation_response(cx, op)
                .map(|x| (Some(501), x)),
        ]
        .into_iter()
        .flatten()
        .collect()
    }

} ```

user vs internal errors - tracing:

``` impl<ST: StatusTypes> IntoResponse for Error<ST> where ST: StatusTypes, { fn into_response(self) -> axum::response::Response { let status = self.status_code(); match self { Self::Internal(error) => { let error = &error as &dyn std::error::Error; tracing::error!(error, "internal error during http request"); (status, Json("INTERNAL SERVER ERROR")).into_response() } Self::Forbidden(e) => (status, Json(e)).into_response(), Self::UnsupportedMediaType(e) => { let value = HeaderValue::from_str(e.expected()); let mut resp = (status, Json(e)).into_response(); if let Ok(value) = value { resp.headers_mut().insert(header::ACCEPT, value); } resp } Self::PayloadTooLarge(e) => (status, Json(e)).into_response(), ... } } }

```

and types sugar ``` mod typelevel {

/// No client error defined; this type can't be constructed. #[derive(Debug, Serialize, Deserialize)] pub enum Infallible {} impl ExpectedMimeType for Infallible { fn expected(&self) -> &str { unreachable!("Infallible") } } pub trait ExpectedMimeType { fn expected(&self) -> &str; } pub trait StatusTypes { type BadRequest: serde::Serialize + OperationOutputInternal; type UnsupportedMediaType: serde::Serialize + OperationOutputInternal + ExpectedMimeType; ... } impl StatusTypes for () { type BadRequest = Infallible; type NotFound = Infallible;
... }

impl StatusTypes for Infallible { type BadRequest = Infallible; type NotFound = Infallible;
.. }

impl< BadRequest: serde::Serialize + OperationOutputInternal, NotFound: serde::Serialize + OperationOutputInternal, Forbidden: serde::Serialize + OperationOutputInternal, UnsupportedMediaType: serde::Serialize + OperationOutputInternal + ExpectedMimeType, PayloadTooLarge: serde::Serialize + OperationOutputInternal, NotImplemented: serde::Serialize + OperationOutputInternal, > StatusTypes for ( BadRequest, NotFound, Forbidden, UnsupportedMediaType, PayloadTooLarge, NotImplemented, ) { type BadRequest = BadRequest; type NotFound = NotFound; type Forbidden = Forbidden; type UnsupportedMediaType = UnsupportedMediaType; type PayloadTooLarge = PayloadTooLarge; type NotImplemented = NotImplemented; }
... }

use typelevel::;

#[derive(Debug)] pub enum Error<ST: StatusTypes> { Internal(Box<dyn std::error::Error + Send + Sync>), BadRequest(ST::BadRequest), ... }

impl std::fmt::Display for Infallible { fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match *self {} } }

impl<ST: StatusTypes> Error<ST> { pub fn internal(value: impl std::error::Error + Send + Sync + 'static) -> Self { Self::Internal(Box::new(value)) }

    pub fn bad_request(value: ST::BadRequest) -> Self {
        Self::BadRequest(value)
    }

    pub fn not_found(value: ST::NotFound) -> Self {
        Self::NotFound(value)
    }

    pub fn forbidden(value: ST::Forbidden) -> Self {
        Self::Forbidden(value)
    }

```

hobs8 bulan yang lalu

Like the post, but the backticks on all sorts of things is very distracting - am I missing some value here?

ruptwelve8 bulan yang lalu

I'll chalk that up to my Astro theme. It's supposed to be just `Something` and the backticks should have not been visible! Sorry!

robdahaldev8 bulan yang lalu

Implementing Rust newtype for errors in axum(rup12.net)

10 comments