Add sector plotting metrics to farmer

Author: nazar-pc

crates/subspace-farmer/src/bin/subspace-farmer/commands/farm.rs

@@ -703,15 +703,30 @@ where
                     let farmer_metrics = farmer_metrics.clone();
 
                     move |(_sector_index, sector_state)| match sector_state {
+                        SectorUpdate::Plotting(SectorPlottingDetails::Starting { .. }) => {
+                            farmer_metrics.sector_plotting.inc();
+                        }
+                        SectorUpdate::Plotting(SectorPlottingDetails::Downloading) => {
+                            farmer_metrics.sector_downloading.inc();
+                        }
                         SectorUpdate::Plotting(SectorPlottingDetails::Downloaded(time)) => {
                             farmer_metrics
                                 .observe_sector_downloading_time(&single_disk_farm_id, time);
+                            farmer_metrics.sector_downloaded.inc();
+                        }
+                        SectorUpdate::Plotting(SectorPlottingDetails::Encoding) => {
+                            farmer_metrics.sector_encoding.inc();
                         }
                         SectorUpdate::Plotting(SectorPlottingDetails::Encoded(time)) => {
                             farmer_metrics.observe_sector_encoding_time(&single_disk_farm_id, time);
+                            farmer_metrics.sector_encoded.inc();
+                        }
+                        SectorUpdate::Plotting(SectorPlottingDetails::Writing) => {
+                            farmer_metrics.sector_writing.inc();
                         }
-                        SectorUpdate::Plotting(SectorPlottingDetails::Wrote(time)) => {
+                        SectorUpdate::Plotting(SectorPlottingDetails::Written(time)) => {
                             farmer_metrics.observe_sector_writing_time(&single_disk_farm_id, time);
+                            farmer_metrics.sector_written.inc();
                         }
                         SectorUpdate::Plotting(SectorPlottingDetails::Finished {
                             plotted_sector,
@@ -720,6 +735,7 @@ where
                         }) => {
                             on_plotted_sector_callback(plotted_sector, old_plotted_sector);
                             farmer_metrics.observe_sector_plotting_time(&single_disk_farm_id, time);
+                            farmer_metrics.sector_plotted.inc();
                         }
                         _ => {}
                     }

crates/subspace-farmer/src/bin/subspace-farmer/commands/farm/metrics.rs

@@ -1,22 +1,32 @@
+use prometheus_client::metrics::counter::Counter;
 use prometheus_client::metrics::family::Family;
 use prometheus_client::metrics::histogram::{exponential_buckets, Histogram};
 use prometheus_client::registry::{Registry, Unit};
+use std::sync::atomic::AtomicU64;
 use std::time::Duration;
 use subspace_farmer::single_disk_farm::farming::ProvingResult;
 use subspace_farmer::single_disk_farm::SingleDiskFarmId;
 
 #[derive(Debug, Clone)]
-pub(crate) struct FarmerMetrics {
+pub(super) struct FarmerMetrics {
     auditing_time: Family<Vec<(String, String)>, Histogram>,
     proving_time: Family<Vec<(String, String)>, Histogram>,
     sector_downloading_time: Family<Vec<(String, String)>, Histogram>,
     sector_encoding_time: Family<Vec<(String, String)>, Histogram>,
     sector_writing_time: Family<Vec<(String, String)>, Histogram>,
     sector_plotting_time: Family<Vec<(String, String)>, Histogram>,
+    pub(super) sector_downloading: Counter<u64, AtomicU64>,
+    pub(super) sector_downloaded: Counter<u64, AtomicU64>,
+    pub(super) sector_encoding: Counter<u64, AtomicU64>,
+    pub(super) sector_encoded: Counter<u64, AtomicU64>,
+    pub(super) sector_writing: Counter<u64, AtomicU64>,
+    pub(super) sector_written: Counter<u64, AtomicU64>,
+    pub(super) sector_plotting: Counter<u64, AtomicU64>,
+    pub(super) sector_plotted: Counter<u64, AtomicU64>,
 }
 
 impl FarmerMetrics {
-    pub(crate) fn new(registry: &mut Registry) -> Self {
+    pub(super) fn new(registry: &mut Registry) -> Self {
         let sub_registry = registry.sub_registry_with_prefix("subspace_farmer");
 
         let auditing_time = Family::<_, _>::new_with_constructor(|| {
@@ -85,17 +95,97 @@ impl FarmerMetrics {
             sector_plotting_time.clone(),
         );
 
+        let sector_downloading = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_downloading_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_downloading.clone(),
+        );
+
+        let sector_downloaded = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_downloaded_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_downloaded.clone(),
+        );
+
+        let sector_encoding = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_encoding_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_encoding.clone(),
+        );
+
+        let sector_encoded = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_encoded_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_encoded.clone(),
+        );
+
+        let sector_writing = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_writing_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_writing.clone(),
+        );
+
+        let sector_written = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_written_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_written.clone(),
+        );
+
+        let sector_plotting = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_plotting_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_plotting.clone(),
+        );
+
+        let sector_plotted = Counter::<_, _>::default();
+
+        sub_registry.register_with_unit(
+            "sector_plotted_counter",
+            "Number of sectors being downloaded",
+            Unit::Other("sectors".to_string()),
+            sector_plotted.clone(),
+        );
+
         Self {
             auditing_time,
             proving_time,
             sector_downloading_time,
             sector_encoding_time,
             sector_writing_time,
             sector_plotting_time,
+            sector_downloading,
+            sector_downloaded,
+            sector_encoding,
+            sector_encoded,
+            sector_writing,
+            sector_written,
+            sector_plotting,
+            sector_plotted,
         }
     }
 
