feat: expose process memory limit metric (#1790)

* feat: expose process memory limit metric

* update memory limit metric

* refactor: set memory limit directly

Author: pratik50

src/metrics/mod.rs

@@ -201,21 +201,31 @@ pub static PROCESS_MEMORY_BYTES_AVG: Lazy<Gauge> = Lazy::new(|| {
     )
     .expect("metric can be created")
 });
-pub static PROCESS_METRICS_INIT: OnceLock<(f64, u64, u64)> = OnceLock::new();
+
+pub static PROCESS_MEMORY_LIMIT_BYTES: Lazy<Gauge> = Lazy::new(|| {
+    Gauge::with_opts(
+        Opts::new(
+            "process_memory_limit_bytes",
+            "Cgroup memory limit in bytes, or total system memory when cgroup limits are unavailable",
+        )
+        .namespace(METRICS_NAMESPACE),
+    )
+    .expect("metric can be created")
+});
+
+pub static PROCESS_METRICS_INIT: OnceLock<(f64, u64)> = OnceLock::new();
 pub struct ProcessMetricsAccumulator {
     cpu_usage_avg: AtomicF64,
     memory_bytes_avg: AtomicF64,
-    total_memory: AtomicF64,
 }
 
 impl Default for ProcessMetricsAccumulator {
     fn default() -> Self {
         // PROCESS_METRICS_INIT must be initialized by now
-        let (cpu, mem, total_mem) = *PROCESS_METRICS_INIT.get().unwrap();
+        let (cpu, mem) = *PROCESS_METRICS_INIT.get().unwrap();
         Self {
             cpu_usage_avg: AtomicF64::new(cpu),
             memory_bytes_avg: AtomicF64::new(mem as f64),
-            total_memory: AtomicF64::new(total_mem as f64),
         }
     }
 }
@@ -248,10 +258,6 @@ impl ProcessMetricsAccumulator {
     pub fn get_mem(&self) -> f64 {
         self.memory_bytes_avg.get()
     }
-
-    pub fn get_total_mem(&self) -> f64 {
-        self.total_memory.get()
-    }
 }
 
 pub static PROCESS_METRICS_ACCUMULATOR: Lazy<ProcessMetricsAccumulator> =
@@ -260,12 +266,13 @@ pub static PROCESS_METRICS_ACCUMULATOR: Lazy<ProcessMetricsAccumulator> =
 pub fn record_process_metrics_sample(cpu_usage_percent: f64, memory_bytes: u64, total_mem: u64) {
     if PROCESS_METRICS_INIT.get().is_none() {
         // first measurement
-        let _ = PROCESS_METRICS_INIT.set((cpu_usage_percent, memory_bytes, total_mem));
+        let _ = PROCESS_METRICS_INIT.set((cpu_usage_percent, memory_bytes));
     }
     let (average_cpu_usage, average_memory_bytes) =
         PROCESS_METRICS_ACCUMULATOR.record(cpu_usage_percent, memory_bytes);
     PROCESS_CPU_USAGE_PERCENT_AVG.set(average_cpu_usage);
     PROCESS_MEMORY_BYTES_AVG.set(average_memory_bytes);
+    PROCESS_MEMORY_LIMIT_BYTES.set(total_mem as f64);
 }
 
 #[cfg(test)]
@@ -277,7 +284,7 @@ mod process_metrics_tests {
     #[test]
     fn averages_process_metric_samples() {
         // init PROCESS_METRICS_INIT
-        PROCESS_METRICS_INIT.get_or_init(|| (10.0, 100, 100));
+        PROCESS_METRICS_INIT.get_or_init(|| (10.0, 100));
         let accumulator = ProcessMetricsAccumulator::default();
 
         assert_eq!(accumulator.record(10.0, 100), (10.0, 100.0));
@@ -791,6 +798,9 @@ fn custom_metrics(registry: &Registry) {
     registry
         .register(Box::new(PROCESS_MEMORY_BYTES_AVG.clone()))
         .expect("metric can be registered");
+    registry
+        .register(Box::new(PROCESS_MEMORY_LIMIT_BYTES.clone()))
+        .expect("metric can be registered");
     registry
         .register(Box::new(QUERY_EXECUTE_TIME.clone()))
         .expect("metric can be registered");