rama_http/layer/
catch_panic.rs

1//! Convert panics into responses.
2//!
3//! Note that using panics for error handling is _not_ recommended. Prefer instead to use `Result`
4//! whenever possible.
5//!
6//! # Example
7//!
8//! ```rust
9//! use std::convert::Infallible;
10//!
11//! use rama_http::{Request, Response, Body, header::HeaderName};
12//! use rama_http::layer::catch_panic::CatchPanicLayer;
13//! use rama_core::service::service_fn;
14//! use rama_core::{Context, Service, Layer};
15//! use rama_core::error::BoxError;
16//!
17//! # #[tokio::main]
18//! # async fn main() -> Result<(), BoxError> {
19//! async fn handle(req: Request) -> Result<Response, Infallible> {
20//!     panic!("something went wrong...")
21//! }
22//!
23//! let mut svc = (
24//!     // Catch panics and convert them into responses.
25//!     CatchPanicLayer::new(),
26//! ).into_layer(service_fn(handle));
27//!
28//! // Call the service.
29//! let request = Request::new(Body::default());
30//!
31//! let response = svc.serve(Context::default(), request).await?;
32//!
33//! assert_eq!(response.status(), 500);
34//! #
35//! # Ok(())
36//! # }
37//! ```
38//!
39//! Using a custom panic handler:
40//!
41//! ```rust
42//! use std::{any::Any, convert::Infallible};
43//!
44//! use rama_http::{Body, Request, StatusCode, Response, header::{self, HeaderName}};
45//! use rama_http::layer::catch_panic::CatchPanicLayer;
46//! use rama_core::service::{Service, service_fn};
47//! use rama_core::Layer;
48//! use rama_core::error::BoxError;
49//!
50//! # #[tokio::main]
51//! # async fn main() -> Result<(), BoxError> {
52//! async fn handle(req: Request) -> Result<Response, Infallible> {
53//!     panic!("something went wrong...")
54//! }
55//!
56//! fn handle_panic(err: Box<dyn Any + Send + 'static>) -> Response {
57//!     let details = if let Some(s) = err.downcast_ref::<String>() {
58//!         s.clone()
59//!     } else if let Some(s) = err.downcast_ref::<&str>() {
60//!         s.to_string()
61//!     } else {
62//!         "Unknown panic message".to_string()
63//!     };
64//!
65//!     let body = serde_json::json!({
66//!         "error": {
67//!             "kind": "panic",
68//!             "details": details,
69//!         }
70//!     });
71//!     let body = serde_json::to_string(&body).unwrap();
72//!
73//!     Response::builder()
74//!         .status(StatusCode::INTERNAL_SERVER_ERROR)
75//!         .header(header::CONTENT_TYPE, "application/json")
76//!         .body(Body::from(body))
77//!         .unwrap()
78//! }
79//!
80//! let svc = (
81//!     // Use `handle_panic` to create the response.
82//!     CatchPanicLayer::custom(handle_panic),
83//! ).into_layer(service_fn(handle));
84//! #
85//! # Ok(())
86//! # }
87//! ```
88
89use crate::{Body, HeaderValue, Request, Response, StatusCode};
90use futures_lite::future::FutureExt;
91use rama_core::{Context, Layer, Service};
92use rama_utils::macros::define_inner_service_accessors;
93use std::fmt;
94use std::{any::Any, panic::AssertUnwindSafe};
95
96/// Layer that applies the [`CatchPanic`] middleware that catches panics and converts them into
97/// `500 Internal Server` responses.
98///
99/// See the [module docs](self) for an example.
100pub struct CatchPanicLayer<T> {
101    panic_handler: T,
102}
103
104impl<T: fmt::Debug> fmt::Debug for CatchPanicLayer<T> {
105    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
106        f.debug_struct("CatchPanicLayer")
107            .field("panic_handler", &self.panic_handler)
108            .finish()
109    }
110}
111
112impl<T: Clone> Clone for CatchPanicLayer<T> {
113    fn clone(&self) -> Self {
114        Self {
115            panic_handler: self.panic_handler.clone(),
116        }
117    }
118}
119
120impl Default for CatchPanicLayer<DefaultResponseForPanic> {
121    fn default() -> Self {
122        Self::new()
123    }
124}
125
126impl CatchPanicLayer<DefaultResponseForPanic> {
127    /// Create a new `CatchPanicLayer` with the [`Default`]] panic handler.
128    pub const fn new() -> Self {
129        CatchPanicLayer {
130            panic_handler: DefaultResponseForPanic,
131        }
132    }
133}
134
135impl<T> CatchPanicLayer<T> {
136    /// Create a new `CatchPanicLayer` with a custom panic handler.
137    pub fn custom(panic_handler: T) -> Self
138    where
139        T: ResponseForPanic,
140    {
141        Self { panic_handler }
142    }
143}
144
145impl<T, S> Layer<S> for CatchPanicLayer<T>
146where
147    T: Clone,
148{
149    type Service = CatchPanic<S, T>;
150
151    fn layer(&self, inner: S) -> Self::Service {
152        CatchPanic {
153            inner,
154            panic_handler: self.panic_handler.clone(),
155        }
156    }
157
158    fn into_layer(self, inner: S) -> Self::Service {
159        CatchPanic {
160            inner,
161            panic_handler: self.panic_handler,
162        }
163    }
164}
165
166/// Middleware that catches panics and converts them into `500 Internal Server` responses.
167///
168/// See the [module docs](self) for an example.
169pub struct CatchPanic<S, T> {
170    inner: S,
171    panic_handler: T,
172}
173
174impl<S> CatchPanic<S, DefaultResponseForPanic> {
175    /// Create a new `CatchPanic` with the default panic handler.
176    pub const fn new(inner: S) -> Self {
177        Self {
178            inner,
179            panic_handler: DefaultResponseForPanic,
180        }
181    }
182}
183
184impl<S, T> CatchPanic<S, T> {
185    define_inner_service_accessors!();
186
187    /// Create a new `CatchPanic` with a custom panic handler.
188    pub const fn custom(inner: S, panic_handler: T) -> Self
189    where
190        T: ResponseForPanic,
191    {
192        Self {
193            inner,
194            panic_handler,
195        }
196    }
197}
198
199impl<S: fmt::Debug, T: fmt::Debug> fmt::Debug for CatchPanic<S, T> {
200    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
201        f.debug_struct("CatchPanic")
202            .field("inner", &self.inner)
203            .field("panic_handler", &self.panic_handler)
204            .finish()
205    }
206}
207
208impl<S: Clone, T: Clone> Clone for CatchPanic<S, T> {
209    fn clone(&self) -> Self {
210        CatchPanic {
211            inner: self.inner.clone(),
212            panic_handler: self.panic_handler.clone(),
213        }
214    }
215}
216
217impl<State, S, T, ReqBody, ResBody> Service<State, Request<ReqBody>> for CatchPanic<S, T>
218where
219    S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,
220    ResBody: Into<Body> + Send + 'static,
221    T: ResponseForPanic + Clone + Send + Sync + 'static,
222    ReqBody: Send + 'static,
223    ResBody: Send + 'static,
224    State: Clone + Send + Sync + 'static,
225{
226    type Response = Response;
227    type Error = S::Error;
228
229    async fn serve(
230        &self,
231        ctx: Context<State>,
232        req: Request<ReqBody>,
233    ) -> Result<Self::Response, Self::Error> {
234        let future = match std::panic::catch_unwind(AssertUnwindSafe(|| self.inner.serve(ctx, req)))
235        {
236            Ok(future) => future,
237            Err(panic_err) => return Ok(self.panic_handler.response_for_panic(panic_err)),
238        };
239        match AssertUnwindSafe(future).catch_unwind().await {
240            Ok(res) => match res {
241                Ok(res) => Ok(res.map(Into::into)),
242                Err(err) => Err(err),
243            },
244            Err(panic_err) => Ok(self.panic_handler.response_for_panic(panic_err)),
245        }
246    }
247}
248
249/// Trait for creating responses from panics.
250pub trait ResponseForPanic: Clone {
251    /// Create a response from the panic error.
252    fn response_for_panic(&self, err: Box<dyn Any + Send + 'static>) -> Response<Body>;
253}
254
255impl<F> ResponseForPanic for F
256where
257    F: Fn(Box<dyn Any + Send + 'static>) -> Response + Clone,
258{
259    fn response_for_panic(&self, err: Box<dyn Any + Send + 'static>) -> Response {
260        self(err)
261    }
262}
263
264/// The default `ResponseForPanic` used by `CatchPanic`.
265///
266/// It will log the panic message and return a `500 Internal Server` error response with an empty
267/// body.
268#[derive(Debug, Default, Clone)]
269#[non_exhaustive]
270pub struct DefaultResponseForPanic;
271
272impl ResponseForPanic for DefaultResponseForPanic {
273    fn response_for_panic(&self, err: Box<dyn Any + Send + 'static>) -> Response {
274        if let Some(s) = err.downcast_ref::<String>() {
275            tracing::error!("Service panicked: {}", s);
276        } else if let Some(s) = err.downcast_ref::<&str>() {
277            tracing::error!("Service panicked: {}", s);
278        } else {
279            tracing::error!(
280                "Service panicked but `CatchPanic` was unable to downcast the panic info"
281            );
282        };
283
284        let mut res = Response::new(Body::from("Service panicked"));
285        *res.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
286
287        #[allow(clippy::declare_interior_mutable_const)]
288        const TEXT_PLAIN: HeaderValue = HeaderValue::from_static("text/plain; charset=utf-8");
289        res.headers_mut()
290            .insert(rama_http_types::header::CONTENT_TYPE, TEXT_PLAIN);
291
292        res
293    }
294}
295
296#[cfg(test)]
297mod tests {
298    #![allow(unreachable_code)]
299
300    use super::*;
301
302    use crate::dep::http_body_util::BodyExt;
303    use crate::{Body, Response};
304    use rama_core::service::service_fn;
305    use rama_core::{Context, Service};
306    use std::convert::Infallible;
307
308    #[tokio::test]
309    async fn panic_before_returning_future() {
310        let svc = CatchPanicLayer::new().into_layer(service_fn(|_: Request| {
311            panic!("service panic");
312            async { Ok::<_, Infallible>(Response::new(Body::empty())) }
313        }));
314
315        let req = Request::new(Body::empty());
316
317        let res = svc.serve(Context::default(), req).await.unwrap();
318
319        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
320        let body = res.into_body().collect().await.unwrap().to_bytes();
321        assert_eq!(&body[..], b"Service panicked");
322    }
323
324    #[tokio::test]
325    async fn panic_in_future() {
326        let svc = CatchPanicLayer::new().into_layer(service_fn(async |_: Request<Body>| {
327            panic!("future panic");
328            Ok::<_, Infallible>(Response::new(Body::empty()))
329        }));
330
331        let req = Request::new(Body::empty());
332
333        let res = svc.serve(Context::default(), req).await.unwrap();
334
335        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
336        let body = res.into_body().collect().await.unwrap().to_bytes();
337        assert_eq!(&body[..], b"Service panicked");
338    }
339}
rama_http/layer/catch_panic.rs

rama_http/layer/
catch_panic.rs
