tests: register process collector

Signed-off-by: Gustavo Murayama <[email protected]>

Author: gmurayama

process-collector/src/lib.rs

@@ -10,15 +10,22 @@ mod linux;
 
 #[derive(Debug)]
 pub struct ProcessCollector {
-    namespace: Option<String>,
+    namespace: String,
     #[cfg(target_os = "linux")]
     system: linux::System,
 }
 
 impl ProcessCollector {
     pub fn new(namespace: Option<String>) -> std::io::Result<Self> {
         #[cfg(target_os = "linux")]
-        let system = linux::System::load()?;
+        let system = linux::System::load(namespace.clone())?;
+        let namespace = match namespace {
+            Some(mut n) => {
+                n.push('_');
+                n
+            }
+            None => "".to_string(),
+        };
 
         Ok(ProcessCollector {
             namespace,
@@ -34,8 +41,9 @@ impl Collector for ProcessCollector {
             .duration_since(UNIX_EPOCH)
             .map_err(|_| std::fmt::Error)?;
         let start_time = ConstGauge::new(start_time_from_epoch.as_secs_f64());
+        let metric_name = format!("{}process_start_time", self.namespace);
         let start_time_metric = encoder.encode_descriptor(
-            "process_start_time_seconds",
+            &metric_name,
             "Start time of the process since unix epoch in seconds.",
             Some(&Unit::Seconds),
             start_time.metric_type(),
@@ -52,11 +60,178 @@ impl Collector for ProcessCollector {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use prometheus_client::registry::Registry;
+    use prometheus_client::{encoding::text::encode, registry::Registry};
 
     #[test]
-    fn register_process_collector() {
+    fn register_start_time() {
         let mut registry = Registry::default();
-        // registry.register_collector(Box::new(ProcessCollector::new(None)))
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let start_time = "# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.\n".to_owned() +
+        "# TYPE process_start_time_seconds gauge\n" +
+        "# UNIT process_start_time_seconds seconds\n" + 
+        "process_start_time_seconds ";
+
+        assert!(
+            encoded.contains(&start_time),
+            "encoded does not contain expected start_time"
+        );
+    }
+
+    #[test]
+    fn register_resident_memory() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let resident_memory =
+            "# HELP process_resident_memory_bytes Resident memory size in bytes.\n".to_owned()
+                + "# TYPE process_resident_memory_bytes gauge\n"
+                + "# UNIT process_resident_memory_bytes bytes\n"
+                + "process_resident_memory_bytes ";
+
+        assert!(
+            encoded.contains(&resident_memory),
+            "encoded does not contain expected resident_memory"
+        );
+    }
+
+    #[test]
+    fn register_virtual_memory() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let virtual_memory = "# HELP process_virtual_memory_bytes Virtual memory size in bytes\n"
+            .to_owned()
+            + "# TYPE process_virtual_memory_bytes gauge\n"
+            + "# UNIT process_virtual_memory_bytes bytes\n"
+            + "process_virtual_memory_bytes ";
+
+        assert!(
+            encoded.contains(&virtual_memory),
+            "encoded does not contain expected virtual_memory"
+        );
+    }
+
+    #[test]
+    fn register_virtual_memory_max() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let virtual_memory_max = "# HELP process_virtual_memory_max Maximum amount of virtual memory available in bytes.\n".to_owned() +
+            "# TYPE process_virtual_memory_max gauge\n" +
+            "process_virtual_memory_max ";
+
+        assert!(
+            encoded.contains(&virtual_memory_max),
+            "encoded does not contain expected virtual_memory_max"
+        );
+    }
+
+    #[test]
+    fn register_open_fds() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let open_fds = "# HELP process_open_fds Number of open file descriptors.\n".to_owned()
+            + "# TYPE process_open_fds counter\n"
+            + "process_open_fds_total ";
+
+        assert!(
+            encoded.contains(&open_fds),
+            "encoded does not contain expected open_fds"
+        );
+    }
+
+    #[test]
+    fn register_max_fds() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let max_fds = "# HELP process_max_fds Maximum number of open file descriptors.\n"
+            .to_owned()
+            + "# TYPE process_max_fds gauge\n"
+            + "process_max_fds ";
+
+        assert!(
+            encoded.contains(&max_fds),
+            "encoded does not contain expected max_fds"
+        );
+    }
+
+    #[test]
+    fn register_cpu_seconds() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let cpu_seconds =
+            "# HELP process_cpu_seconds Total user and system CPU time spent in seconds.\n"
+                .to_owned()
+                + "# TYPE process_cpu_seconds counter\n"
+                + "# UNIT process_cpu_seconds seconds\n"
+                + "process_cpu_seconds_total ";
+
+        assert!(
+            encoded.contains(&cpu_seconds),
+            "encoded does not contain expected cpu_seconds"
+        );
+    }
+
+    #[test]
+    fn register_network_receive() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let network_receive = "# HELP process_network_receive_bytes Number of bytes received by the process over the network.\n".to_owned() +
+        "# TYPE process_network_receive_bytes counter\n" +
+        "# UNIT process_network_receive_bytes bytes\n" +
+        "process_network_receive_bytes_total ";
+
+        assert!(
+            encoded.contains(&network_receive),
+            "encoded does not contain expected network_receive"
+        );
+    }
+
+    #[test]
+    fn register_network_transmit() {
+        let mut registry = Registry::default();
+        let processor_collector = ProcessCollector::new(None).unwrap();
+        registry.register_collector(Box::new(processor_collector));
+        let mut encoded = String::new();
+        encode(&mut encoded, &registry).unwrap();
+
+        let network_transmit = "# HELP process_network_transmit_bytes Number of bytes sent by the process over the network.\n".to_owned() +
+        "# TYPE process_network_transmit_bytes counter\n" +
+        "# UNIT process_network_transmit_bytes bytes\n" +
+        "process_network_transmit_bytes_total ";
+
+        assert!(
+            encoded.contains(&network_transmit),
+            "encoded does not contain expected network_transmit"
+        );
     }
 }

