Line data    Source code

       1              : use std::time::Duration;
       2              : 
       3              : use metrics::IntGauge;
       4              : use prometheus::{register_int_gauge_with_registry, Registry};
       5              : use tikv_jemalloc_ctl::{config, epoch, epoch_mib, stats, version};
       6              : 
       7              : pub struct MetricRecorder {
       8              :     epoch: epoch_mib,
       9              :     active: stats::active_mib,
      10              :     active_gauge: IntGauge,
      11              :     allocated: stats::allocated_mib,
      12              :     allocated_gauge: IntGauge,
      13              :     mapped: stats::mapped_mib,
      14              :     mapped_gauge: IntGauge,
      15              :     metadata: stats::metadata_mib,
      16              :     metadata_gauge: IntGauge,
      17              :     resident: stats::resident_mib,
      18              :     resident_gauge: IntGauge,
      19              :     retained: stats::retained_mib,
      20              :     retained_gauge: IntGauge,
      21              : }
      22              : 
      23              : impl MetricRecorder {
      24            0 :     pub fn new(registry: &Registry) -> Result<Self, anyhow::Error> {
      25            0 :         tracing::info!(
      26            0 :             config = config::malloc_conf::read()?,
      27            0 :             version = version::read()?,
      28            0 :             "starting jemalloc recorder"
      29            0 :         );
      30              : 
      31              :         Ok(Self {
      32            0 :             epoch: epoch::mib()?,
      33            0 :             active: stats::active::mib()?,
      34            0 :             active_gauge: register_int_gauge_with_registry!(
      35            0 :                 "jemalloc_active_bytes",
      36            0 :                 "Total number of bytes in active pages allocated by the process",
      37            0 :                 registry
      38            0 :             )?,
      39            0 :             allocated: stats::allocated::mib()?,
      40            0 :             allocated_gauge: register_int_gauge_with_registry!(
      41            0 :                 "jemalloc_allocated_bytes",
      42            0 :                 "Total number of bytes allocated by the process",
      43            0 :                 registry
      44            0 :             )?,
      45            0 :             mapped: stats::mapped::mib()?,
      46            0 :             mapped_gauge: register_int_gauge_with_registry!(
      47            0 :                 "jemalloc_mapped_bytes",
      48            0 :                 "Total number of bytes in active extents mapped by the allocator",
      49            0 :                 registry
      50            0 :             )?,
      51            0 :             metadata: stats::metadata::mib()?,
      52            0 :             metadata_gauge: register_int_gauge_with_registry!(
      53            0 :                 "jemalloc_metadata_bytes",
      54            0 :                 "Total number of bytes dedicated to jemalloc metadata",
      55            0 :                 registry
      56            0 :             )?,
      57            0 :             resident: stats::resident::mib()?,
      58            0 :             resident_gauge: register_int_gauge_with_registry!(
      59            0 :                 "jemalloc_resident_bytes",
      60            0 :                 "Total number of bytes in physically resident data pages mapped by the allocator",
      61            0 :                 registry
      62            0 :             )?,
      63            0 :             retained: stats::retained::mib()?,
      64            0 :             retained_gauge: register_int_gauge_with_registry!(
      65            0 :                 "jemalloc_retained_bytes",
      66            0 :                 "Total number of bytes in virtual memory mappings that were retained rather than being returned to the operating system",
      67            0 :                 registry
      68            0 :             )?,
      69              :         })
      70            0 :     }
      71              : 
      72            0 :     fn _poll(&self) -> Result<(), anyhow::Error> {
      73            0 :         self.epoch.advance()?;
      74            0 :         self.active_gauge.set(self.active.read()? as i64);
      75            0 :         self.allocated_gauge.set(self.allocated.read()? as i64);
      76            0 :         self.mapped_gauge.set(self.mapped.read()? as i64);
      77            0 :         self.metadata_gauge.set(self.metadata.read()? as i64);
      78            0 :         self.resident_gauge.set(self.resident.read()? as i64);
      79            0 :         self.retained_gauge.set(self.retained.read()? as i64);
      80            0 :         Ok(())
      81            0 :     }
      82              : 
      83              :     #[inline]
      84            0 :     pub fn poll(&self) {
      85            0 :         if let Err(error) = self._poll() {
      86            0 :             tracing::warn!(%error, "Failed to poll jemalloc stats");
      87            0 :         }
      88            0 :     }
      89              : 
      90            0 :     pub fn start(self) -> tokio::task::JoinHandle<()> {
      91            0 :         tokio::task::spawn(async move {
      92            0 :             let mut interval = tokio::time::interval(Duration::from_secs(15));
      93            0 :             interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
      94              :             loop {
      95            0 :                 self.poll();
      96            0 :                 interval.tick().await;
      97              :             }
      98            0 :         })
      99            0 :     }
     100              : }