predawn 0.9.0

Predawn is a Rust web framework like Spring Boot.
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

use std::time::Instant;

use predawn_core::{error::Error, request::Request, response::Response};
use tracing::Instrument;

use super::Middleware;
use crate::handler::Handler;

#[derive(Clone, Copy)]
pub struct Tracing;

impl<H: Handler> Middleware<H> for Tracing {
    type Output = TracingHandler<H>;

    fn transform(self, input: H) -> Self::Output {
        TracingHandler { inner: input }
    }
}

pub struct TracingHandler<H> {
    inner: H,
}

impl<H: Handler> Handler for TracingHandler<H> {
    async fn call(&self, req: Request) -> Result<Response, Error> {
        let head = &req.head;

        let span = ::tracing::info_span!(
            target: module_path!(),
            "request",
            remote_addr = %head.remote_addr(),
            version = ?head.version,
            method = %head.method,
            uri = %head.original_uri(),
        );

        async move {
            let now = Instant::now();
            let result = self.inner.call(req).await;
            let duration = now.elapsed();

            match &result {
                Ok(response) => {
                    ::tracing::info!(
                        status = %response.status(),
                        duration = ?duration,
                        "response"
                    )
                }
                Err(error) => {
                    ::tracing::info!(
                        status = %error.status(),
                        duration = ?duration,
                        error = %error,
                        "error"
                    )
                }
            };

            result
        }
        .instrument(span)
        .await
    }
}