nautobot 0.4.3

ergonomic rust client for Nautobot REST API
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! metrics endpoint.
//!
//! basic usage:
//! ```no_run
//! # use nautobot::{Client, ClientConfig};
//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
//! # let client = Client::new(ClientConfig::new("https://nautobot.example.com", "token"))?;
//! let metrics = client.metrics().metrics().await?;
//! println!("{}", metrics.lines().next().unwrap_or(""));
//! # Ok(())
//! # }
//! ```

use crate::Client;
use crate::error::{Error, Result};
use reqwest::Method;

/// api for metrics endpoint.
#[derive(Clone)]
pub struct MetricsApi {
    client: Client,
}

impl MetricsApi {
    pub(crate) fn new(client: Client) -> Self {
        Self { client }
    }

    /// fetch the prometheus metrics payload.
    pub async fn metrics(&self) -> Result<String> {
        let path = "metrics/";
        self.client
            .retry_loop(Method::GET, path, false, |_attempt| async move {
                let url = self.client.config().build_url(path)?;
                let request = self.client.http_client().get(url);
                let response = self
                    .client
                    .execute_request(&Method::GET, path, request)
                    .await?;
                let status = response.status();
                let body = response.text().await.map_err(Error::from)?;
                if status.is_success() {
                    Ok(body)
                } else {
                    Err(Error::from_response(status, body))
                }
            })
            .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{ClientConfig, HttpHooks};
    use httpmock::prelude::HttpMockRequest;
    use httpmock::{Method::GET, MockServer};
    use reqwest::StatusCode;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::{Arc, Mutex};
    use std::time::Duration;

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn metrics_hits_expected_path() {
        let server = MockServer::start();
        let config = ClientConfig::new(server.base_url(), "token").with_max_retries(0);
        let client = Client::new(config).unwrap();
        let api = MetricsApi::new(client);

        server.mock(|when, then| {
            when.method(GET).path("/api/metrics/");
            then.status(200).body("# HELP test_metric 1");
        });

        let metrics = api.metrics().await.unwrap();
        assert!(metrics.contains("test_metric"));
    }

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn metrics_retries_on_429() {
        let server = MockServer::start();
        let config = ClientConfig::new(server.base_url(), "token").with_max_retries(2);
        let client = Client::new(config).unwrap();
        let api = MetricsApi::new(client);

        let call_count = Arc::new(AtomicUsize::new(0));
        let counter = call_count.clone();
        let fail = server.mock(|when, then| {
            when.method(GET)
                .path("/api/metrics/")
                .is_true(move |_: &HttpMockRequest| counter.fetch_add(1, Ordering::SeqCst) == 0);
            then.status(429).body("rate limited");
        });
        let succeed = server.mock(|when, then| {
            when.method(GET).path("/api/metrics/");
            then.status(200).body("# HELP up 1");
        });

        let metrics = api.metrics().await.unwrap();
        assert!(metrics.contains("up"));
        fail.assert_calls(1);
        succeed.assert_calls(1);
    }

    struct StatusCapture {
        statuses: Arc<Mutex<Vec<u16>>>,
    }

    impl HttpHooks for StatusCapture {
        fn on_response(
            &self,
            _method: &reqwest::Method,
            _path: &str,
            status: StatusCode,
            _duration: Duration,
        ) {
            self.statuses.lock().unwrap().push(status.as_u16());
        }
    }

    #[cfg_attr(miri, ignore)]
    #[tokio::test]
    async fn metrics_invokes_hooks() {
        let server = MockServer::start();
        let statuses = Arc::new(Mutex::new(Vec::new()));
        let hook = StatusCapture {
            statuses: statuses.clone(),
        };
        let config = ClientConfig::new(server.base_url(), "token")
            .with_max_retries(0)
            .with_http_hooks(hook);
        let client = Client::new(config).unwrap();
        let api = MetricsApi::new(client);

        server.mock(|when, then| {
            when.method(GET).path("/api/metrics/");
            then.status(200).body("# HELP up 1");
        });

        api.metrics().await.unwrap();
        let captured = statuses.lock().unwrap().clone();
        assert_eq!(captured, vec![200]);
    }
}