feat(graph): show how many checks are in the store for each minute

Author: PlexSheep

.zed/tasks.json

@@ -0,0 +1,17 @@
+// Static tasks configuration.
+//
+// Example:
+[
+    {
+        "label": "make graph",
+        "command": "cargo run --release -- --graph",
+        "env": {
+            "NETPULSE_LOG_LEVEL": "TRACE"
+        },
+        "use_new_terminal": false,
+        "allow_concurrent_runs": false,
+        "reveal": "no_focus",
+        "reveal_target": "dock",
+        "hide": "never"
+    }
+]

src/analyze.rs

@@ -29,8 +29,9 @@
 //! - Outage analysis
 //! - Store metadata (hashes, versions)
 
-use chrono::{DateTime, Local};
+use chrono::{DateTime, Local, TimeDelta};
 use deepsize::DeepSizeOf;
+use plotters::prelude::IntoMonthly;
 use tracing::{error, trace};
 
 use crate::errors::AnalysisError;
@@ -39,6 +40,7 @@ use crate::store::Store;
 
 use std::collections::HashMap;
 use std::fmt::{Display, Write};
+use std::ops::RangeBounds;
 use std::os::unix::fs::MetadataExt;
 
 use self::outage::Outage;
@@ -226,6 +228,27 @@ pub fn outages_detailed(all: &[&Check], f: &mut String, dump: bool) -> Result<()
     Ok(())
 }
 
+pub fn checks_per_time_group<'check>(
+    checks: impl IntoIterator<Item = &'check Check>,
+) -> HashMap<i64, usize> {
+    let cbt = group_by_time(checks);
+    assert!(!cbt.is_empty());
+    let mut times: Vec<_> = cbt.values().collect();
+    times.sort();
+    let time_start = times.first().unwrap()[0].timestamp();
+    let time_end = times.last().unwrap()[0].timestamp();
+
+    let mut buf: HashMap<i64, usize> = HashMap::new();
+
+    let mut current = time_start;
+    while current < time_end {
+        buf.insert(current, cbt.get(&current).map(|a| a.len()).unwrap_or(0));
+        current += 60;
+    }
+
+    buf
+}
+
 pub fn group_by_time<'check>(
     checks: impl IntoIterator<Item = &'check Check>,
 ) -> HashMap<i64, CheckGroup<'check>> {

src/analyze/graph.rs

@@ -1,7 +1,7 @@
 use std::fmt::Write;
 use std::path::Path;
 
-use chrono::{DateTime, Local};
+use chrono::{DateTime, Local, TimeZone};
 use plotters::prelude::*;
 use tracing::trace;
 
@@ -23,10 +23,6 @@ pub fn draw_checks(checks: &[Check], file: impl AsRef<Path>) -> Result<(), Analy
     times.sort();
     let timespan =
         times.first().unwrap()[0].timestamp_parsed()..times.last().unwrap()[0].timestamp_parsed();
-    let mut x_axis: Vec<_> = Vec::new();
-    for t in 0..time_grouped.len() {
-        x_axis.push(t);
-    }
 
     for group in time_grouped.values() {
         data.push((
@@ -36,6 +32,13 @@ pub fn draw_checks(checks: &[Check], file: impl AsRef<Path>) -> Result<(), Analy
     }
     data.sort_by_key(|a| a.0);
 
+    let cpt = super::checks_per_time_group(checks.iter());
+    let mut checks_per_time: Vec<(DateTime<Local>, usize)> = cpt
+        .iter()
+        .map(|(k, v)| (Local.timestamp_opt(*k, 0).unwrap(), *v))
+        .collect();
+    checks_per_time.sort_by_key(|a| a.0);
+
     let root = BitMapBackend::new(outfile, (1920, 1080)).into_drawing_area();
     root.fill(&WHITE).map_err(|e| AnalysisError::GraphDraw {
         reason: e.to_string(),
@@ -45,11 +48,16 @@ pub fn draw_checks(checks: &[Check], file: impl AsRef<Path>) -> Result<(), Analy
         .margin(10)
         .caption("Outage Severity over all time", ("sans-serif", 60))
         .set_label_area_size(LabelAreaPosition::Left, 60)
-        .set_label_area_size(LabelAreaPosition::Bottom, 30)
-        .build_cartesian_2d(timespan, 0.0..1.0)
+        .set_label_area_size(LabelAreaPosition::Right, 60)
+        .set_label_area_size(LabelAreaPosition::Bottom, 60)
+        .build_cartesian_2d(timespan.clone(), 0.0..1.0)
         .map_err(|e| AnalysisError::GraphDraw {
             reason: e.to_string(),
-        })?;
+        })?
+        .set_secondary_coord(
+            timespan,
+            0f64..checks_per_time.last().map(|a| a.1 as f64).unwrap(),
+        );
 
     chart
         .configure_mesh()
@@ -61,17 +69,24 @@ pub fn draw_checks(checks: &[Check], file: impl AsRef<Path>) -> Result<(), Analy
         .map_err(|e| AnalysisError::GraphDraw {
             reason: e.to_string(),
         })?;
+    chart
+        .configure_secondary_axes()
+        .y_desc("Amount of Checks")
+        .draw()
+        .map_err(|e| AnalysisError::GraphDraw {
+            reason: e.to_string(),
+        })?;
+
+    let processed_serevity_data = data.iter().map(|(a, b)| (*a, f64::from(*b)));
+    chart
+        .draw_series(AreaSeries::new(processed_serevity_data, 0.0, RED.mix(0.2)).border_style(RED))
+        .map_err(|e| AnalysisError::GraphDraw {
+            reason: e.to_string(),
+        })?;
 
-    let processed_data = data.iter().map(|(a, b)| (*a, f64::from(*b)));
-    trace!("dumping whole processed data: \n{}", {
-        let mut buf = String::new();
-        for (idx, row) in processed_data.clone().enumerate() {
-            writeln!(buf, "{:08},{},{:.06}", idx, row.0, row.1).unwrap();
-        }
-        buf
-    });
+    let checks_per_time_f64 = checks_per_time.into_iter().map(|(t, v)| (t, v as f64));
     chart
-        .draw_series(AreaSeries::new(processed_data, 0.0, RED.mix(0.2)).border_style(RED))
+        .draw_series(AreaSeries::new(checks_per_time_f64, 0.0, BLUE.mix(0.2)))
         .map_err(|e| AnalysisError::GraphDraw {
             reason: e.to_string(),
         })?;

src/analyze/outage.rs

@@ -81,6 +81,12 @@ pub enum Severity {
     None,
 }
 
+impl Severity {
+    pub fn raw(self) -> f64 {
+        f64::from(self)
+    }
+}
+
 impl From<&[&Check]> for Severity {
     fn from(value: &[&Check]) -> Self {
         let percentage: f64 =