Split logging of performance metrics into better readable lines (#4)

* Split logging of performance metrics

Affects:
- daemon.rs
- simpa

* Make daemon.rs log perf metrics if enabled

* Log perf metrics via impl Display

* Remove loglevel default changes

With impl Display, we don't need to change loglevels
to display perf metrics

kaspad/src/daemon.rs

@@ -6,7 +6,9 @@ use kaspa_consensus_core::{
     errors::config::{ConfigError, ConfigResult},
 };
 use kaspa_consensus_notify::{root::ConsensusNotificationRoot, service::NotifyService};
-use kaspa_core::{core::Core, info, trace};
+#[cfg(feature = "heap")]
+use kaspa_core::trace;
+use kaspa_core::{core::Core, info};
 use kaspa_core::{kaspad_env::version, task::tick::TickService};
 use kaspa_grpc_server::service::GrpcService;
 use kaspa_rpc_service::service::RpcCoreService;
@@ -29,7 +31,7 @@ use kaspa_mining::{
 };
 use kaspa_p2p_flows::{flow_context::FlowContext, service::P2pService};
 
-use kaspa_perf_monitor::builder::Builder as PerfMonitorBuilder;
+use kaspa_perf_monitor::{builder::Builder as PerfMonitorBuilder, counters::CountersSnapshot};
 use kaspa_utxoindex::{api::UtxoIndexProxy, UtxoIndex};
 use kaspa_wrpc_server::service::{Options as WrpcServerOptions, ServerCounters as WrpcServerCounters, WrpcEncoding, WrpcService};
 
@@ -377,8 +379,8 @@ do you confirm? (answer y/n or pass --yes to the Kaspad command line to confirm
         .with_fetch_interval(Duration::from_secs(args.perf_metrics_interval_sec))
         .with_tick_service(tick_service.clone());
     let perf_monitor = if args.perf_metrics {
-        let cb = move |counters| {
-            trace!("[{}] metrics: {:?}", kaspa_perf_monitor::SERVICE_NAME, counters);
+        let cb = move |counters: CountersSnapshot| {
+            info!("{}", counters);
             #[cfg(feature = "heap")]
             trace!("[{}] heap stats: {:?}", kaspa_perf_monitor::SERVICE_NAME, dhat::HeapStats::get());
         };

metrics/perf_monitor/src/counters.rs

@@ -1,5 +1,8 @@
 use portable_atomic::{AtomicF64, AtomicUsize};
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::{
+    fmt::Display,
+    sync::atomic::{AtomicU64, Ordering},
+};
 
 #[derive(Debug, Default)]
 pub(crate) struct Counters {
@@ -79,3 +82,48 @@ pub struct CountersSnapshot {
     pub disk_io_read_per_sec: f64,
     pub disk_io_write_per_sec: f64,
 }
+
+fn to_human_readable(mut number_to_format: f64, precision: usize, suffix: &str) -> String {
+    let units = ["", "K", "M", "G", "T", "P", "E"];
+    let mut found_unit = "";
+
+    for unit in units {
+        if number_to_format < 1000.0 {
+            found_unit = unit;
+            break;
+        } else {
+            number_to_format /= 1000.0
+        }
+    }
+
+    format!("{number_to_format:.precision$}{}{}", found_unit, suffix)
+}
+
+impl Display for CountersSnapshot {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Performance Metrics")?;
+        writeln!(
+            f,
+            "Process Metrics: RSS: {} ({}), VIRT: {} ({}), cores: {}, cpu usage (per core): {}",
+            self.resident_set_size,
+            to_human_readable(self.resident_set_size as f64, 2, "B"),
+            self.virtual_memory_size,
+            to_human_readable(self.virtual_memory_size as f64, 2, "B"),
+            self.core_num,
+            self.cpu_usage
+        )?;
+        write!(
+            f,
+            "Disk IO Metrics: FD: {}, read: {} ({}), write: {} ({}), read rate: {} ({}), write rate: {} ({})",
+            self.fd_num,
+            self.disk_io_read_bytes,
+            to_human_readable(self.disk_io_read_bytes as f64, 0, "B"),
+            self.disk_io_write_bytes,
+            to_human_readable(self.disk_io_write_bytes as f64, 0, "B"),
+            self.disk_io_read_per_sec,
+            to_human_readable(self.disk_io_read_per_sec, 0, "B/s"),
+            self.disk_io_write_per_sec,
+            to_human_readable(self.disk_io_write_per_sec, 0, "B/s")
+        )
+    }
+}

simpa/src/main.rs

@@ -23,7 +23,7 @@ use kaspa_core::{info, task::service::AsyncService, task::tick::TickService, tim
 use kaspa_database::prelude::ConnBuilder;
 use kaspa_database::{create_temp_db, load_existing_db};
 use kaspa_hashes::Hash;
-use kaspa_perf_monitor::builder::Builder;
+use kaspa_perf_monitor::{builder::Builder, counters::CountersSnapshot};
 use kaspa_utils::fd_budget;
 use simulator::network::KaspaNetworkSimulator;
 use std::{collections::VecDeque, sync::Arc, time::Duration};
@@ -138,8 +138,9 @@ fn main_impl(mut args: Args) {
 
     let stop_perf_monitor = args.perf_metrics.then(|| {
         let ts = Arc::new(TickService::new());
-        let cb = move |counters| {
-            trace!("metrics: {:?}", counters);
+
+        let cb = move |counters: CountersSnapshot| {
+            trace!("{}", counters);
             #[cfg(feature = "heap")]
             trace!("heap stats: {:?}", dhat::HeapStats::get());
         };