feat(process): add collection time metric, more system stats (#33)

Author: mempirate

README.md

@@ -158,34 +158,46 @@ collector.collect();
 #### Sample Output
 
 ```text
+# HELP process_collection_duration_seconds The duration of the associated collection routine in seconds.
+# TYPE process_collection_duration_seconds gauge
+process_collection_duration_seconds 0.008691417
 # HELP process_cpu_usage The CPU usage of the process as a percentage.
 # TYPE process_cpu_usage gauge
-process_cpu_usage 0.7814099788665771
+process_cpu_usage 0.014495549723505974
 # HELP process_disk_written_bytes_total The total written bytes to disk by the process.
 # TYPE process_disk_written_bytes_total gauge
 process_disk_written_bytes_total 0
-# HELP process_max_cpu_freq The maximum CPU frequency of all cores in MHz.
-# TYPE process_max_cpu_freq gauge
-process_max_cpu_freq 4464
 # HELP process_max_fds The maximum number of open file descriptors of the process.
 # TYPE process_max_fds gauge
 process_max_fds 10240
-# HELP process_min_cpu_freq The minimum CPU frequency of all cores in MHz.
-# TYPE process_min_cpu_freq gauge
-process_min_cpu_freq 4464
 # HELP process_open_fds The number of open file descriptors of the process.
 # TYPE process_open_fds gauge
 process_open_fds 45
 # HELP process_resident_memory_bytes The resident memory of the process in bytes. (RSS)
 # TYPE process_resident_memory_bytes gauge
-process_resident_memory_bytes 4603904
+process_resident_memory_bytes 4915200
 # HELP process_resident_memory_usage The resident memory usage of the process as a percentage of the total memory available.
 # TYPE process_resident_memory_usage gauge
-process_resident_memory_usage 0.00013399124145507813
+process_resident_memory_usage 0.0001430511474609375
 # HELP process_start_time_seconds The start time of the process in UNIX seconds.
 # TYPE process_start_time_seconds gauge
-process_start_time_seconds 1762338704
+process_start_time_seconds 1762438572
 # HELP process_threads The number of OS threads used by the process (Linux only).
 # TYPE process_threads gauge
 process_threads 1
+# HELP system_cpu_cores The number of logical CPU cores available in the system.
+# TYPE system_cpu_cores gauge
+system_cpu_cores 10
+# HELP system_cpu_usage System-wide CPU usage percentage.
+# TYPE system_cpu_usage gauge
+system_cpu_usage 15.498806953430176
+# HELP system_max_cpu_frequency The maximum CPU frequency of all cores in MHz.
+# TYPE system_max_cpu_frequency gauge
+system_max_cpu_frequency 4464
+# HELP system_memory_usage System-wide memory usage percentage.
+# TYPE system_memory_usage gauge
+system_memory_usage 65.11974334716797
+# HELP system_min_cpu_frequency The minimum CPU frequency of all cores in MHz.
+# TYPE system_min_cpu_frequency gauge
+system_min_cpu_frequency 4464
 ```

prometric-derive/src/lib.rs

@@ -162,36 +162,48 @@ mod utils;
 ///
 /// #### Output
 /// ```text
+/// # HELP process_collection_duration_seconds The duration of the associated collection routine in
+/// seconds. # TYPE process_collection_duration_seconds gauge
+/// process_collection_duration_seconds 0.008691417
 /// # HELP process_cpu_usage The CPU usage of the process as a percentage.
 /// # TYPE process_cpu_usage gauge
-/// process_cpu_usage 0.7814099788665771
+/// process_cpu_usage 0.014495549723505974
 /// # HELP process_disk_written_bytes_total The total written bytes to disk by the process.
 /// # TYPE process_disk_written_bytes_total gauge
 /// process_disk_written_bytes_total 0
-/// # HELP process_max_cpu_freq The maximum CPU frequency of all cores in MHz.
-/// # TYPE process_max_cpu_freq gauge
-/// process_max_cpu_freq 4464
 /// # HELP process_max_fds The maximum number of open file descriptors of the process.
 /// # TYPE process_max_fds gauge
 /// process_max_fds 10240
-/// # HELP process_min_cpu_freq The minimum CPU frequency of all cores in MHz.
-/// # TYPE process_min_cpu_freq gauge
-/// process_min_cpu_freq 4464
 /// # HELP process_open_fds The number of open file descriptors of the process.
 /// # TYPE process_open_fds gauge
 /// process_open_fds 45
 /// # HELP process_resident_memory_bytes The resident memory of the process in bytes. (RSS)
 /// # TYPE process_resident_memory_bytes gauge
-/// process_resident_memory_bytes 4603904
+/// process_resident_memory_bytes 4915200
 /// # HELP process_resident_memory_usage The resident memory usage of the process as a percentage of
 /// the total memory available. # TYPE process_resident_memory_usage gauge
-/// process_resident_memory_usage 0.00013399124145507813
+/// process_resident_memory_usage 0.0001430511474609375
 /// # HELP process_start_time_seconds The start time of the process in UNIX seconds.
 /// # TYPE process_start_time_seconds gauge
-/// process_start_time_seconds 1762338704
+/// process_start_time_seconds 1762438572
 /// # HELP process_threads The number of OS threads used by the process (Linux only).
 /// # TYPE process_threads gauge
 /// process_threads 1
+/// # HELP system_cpu_cores The number of logical CPU cores available in the system.
+/// # TYPE system_cpu_cores gauge
+/// system_cpu_cores 10
+/// # HELP system_cpu_usage System-wide CPU usage percentage.
+/// # TYPE system_cpu_usage gauge
+/// system_cpu_usage 15.498806953430176
+/// # HELP system_max_cpu_frequency The maximum CPU frequency of all cores in MHz.
+/// # TYPE system_max_cpu_frequency gauge
+/// system_max_cpu_frequency 4464
+/// # HELP system_memory_usage System-wide memory usage percentage.
+/// # TYPE system_memory_usage gauge
+/// system_memory_usage 65.11974334716797
+/// # HELP system_min_cpu_frequency The minimum CPU frequency of all cores in MHz.
+/// # TYPE system_min_cpu_frequency gauge
+/// system_min_cpu_frequency 4464
 /// ```
 #[proc_macro_attribute]
 pub fn metrics(attr: TokenStream, item: TokenStream) -> TokenStream {

prometric/src/process.rs

@@ -8,21 +8,10 @@ type UintGauge = GenericGauge<AtomicU64>;
 
 type UintCounter = GenericGauge<AtomicU64>;
 
-/// A collector for process metrics.
+/// A collector for process (and some system) metrics.
 ///
 /// # Metrics
-/// - `process_threads`: The number of OS threads used by the process (Linux only).
-/// - `process_cpu_cores`: The number of logical CPU cores available in the system.
-/// - `process_cpu_usage`: The CPU usage of the process as a percentage.
-/// - `process_max_cpu_freq`: The maximum CPU frequency of all cores in MHz.
-/// - `process_min_cpu_freq`: The minimum CPU frequency of all cores in MHz.
-/// - `process_resident_memory_bytes`: The resident memory of the process in bytes.
-/// - `process_resident_memory_usage`: The resident memory usage of the process as a percentage of
-///   the total memory available.
-/// - `process_start_time_seconds`: The start time of the process in UNIX seconds.
-/// - `process_open_fds`: The number of open file descriptors of the process.
-/// - `process_max_fds`: The maximum number of open file descriptors of the process.
-/// - `process_disk_written_bytes_total`: The total written bytes to disk by the process.
+/// See the documentation for the [`ProcessMetrics`] struct for the list of metrics.
 ///
 /// # Example
 /// ```rust
@@ -86,13 +75,17 @@ impl ProcessCollector {
         self.pid.as_u32()
     }
 
-    /// Collect the metrics for the process.
+    /// Collect system and process metrics.
     pub fn collect(&mut self) {
+        let start = std::time::Instant::now();
         self.sys.refresh_specifics(self.specifics);
 
         let cpus = self.sys.cpus();
         let min_cpu_freq = cpus.iter().map(|cpu| cpu.frequency()).min().unwrap();
         let max_cpu_freq = cpus.iter().map(|cpu| cpu.frequency()).max().unwrap();
+        let system_cpu_usage = self.sys.global_cpu_usage();
+        let system_memory_usage =
+            self.sys.used_memory() as f64 / self.sys.total_memory() as f64 * 100.0;
 
         let process = self.sys.process(self.pid).unwrap();
         let threads = process.tasks().map(|tasks| tasks.len()).unwrap_or(0);
@@ -103,9 +96,11 @@ impl ProcessCollector {
         let resident_memory_usage = resident_memory as f64 / self.sys.total_memory() as f64;
         let disk_usage = process.disk_usage().total_written_bytes;
 
-        self.metrics.cores.set(self.cores);
-        self.metrics.max_cpu_freq.set(max_cpu_freq);
-        self.metrics.min_cpu_freq.set(min_cpu_freq);
+        self.metrics.system_cores.set(self.cores);
+        self.metrics.system_max_cpu_freq.set(max_cpu_freq);
+        self.metrics.system_min_cpu_freq.set(min_cpu_freq);
+        self.metrics.system_cpu_usage.set(system_cpu_usage as f64);
+        self.metrics.system_memory_usage.set(system_memory_usage);
 
         self.metrics.threads.set(threads as u64);
         self.metrics.cpu_usage.set(cpu_usage as f64);
@@ -115,43 +110,69 @@ impl ProcessCollector {
         self.metrics.open_fds.set(open_fds as u64);
         self.metrics.max_fds.set(max_fds as u64);
         self.metrics.disk_written_bytes.set(disk_usage);
+
+        // Record the duration of the collection routine
+        self.metrics.collection_duration.set(start.elapsed().as_secs_f64());
     }
 }
 
-struct ProcessMetrics {
+/// A collection of metrics for a process, with some useful system metrics.
+pub struct ProcessMetrics {
     // System metrics
-    cores: UintGauge,
-    max_cpu_freq: UintGauge,
-    min_cpu_freq: UintGauge,
+    /// The number of logical CPU cores available in the system.
+    system_cores: UintGauge,
+    /// The maximum CPU frequency of all cores in MHz.
+    system_max_cpu_freq: UintGauge,
+    /// The minimum CPU frequency of all cores in MHz.
+    system_min_cpu_freq: UintGauge,
+    /// The system-wide CPU usage percentage.
+    system_cpu_usage: Gauge,
+    /// The system-wide memory usage percentage.
+    system_memory_usage: Gauge,
 
     // Process metrics
+    /// The number of OS threads used by the process (Linux only).
     threads: UintGauge,
+    /// The CPU usage of the process as a percentage.
     cpu_usage: Gauge,
+    /// The resident memory of the process in bytes. (RSS)
     resident_memory: UintGauge,
+    /// The resident memory usage of the process as a percentage of the total memory available.
     resident_memory_usage: Gauge,
+    /// The start time of the process in UNIX seconds.
     start_time: UintGauge,
+    /// The number of open file descriptors of the process.
     open_fds: UintGauge,
+    /// The maximum number of open file descriptors of the process.
     max_fds: UintGauge,
+    /// The total written bytes to disk by the process.
     disk_written_bytes: UintCounter,
+
+    /// The duration of the associated collection routine in seconds.
+    collection_duration: Gauge,
 }
 
 impl ProcessMetrics {
     pub fn new(registry: &prometheus::Registry) -> Self {
-        let cores = UintGauge::new(
+        let system_cores = UintGauge::new(
             "system_cpu_cores",
             "The number of logical CPU cores available in the system.",
         )
         .unwrap();
-        let max_cpu_freq = UintGauge::new(
+        let system_max_cpu_freq = UintGauge::new(
             "system_max_cpu_frequency",
             "The maximum CPU frequency of all cores in MHz.",
         )
         .unwrap();
-        let min_cpu_freq = UintGauge::new(
+        let system_min_cpu_freq = UintGauge::new(
             "system_min_cpu_frequency",
             "The minimum CPU frequency of all cores in MHz.",
         )
         .unwrap();
+        let system_cpu_usage =
+            Gauge::new("system_cpu_usage", "System-wide CPU usage percentage.").unwrap();
+        let system_memory_usage =
+            Gauge::new("system_memory_usage", "System-wide memory usage percentage.").unwrap();
 
         let threads = UintGauge::new(
             "process_threads",
@@ -192,10 +213,18 @@ impl ProcessMetrics {
         )
         .unwrap();
 
+        let collection_duration = Gauge::new(
+            "process_collection_duration_seconds",
+            "The duration of the associated collection routine in seconds.",
+        )
+        .unwrap();
+
         // Register all metrics with the registry
-        registry.register(Box::new(cores.clone())).unwrap();
-        registry.register(Box::new(max_cpu_freq.clone())).unwrap();
-        registry.register(Box::new(min_cpu_freq.clone())).unwrap();
+        registry.register(Box::new(system_cores.clone())).unwrap();
+        registry.register(Box::new(system_max_cpu_freq.clone())).unwrap();
+        registry.register(Box::new(system_min_cpu_freq.clone())).unwrap();
+        registry.register(Box::new(system_cpu_usage.clone())).unwrap();
+        registry.register(Box::new(system_memory_usage.clone())).unwrap();
 
         registry.register(Box::new(threads.clone())).unwrap();
         registry.register(Box::new(cpu_usage.clone())).unwrap();
@@ -205,11 +234,14 @@ impl ProcessMetrics {
         registry.register(Box::new(open_fds.clone())).unwrap();
         registry.register(Box::new(max_fds.clone())).unwrap();
         registry.register(Box::new(disk_written_bytes.clone())).unwrap();
+        registry.register(Box::new(collection_duration.clone())).unwrap();
 
         Self {
-            cores,
-            max_cpu_freq,
-            min_cpu_freq,
+            system_cores,
+            system_max_cpu_freq,
+            system_min_cpu_freq,
+            system_cpu_usage,
+            system_memory_usage,
             threads,
             cpu_usage,
             resident_memory,
@@ -218,6 +250,7 @@ impl ProcessMetrics {
             open_fds,
             max_fds,
             disk_written_bytes,
+            collection_duration,
         }
     }
 }