nidus-http 1.0.14

Axum and Tower HTTP integration, controllers, middleware, health, metrics, and server defaults for Nidus.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Panic-catching middleware that preserves the response body type.
//!
//! Unlike `tower_http::catch_panic`, this layer keeps the response as
//! `Response<axum::body::Body>` so it composes with [`crate::error::ErrorEnvelopeLayer`].
//! Place it inside the envelope (as [`crate::middleware::ApiDefaults::production`] does)
//! so a handler panic surfaces as a structured `500` envelope with a request id and
//! metrics, instead of aborting the connection.

use std::{
    any::Any,
    panic::{AssertUnwindSafe, catch_unwind},
    task::{Context, Poll},
};

use axum::{body::Body, extract::Request};
use futures_util::{
    FutureExt,
    future::{CatchUnwind, Either, Map, Ready, ready},
};
use http::{Response, StatusCode};
use tower::{Layer, Service};

/// Creates a layer that catches panics from the inner service and maps them to a
/// `500 Internal Server Error` response.
///
/// See [`CatchPanicLayer`] for details.
pub fn catch_panic_layer() -> CatchPanicLayer {
    CatchPanicLayer
}

/// Tower layer that catches panics from the inner service.
///
/// On a panic the inner service's future is abandoned, the panic payload is
/// logged via `tracing::error!`, and a bare `500` response is returned. When
/// layered inside [`crate::error::ErrorEnvelopeLayer`] that `500` is rendered as
/// the production error envelope.
#[derive(Clone, Copy, Debug, Default)]
pub struct CatchPanicLayer;

impl<S> Layer<S> for CatchPanicLayer {
    type Service = CatchPanicService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        CatchPanicService { inner }
    }
}

/// Service produced by [`CatchPanicLayer`].
#[derive(Clone, Debug)]
pub struct CatchPanicService<S> {
    inner: S,
}

type PanicPayload = Box<dyn Any + Send + 'static>;
type CatchPanicResult<E> = Result<Result<Response<Body>, E>, PanicPayload>;
type CatchPanicResultMapper<E> = fn(CatchPanicResult<E>) -> Result<Response<Body>, E>;
type ImmediatePanicMapper<E> = fn(PanicPayload) -> Result<Response<Body>, E>;
type CatchPanicFuture<F, E> = Either<
    Map<CatchUnwind<AssertUnwindSafe<F>>, CatchPanicResultMapper<E>>,
    Map<Ready<PanicPayload>, ImmediatePanicMapper<E>>,
>;

impl<S> Service<Request> for CatchPanicService<S>
where
    S: Service<Request, Response = Response<Body>> + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Send + 'static,
{
    type Response = Response<Body>;
    type Error = S::Error;
    type Future = CatchPanicFuture<S::Future, S::Error>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, request: Request) -> Self::Future {
        // Catch a panic that occurs synchronously while starting the inner
        // service (e.g. inside `call`), then catch a panic that occurs while the
        // inner future is polled.
        match catch_unwind(AssertUnwindSafe(|| self.inner.call(request))) {
            Ok(future) => Either::Left(
                AssertUnwindSafe(future)
                    .catch_unwind()
                    .map(map_catch_panic_result::<S::Error> as CatchPanicResultMapper<S::Error>),
            ),
            Err(payload) => Either::Right(
                ready(payload)
                    .map(map_immediate_panic::<S::Error> as ImmediatePanicMapper<S::Error>),
            ),
        }
    }
}

fn map_catch_panic_result<E>(result: CatchPanicResult<E>) -> Result<Response<Body>, E> {
    match result {
        Ok(result) => result,
        Err(payload) => map_immediate_panic(payload),
    }
}

fn map_immediate_panic<E>(payload: PanicPayload) -> Result<Response<Body>, E> {
    log_panic(&payload);
    Ok(internal_server_error())
}

fn log_panic(payload: &PanicPayload) {
    if let Some(message) = payload.downcast_ref::<String>() {
        tracing::error!(http.status = 500, panic.message = %message, "request handler panicked");
    } else if let Some(message) = payload.downcast_ref::<&'static str>() {
        tracing::error!(http.status = 500, panic.message = %message, "request handler panicked");
    } else {
        tracing::error!(
            http.status = 500,
            "request handler panicked with non-string payload"
        );
    }
}

fn internal_server_error() -> Response<Body> {
    let mut response = Response::new(Body::empty());
    *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
    response
}