oauth10a 3.0.0

A rust implementation of the oauth 1.0a protocol fully-async with logging, metrics and tracing facilities
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

use core::fmt;
use std::sync::Arc;
#[cfg(feature = "metrics")]
use std::time::Instant;

#[cfg(feature = "metrics")]
use crate::metrics;

/// HTTP Client.
pub trait ExecuteRequest: fmt::Debug + Send + Sync + 'static {
    type Error: Send + 'static;

    /// Execute the HTTP request.
    ///
    /// # Errors
    ///
    /// If the client fails to send the request.
    fn execute_request(
        &self,
        request: reqwest::Request,
    ) -> impl Future<Output = Result<reqwest::Response, Self::Error>> + Send + 'static;
}

impl ExecuteRequest for reqwest::Client {
    type Error = reqwest::Error;

    #[inline]
    fn execute_request(
        &self,
        request: reqwest::Request,
    ) -> impl Future<Output = Result<reqwest::Response, Self::Error>> + Send + 'static {
        execute_request(self.clone(), request)
    }
}

#[inline]
#[cfg_attr(feature = "tracing", tracing::instrument)]
#[allow(clippy::cast_precision_loss)]
async fn execute_request(
    client: reqwest::Client,
    request: reqwest::Request,
) -> Result<reqwest::Response, reqwest::Error> {
    #[cfg(any(feature = "logging", feature = "metrics"))]
    let (endpoint, method) = (request.url().to_string(), request.method().to_string());

    #[cfg(feature = "logging")]
    trace!(%endpoint, %method, "execute request");

    #[cfg(feature = "metrics")]
    let instant = Instant::now();

    let response = client.execute(request).await?;

    #[cfg(any(feature = "logging", feature = "metrics"))]
    let status_code = response.status();

    #[cfg(feature = "logging")]
    trace!(
        endpoint,
        method = %method,
        status_code = %status_code,
        "received response",
    );

    #[cfg(feature = "metrics")]
    {
        let status_code = status_code.as_u16().to_string();

        metrics::CLIENT_REQUEST
            .with_label_values(&[&*endpoint, &*method, &*status_code])
            .inc();

        metrics::CLIENT_REQUEST_DURATION
            .with_label_values(&[&*endpoint, &*method, &*status_code, "us"])
            .inc_by(Instant::now().duration_since(instant).as_micros() as f64);
    }

    Ok(response)
}

impl<T: ExecuteRequest> ExecuteRequest for Arc<T> {
    type Error = T::Error;

    #[inline]
    fn execute_request(
        &self,
        request: reqwest::Request,
    ) -> impl Future<Output = Result<reqwest::Response, Self::Error>> + Send + 'static {
        self.as_ref().execute_request(request)
    }
}