process-collector/src/linux/netstat.rs

@@ -55,13 +55,12 @@ fn parse_proc_netstat<R: io::Read>(reader: R, file_name: &str) -> io::Result<Net
                 )
             })?;
             let key = name_parts[i];
-            match protocol {
-                "IpExt" => match key {
+            if protocol == "IpExt" {
+                match key {
                     "InOctets" => proc_netstat.ip_ext.in_octets = Some(value),
                     "OutOctets" => proc_netstat.ip_ext.out_octets = Some(value),
                     _ => {}
-                },
-                _ => {}
+                }
             }
         }
     }

process-collector/src/linux/system.rs

@@ -59,7 +59,7 @@ impl System {
         let tps = procfs::ticks_per_second();
         let cpu_time = (stat.stime + stat.utime) / tps;
         let counter = ConstCounter::new(cpu_time);
-        let metric_name = format!("{}process_cpu_seconds_total", &self.namespace);
+        let metric_name = format!("{}process_cpu", &self.namespace);
         let metric_encoder = encoder.encode_descriptor(
             &metric_name,
             "Total user and system CPU time spent in seconds.",
@@ -116,7 +116,7 @@ impl System {
                 LimitValue::Value(soft) => soft,
             };
             let gauge = ConstGauge::new(max_virtual_memory as i64);
-            let metric_name = format!("{}process_virtual_memory_max_bytes", &self.namespace);
+            let metric_name = format!("{}process_virtual_memory_max", &self.namespace);
             let metric_encoder = encoder.encode_descriptor(
                 &metric_name,
                 "Maximum amount of virtual memory available in bytes.",
@@ -135,7 +135,7 @@ impl System {
         encoder: &mut prometheus_client::encoding::DescriptorEncoder,
     ) -> SystemResult {
         let vm_bytes = ConstGauge::new(stat.vsize as i64);
-        let metric_name = format!("{}process_virtual_memory_bytes", &self.namespace);
+        let metric_name = format!("{}process_virtual_memory", &self.namespace);
         let vme = encoder.encode_descriptor(
             &metric_name,
             "Virtual memory size in bytes",
@@ -153,7 +153,7 @@ impl System {
         encoder: &mut prometheus_client::encoding::DescriptorEncoder,
     ) -> SystemResult {
         let rss_bytes = ConstGauge::new((stat.rss * self.page_size) as i64);
-        let metric_name = format!("{}process_resident_memory_bytes", &self.namespace);
+        let metric_name = format!("{}process_resident_memory", &self.namespace);
         let rsse = encoder.encode_descriptor(
             &metric_name,
             "Resident memory size in bytes.",
@@ -173,7 +173,7 @@ impl System {
         match Netstat::read(stat.pid) {
             Ok(Netstat { ip_ext, .. }) => {
                 let recv_bytes = ConstCounter::new(ip_ext.in_octets.unwrap_or_default());
-                let metric_name = format!("{}process_network_receive_bytes_total", &self.namespace);
+                let metric_name = format!("{}process_network_receive", &self.namespace);
                 let rbe = encoder.encode_descriptor(
                     &metric_name,
                     "Number of bytes received by the process over the network.",
@@ -183,8 +183,7 @@ impl System {
                 recv_bytes.encode(rbe)?;
 
                 let transmit_bytes = ConstCounter::new(ip_ext.out_octets.unwrap_or_default());
-                let metric_name =
-                    format!("{}process_network_transmit_bytes_total", &self.namespace);
+                let metric_name = format!("{}process_network_transmit", &self.namespace);
                 let tbe = encoder.encode_descriptor(
                     &metric_name,
                     "Number of bytes sent by the process over the network.",