prometheus_http_client/
builders.rs

1//! Builder for QueryRangeRequest
2
3use super::QueryRangeRequest;
4use chrono::{DateTime, TimeDelta, Utc};
5use std::{ops::Range, time::Duration};
6
7/// Builder for constructing a QueryRangeRequest
8pub struct QueryRangeRequestBuilder {
9    query: String,
10    range: Option<Range<DateTime<Utc>>>,
11    step: Option<Duration>,
12    count: usize,
13}
14
15impl QueryRangeRequestBuilder {
16    /// Create a new builder with the given PromQL query
17    pub fn new(query: String) -> Self {
18        Self {
19            query,
20            range: None,
21            step: None,
22            count: 256,
23        }
24    }
25
26    /// Set the time range for the query
27    pub fn range(mut self, range: Range<DateTime<Utc>>) -> Self {
28        if self.range.is_some() {
29            panic!("already set range: {:?}", self.range);
30        }
31        self.range = Some(range);
32        self
33    }
34
35    /// Set the time range to be from `time` ago until now
36    pub fn since(mut self, time: Duration) -> Self {
37        if self.range.is_some() {
38            panic!("already set range: {:?}", self.range);
39        }
40        let end = Utc::now();
41        let start = end - TimeDelta::from_std(time).unwrap();
42
43        self.range = Some(start..end);
44        self
45    }
46
47    /// Set the step interval between data points
48    pub fn step(mut self, step: Duration) -> Self {
49        if self.step.is_some() {
50            panic!("already set step: {:?}", self.step);
51        }
52        self.step = Some(step);
53        self
54    }
55
56    /// Set the target number of data points (used to compute step if not set)
57    pub fn count(mut self, count: usize) -> Self {
58        self.count = count;
59        self
60    }
61
62    /// Build the QueryRangeRequest
63    pub fn build(self) -> QueryRangeRequest {
64        let query = self.query;
65        let range = self.range.unwrap();
66
67        let step = self.step.unwrap_or_else(|| {
68            let delta = range.end - range.start;
69            (delta / (self.count as i32)).to_std().unwrap()
70        });
71
72        QueryRangeRequest {
73            query,
74            start: range.start,
75            end: range.end,
76            step: step.as_secs_f64(),
77        }
78    }
79}