derust 0.1.1

Easy way to start your Rust asynchronous application server using Tokio and Axum frameworks.
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

use crate::httpx::tags::HttpTags;
use crate::httpx::HttpResponse;
use axum::http::StatusCode;
use axum_tracing_opentelemetry::tracing_opentelemetry_instrumentation_sdk::find_current_trace_id;
use serde_json::Value;

pub struct HttpError {
    status_code: StatusCode,
    error_message: String,
    response_body: Option<String>,
    response_headers: Option<Vec<(String, String)>>,
    tags: HttpTags,
}

impl HttpError {
    pub fn with_body(
        status_code: StatusCode,
        error_message: String,
        response_body: String,
        tags: HttpTags,
    ) -> Self {
        Self {
            status_code,
            error_message,
            response_body: Some(response_body),
            response_headers: None,
            tags,
        }
    }

    pub fn with_json(
        status_code: StatusCode,
        error_message: String,
        response_body: Value,
        tags: HttpTags,
    ) -> Self {
        let headers = vec![("Content-Type".to_string(), "application/json".to_string())];

        Self {
            status_code,
            error_message,
            response_body: Some(response_body.to_string()),
            response_headers: Some(headers),
            tags,
        }
    }

    pub fn without_body(status_code: StatusCode, error_message: String, tags: HttpTags) -> Self {
        Self {
            status_code,
            error_message,
            response_body: None,
            response_headers: None,
            tags,
        }
    }

    pub fn with_headers(mut self, response_headers: Vec<(String, String)>) -> Self {
        let mut headers: Vec<(String, String)> = self.response_headers.unwrap_or_default();

        for (key, value) in response_headers {
            headers.push((key, value));
        }

        self.response_headers = Some(headers);

        self
    }
}

impl HttpResponse for HttpError {
    fn status_code(&self) -> StatusCode {
        self.status_code
    }

    fn error_message(&self) -> Option<String> {
        Some(self.error_message.to_string())
    }

    fn response_body(&self) -> Option<String> {
        self.response_body.clone()
    }

    fn response_headers(&self) -> Option<Vec<(String, String)>> {
        self.response_headers.clone()
    }

    fn tags(&self) -> HttpTags {
        let mut tags = self.tags.clone();
        tags.add("error_message", &self.error_message);

        if !tags
            .values()
            .iter()
            .any(|(key, _)| key.to_uppercase() == "X-TRACE-ID".to_uppercase())
        {
            if let Some(trace_id) = find_current_trace_id() {
                tags.add("x-trace-id", &trace_id);
            }
        }

        tags
    }
}