prometheus-http-client 0.1.0

HTTP client for Prometheus query API with optional time-series plotting
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

//! Builder for QueryRangeRequest

use super::QueryRangeRequest;
use chrono::{DateTime, TimeDelta, Utc};
use std::{ops::Range, time::Duration};

/// Builder for constructing a QueryRangeRequest
pub struct QueryRangeRequestBuilder {
    query: String,
    range: Option<Range<DateTime<Utc>>>,
    step: Option<Duration>,
    count: usize,
}

impl QueryRangeRequestBuilder {
    /// Create a new builder with the given PromQL query
    pub fn new(query: String) -> Self {
        Self {
            query,
            range: None,
            step: None,
            count: 256,
        }
    }

    /// Set the time range for the query
    pub fn range(mut self, range: Range<DateTime<Utc>>) -> Self {
        if self.range.is_some() {
            panic!("already set range: {:?}", self.range);
        }
        self.range = Some(range);
        self
    }

    /// Set the time range to be from `time` ago until now
    pub fn since(mut self, time: Duration) -> Self {
        if self.range.is_some() {
            panic!("already set range: {:?}", self.range);
        }
        let end = Utc::now();
        let start = end - TimeDelta::from_std(time).unwrap();

        self.range = Some(start..end);
        self
    }

    /// Set the step interval between data points
    pub fn step(mut self, step: Duration) -> Self {
        if self.step.is_some() {
            panic!("already set step: {:?}", self.step);
        }
        self.step = Some(step);
        self
    }

    /// Set the target number of data points (used to compute step if not set)
    pub fn count(mut self, count: usize) -> Self {
        self.count = count;
        self
    }

    /// Build the QueryRangeRequest
    pub fn build(self) -> QueryRangeRequest {
        let query = self.query;
        let range = self.range.unwrap();

        let step = self.step.unwrap_or_else(|| {
            let delta = range.end - range.start;
            (delta / (self.count as i32)).to_std().unwrap()
        });

        QueryRangeRequest {
            query,
            start: range.start,
            end: range.end,
            step: step.as_secs_f64(),
        }
    }
}