refactor: using metric generator for stdout exporter's host metrics

src/exporters/mod.rs

@@ -45,6 +45,7 @@ struct Metric {
     timestamp: Duration,
 }
 
+#[derive(Clone)]
 enum MetricValueType {
     // IntSigned(i64),
     // Float(f32),
@@ -53,6 +54,18 @@ enum MetricValueType {
     IntUnsigned(u64),
 }
 
+impl fmt::Display for MetricValueType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self {
+            // MetricValueType::IntSigned(value) => write!(f, "{}", value),
+            // MetricValueType::Float(value) => write!(f, "{}", value),
+            MetricValueType::Text(text) => write!(f, "{}", text),
+            MetricValueType::FloatDouble(value) => write!(f, "{}", value),
+            MetricValueType::IntUnsigned(value) => write!(f, "{}", value),
+        }
+    }
+}
+
 impl fmt::Debug for MetricValueType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self {
@@ -65,6 +78,7 @@ impl fmt::Debug for MetricValueType {
     }
 }
 
+
 /// An Exporter is what tells scaphandre when to collect metrics and how to export
 /// or expose them.
 /// Its basic role is to instanciate a Sensor, get the data the sensor has to offer

src/exporters/prometheus.rs

@@ -86,7 +86,7 @@ impl Exporter for PrometheusExporter {
         options.push(arg);
 
         let arg = Arg::with_name("qemu")
-            .help("Instruct that scaphandre is running on an hypervisor")
+            .help("Apply labels to metrics of processes looking like a Qemu/KVM virtual machine")
             .long("qemu")
             .short("q")
             .required(false)

src/exporters/stdout.rs

@@ -58,6 +58,14 @@ impl Exporter for StdoutExporter {
             .takes_value(true);
         options.push(arg);
 
+        let arg = Arg::with_name("qemu")
+            .help("Apply labels to metrics of processes looking like a Qemu/KVM virtual machine")
+            .long("qemu")
+            .short("q")
+            .required(false)
+            .takes_value(false);
+        options.push(arg);
+
         options
     }
 }
@@ -118,14 +126,14 @@ impl StdoutExporter {
         println!("Measurement step is: {}s", step_duration);
         if timeout_secs == 0 {
             loop {
-                self.iterate(&regex_filter, process_number);
+                self.iterate(&regex_filter, process_number, parameters.is_present("qemu"));
                 thread::sleep(Duration::new(step_duration, 0));
             }
         } else {
             let now = Instant::now();
 
             while now.elapsed().as_secs() <= timeout_secs {
-                self.iterate(&regex_filter, process_number);
+                self.iterate(&regex_filter, process_number, parameters.is_present("qemu"));
                 thread::sleep(Duration::new(step_duration, 0));
             }
         }
@@ -151,16 +159,27 @@ impl StdoutExporter {
         }
     }
 
-    fn iterate(&mut self, regex_filter: &Option<Regex>, process_number: u16) {
+    fn iterate(&mut self, regex_filter: &Option<Regex>, process_number: u16, qemu: bool) {
         self.topology.refresh();
-        self.show_metrics(regex_filter, process_number);
+        self.show_metrics(regex_filter, process_number, qemu);
     }
 
-    fn show_metrics(&self, regex_filter: &Option<Regex>, process_number: u16) {
-        let host_power = match self.topology.get_records_diff_power_microwatts() {
-            Some(record) => record.value.parse::<u64>().unwrap(),
-            None => 0,
+    fn show_metrics(&self, regex_filter: &Option<Regex>, process_number: u16, qemu: bool) {
+        let hostname = utils::get_hostname();
+        let mut metric_generator = MetricGenerator::new(&self.topology, &hostname);
+        metric_generator.gen_all_metrics(qemu);
+
+        let metrics = metric_generator.get_metrics();
+        let mut metrics_iter = metrics.iter();
+        let host_power =  match metrics_iter.find(|x| x.name == "scaph_host_power_microwatts") {
+            Some(m) => m.metric_value.clone(),
+            None => MetricValueType::Text("0".to_string())
         };
+        //let host_power = match self.topology.get_records_diff_power_microwatts() {
+        //    Some(record) => record.value.parse::<u64>().unwrap(),
+        //    None => 0,
+        //};
+
         let mut sockets_power: HashMap<u16, (u64, HashMap<String, Option<Record>>)> =
             HashMap::new();
         let sockets = self.topology.get_sockets_passive();
@@ -173,7 +192,7 @@ impl StdoutExporter {
         }
         let domain_names = self.topology.domains_names.as_ref().unwrap();
 
-        println!("Host:\t{} W", (host_power as f32 / 1000000.0));
+        println!("Host:\t{} W", (format!("{}", host_power).parse::<f64>().unwrap() / 1000000.0));
         println!("\tpackage \t{}", domain_names.join("\t\t"));
 
         for (s_id, v) in sockets_power.iter() {
@@ -222,7 +241,7 @@ impl StdoutExporter {
                     println!(
                         "{} W\t{}\t{:?}",
                         ((c.1 as f32 / (host_time * procfs::ticks_per_second().unwrap() as f32))
-                            * host_power as f32)
+                            * format!("{}", host_power).parse::<f32>().unwrap())
                             / 1000000.0,
                         c.0.pid,
                         c.0.exe().unwrap_or_default()