confluent_kafka/common/metrics/stats/
rate.rs1use std::sync::Arc;
19
20use crate::common::metrics::TimeUnit;
21use crate::common::metrics::internals::MetricsUtils;
22use crate::common::metrics::stats::SampledStat;
23use crate::common::metrics::stats::WindowedSum;
24use crate::common::metrics::{Measurable, MetricConfig, Stat};
25
26#[derive(Debug)]
32#[doc(alias = "org.apache.kafka.common.metrics.stats.Rate")]
33pub struct Rate {
34 unit: TimeUnit,
35 stat: Arc<SampledStat>,
36 time_window_ms: i64,
37}
38
39impl Rate {
40 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#Rate")]
42 pub fn new() -> Self {
43 Self::with_unit(TimeUnit::Seconds)
44 }
45
46 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#Rate")]
52 pub fn with_unit(unit: TimeUnit) -> Self {
53 Self::with_unit_stat(unit, Arc::new(WindowedSum::new().into_sampled_stat()))
54 }
55
56 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#Rate")]
62 pub fn with_stat(stat: Arc<SampledStat>) -> Self {
63 Self::with_unit_stat(TimeUnit::Seconds, stat)
64 }
65
66 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#Rate")]
73 pub fn with_unit_stat(unit: TimeUnit, stat: Arc<SampledStat>) -> Self {
74 Self::with_unit_stat_window(unit, stat, -1)
75 }
76
77 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#Rate")]
85 pub fn with_unit_stat_window(unit: TimeUnit, stat: Arc<SampledStat>, window: i64) -> Self {
86 let time_window_ms = if window > 0 {
87 let ms = unit.to_millis(window);
88 stat.with_time_window_ms(ms);
89 ms
90 } else {
91 -1
92 };
93 Self { unit, stat, time_window_ms }
94 }
95
96 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#unitName")]
99 pub fn unit_name(&self) -> String {
100 let name = self.unit.name();
101 name[..name.len() - 2].to_lowercase()
102 }
103
104 pub(crate) fn stat(&self) -> &Arc<SampledStat> {
106 &self.stat
107 }
108
109 #[doc(alias = "org.apache.kafka.common.metrics.stats.Rate#windowSize")]
120 pub fn window_size(&self, config: &MetricConfig, now: i64) -> i64 {
121 self.stat.purge_obsolete_samples(config, now);
123
124 let mut total_elapsed_time_ms = now - self.stat.oldest_start_time_ms(now);
132 let window_ms = if self.time_window_ms > 0 {
134 self.time_window_ms
135 } else {
136 config.time_window_ms()
137 };
138 let num_full_windows = (total_elapsed_time_ms / window_ms) as i32;
140 let min_full_windows = config.samples() - 1;
141
142 if num_full_windows < min_full_windows {
145 total_elapsed_time_ms += (min_full_windows - num_full_windows) as i64 * window_ms;
146 }
147
148 total_elapsed_time_ms.max(1)
153 }
154}
155
156impl Default for Rate {
157 fn default() -> Self {
158 Self::new()
159 }
160}
161
162impl Stat for Rate {
163 fn record(&self, config: &MetricConfig, value: f64, time_ms: i64) {
164 self.stat.record(config, value, time_ms);
165 }
166}
167
168impl Measurable for Rate {
169 fn measure(&self, config: &MetricConfig, now: i64) -> f64 {
170 let value = self.stat.measure(config, now);
171 value / MetricsUtils::convert(self.window_size(config, now), self.unit)
172 }
173}
174
175impl std::fmt::Display for Rate {
176 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
178 write!(f, "Rate(unit={}, stat={})", self.unit.name(), self.stat)
179 }
180}
181
182#[cfg(test)]
183mod tests {
184 use super::*;
185
186 #[test]
187 fn to_string_follows_java() {
188 assert_eq!(
189 Rate::new().to_string(),
190 "Rate(unit=SECONDS, stat=SampledStat(initialValue=0.0, current=0, samples=[]))"
191 );
192 assert_eq!(
193 Rate::with_unit(TimeUnit::Milliseconds).to_string(),
194 "Rate(unit=MILLISECONDS, stat=SampledStat(initialValue=0.0, current=0, samples=[]))"
195 );
196 }
197 use crate::common::metrics::internals::MetricsUtils;
198 use crate::common::utils::MockTime;
199 use crate::common::utils::Time;
200
201 const EPS: f64 = 0.000001;
202
203 #[test]
205 #[doc(alias = "org.apache.kafka.common.metrics.stats.RateTest#testRateWithNoPriorAvailableSamples")]
206 fn test_rate_with_no_prior_available_samples() {
207 for (num_sample, sample_window_size_sec) in [(1, 1), (1, 11), (11, 1), (11, 11)] {
209 let config = MetricConfig::new()
210 .set_samples(num_sample)
211 .set_time_window(sample_window_size_sec, TimeUnit::Seconds);
212 let rate = Rate::new();
213 let time = MockTime::new();
214 let sample_value = 50.0;
215 rate.record(&config, sample_value, time.milliseconds());
217 let measurement_time = TimeUnit::Seconds.to_millis(sample_window_size_sec) - 1;
219 time.sleep(measurement_time);
220 let observed_rate = rate.measure(&config, time.milliseconds());
222 assert!(!observed_rate.is_nan());
223
224 let dummy_prior_samples_assumed = (num_sample - 1) as f64;
226 let window_size = MetricsUtils::convert(measurement_time, TimeUnit::Seconds)
227 + (dummy_prior_samples_assumed * sample_window_size_sec as f64);
228 let expected_rate_per_sec = sample_value / window_size;
229 assert!(
230 (expected_rate_per_sec - observed_rate).abs() <= EPS,
231 "numSample={num_sample}, window={sample_window_size_sec}: expected {expected_rate_per_sec}, got {observed_rate}"
232 );
233 }
234 }
235
236 #[test]
238 #[doc(alias = "org.apache.kafka.common.metrics.stats.RateTest#testRateIsConsistentAfterTheFirstWindow")]
239 fn test_rate_is_consistent_after_the_first_window() {
240 let config = MetricConfig::new().set_time_window(1, TimeUnit::Seconds).set_samples(2);
241 let rate = Rate::new();
242 let time = MockTime::new();
243 let steps = [0, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100];
244
245 for step_ms in steps {
247 time.sleep(step_ms);
248 rate.record(&config, 1.0, time.milliseconds());
249 }
250
251 time.sleep(101);
253
254 for step_ms in steps {
256 time.sleep(step_ms);
257 rate.record(&config, 1.0, time.milliseconds());
258 let observed_rate = rate.measure(&config, time.milliseconds());
259 assert!((10.0..=11.0).contains(&observed_rate), "observed_rate={observed_rate}");
260 let measured_again = rate.measure(&config, time.milliseconds());
262 assert_eq!(observed_rate, measured_again);
263 }
264 }
265
266 #[test]
267 fn unit_name_strips_last_two_chars() {
268 assert_eq!("secon", Rate::with_unit(TimeUnit::Seconds).unit_name());
271 assert_eq!("millisecon", Rate::with_unit(TimeUnit::Milliseconds).unit_name());
273 }
274}