-    pub(crate) fn observe_auditing_time(
+    pub(super) fn observe_auditing_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,
@@ -108,7 +198,7 @@ impl FarmerMetrics {
             .observe(time.as_secs_f64());
     }
 
-    pub(crate) fn observe_proving_time(
+    pub(super) fn observe_proving_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,
@@ -122,7 +212,7 @@ impl FarmerMetrics {
             .observe(time.as_secs_f64());
     }
 
-    pub(crate) fn observe_sector_downloading_time(
+    pub(super) fn observe_sector_downloading_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,
@@ -135,7 +225,7 @@ impl FarmerMetrics {
             .observe(time.as_secs_f64());
     }
 
-    pub(crate) fn observe_sector_encoding_time(
+    pub(super) fn observe_sector_encoding_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,
@@ -148,7 +238,7 @@ impl FarmerMetrics {
             .observe(time.as_secs_f64());
     }
 
-    pub(crate) fn observe_sector_writing_time(
+    pub(super) fn observe_sector_writing_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,
@@ -161,7 +251,7 @@ impl FarmerMetrics {
             .observe(time.as_secs_f64());
     }
 
-    pub(crate) fn observe_sector_plotting_time(
+    pub(super) fn observe_sector_plotting_time(
         &self,
         single_disk_farm_id: &SingleDiskFarmId,
         time: &Duration,

crates/subspace-farmer/src/single_disk_farm.rs

@@ -560,8 +560,8 @@ pub enum SectorPlottingDetails {
     Encoded(Duration),
     /// Writing sector
     Writing,
-    /// Wrote sector
-    Wrote(Duration),
+    /// Written sector
+    Written(Duration),
     /// Finished plotting
     Finished {
         /// Information about plotted sector

crates/subspace-farmer/src/single_disk_farm/plotting.rs

@@ -402,7 +402,7 @@ where
 
             handlers.sector_update.call_simple(&(
                 sector_index,
-                SectorUpdate::Plotting(SectorPlottingDetails::Wrote(start.elapsed())),
+                SectorUpdate::Plotting(SectorPlottingDetails::Written(start.elapsed())),
             ));
         }