Line data    Source code

       1              : use measured::{
       2              :     FixedCardinalityLabel, Gauge, GaugeVec, LabelGroup, MetricGroup,
       3              :     label::{LabelName, LabelValue, StaticLabelSet},
       4              :     metric::{MetricEncoding, gauge::GaugeState, group::Encoding},
       5              : };
       6              : 
       7              : use super::callbacks::callback_get_lfc_metrics;
       8              : 
       9              : pub(crate) struct LfcMetricsCollector;
      10              : 
      11              : #[derive(MetricGroup)]
      12              : #[metric(new())]
      13              : struct LfcMetricsGroup {
      14              :     /// LFC cache size limit in bytes
      15              :     lfc_cache_size_limit: Gauge,
      16              :     /// LFC cache hits
      17              :     lfc_hits: Gauge,
      18              :     /// LFC cache misses
      19              :     lfc_misses: Gauge,
      20              :     /// LFC chunks used (chunk = 1MB)
      21              :     lfc_used: Gauge,
      22              :     /// LFC cache writes
      23              :     lfc_writes: Gauge,
      24              :     /// Approximate working set size in pages of 8192 bytes
      25              :     #[metric(init = GaugeVec::dense())]
      26              :     lfc_approximate_working_set_size_windows: GaugeVec<StaticLabelSet<MinuteAsSeconds>>,
      27              : }
      28              : 
      29              : impl<T: Encoding> MetricGroup<T> for LfcMetricsCollector
      30              : where
      31              :     GaugeState: MetricEncoding<T>,
      32              : {
      33            0 :     fn collect_group_into(&self, enc: &mut T) -> Result<(), <T as Encoding>::Err> {
      34            0 :         let g = LfcMetricsGroup::new();
      35              : 
      36            0 :         let lfc_metrics = callback_get_lfc_metrics();
      37              : 
      38            0 :         g.lfc_cache_size_limit.set(lfc_metrics.lfc_cache_size_limit);
      39            0 :         g.lfc_hits.set(lfc_metrics.lfc_hits);
      40            0 :         g.lfc_misses.set(lfc_metrics.lfc_misses);
      41            0 :         g.lfc_used.set(lfc_metrics.lfc_used);
      42            0 :         g.lfc_writes.set(lfc_metrics.lfc_writes);
      43              : 
      44            0 :         for i in 0..60 {
      45            0 :             let val = lfc_metrics.lfc_approximate_working_set_size_windows[i];
      46            0 :             g.lfc_approximate_working_set_size_windows
      47            0 :                 .set(MinuteAsSeconds(i), val);
      48            0 :         }
      49              : 
      50            0 :         g.collect_group_into(enc)
      51            0 :     }
      52              : }
      53              : 
      54              : /// This stores the values in range 0..60,
      55              : /// encodes them as seconds (60, 120, 180, ..., 3600)
      56              : #[derive(Clone, Copy)]
      57              : struct MinuteAsSeconds(usize);
      58              : 
      59              : impl FixedCardinalityLabel for MinuteAsSeconds {
      60            0 :     fn cardinality() -> usize {
      61            0 :         60
      62            0 :     }
      63              : 
      64            0 :     fn encode(&self) -> usize {
      65            0 :         self.0
      66            0 :     }
      67              : 
      68            0 :     fn decode(value: usize) -> Self {
      69            0 :         Self(value)
      70            0 :     }
      71              : }
      72              : 
      73              : impl LabelValue for MinuteAsSeconds {
      74            0 :     fn visit<V: measured::label::LabelVisitor>(&self, v: V) -> V::Output {
      75            0 :         v.write_int((self.0 + 1) as i64 * 60)
      76            0 :     }
      77              : }
      78              : 
      79              : impl LabelGroup for MinuteAsSeconds {
      80            0 :     fn visit_values(&self, v: &mut impl measured::label::LabelGroupVisitor) {
      81            0 :         v.write_value(LabelName::from_str("duration_seconds"), self);
      82            0 :     }
      83              : }