fix(analyze): outages were not displayed #34

src/analyze.rs

@@ -33,7 +33,7 @@ use chrono::{DateTime, Local};
 use deepsize::DeepSizeOf;
 
 use crate::errors::AnalysisError;
-use crate::records::{Check, CheckType, IpType};
+use crate::records::{indented_check, Check, CheckType, IpType};
 use crate::store::Store;
 
 use std::fmt::{Display, Write};
@@ -211,38 +211,44 @@ fn key_value_write(
 /// Outage records for reporting.
 fn outages(store: &Store, f: &mut String) -> Result<(), AnalysisError> {
     let all_checks: Vec<&Check> = store.checks().iter().collect();
-    let mut outages: Vec<Outage> = Vec::new();
-    let fails_exist = all_checks
-        .iter()
-        .fold(true, |fails_exist, c| fails_exist & !c.is_success());
+    let fails_exist = !all_checks.iter().all(|c| c.is_success());
     if !fails_exist || all_checks.is_empty() {
         writeln!(f, "None\n")?;
         return Ok(());
     }
 
-    for check_type in CheckType::all() {
-        let checks: Vec<&&Check> = all_checks
-            .iter()
-            .filter(|c| c.calc_type().unwrap_or(CheckType::Unknown) == *check_type)
-            .collect();
+    let failed_checks: Vec<&&Check> = all_checks.iter().filter(|c| !c.is_success()).collect();
 
-        let fail_groups = fail_groups(&checks);
-        for group in fail_groups {
-            // writeln!(f, "Group {gidx}:")?;
-            // display_group(group, f)?;
-            if !group.is_empty() {
-                outages.push(Outage::new(
-                    checks.first().unwrap(),
-                    Some(checks.last().unwrap()),
-                    &group,
-                ));
+    let fail_groups = fail_groups(&failed_checks);
+    for (outage_idx, group) in fail_groups.into_iter().enumerate() {
+        writeln!(f, "{outage_idx}")?;
+        if !group.is_empty() {
+            if group.len() == 1 {
+                // Single check failure
+                let check = group[0];
+                writeln!(f, "\tSingle failure")?;
+                writeln!(f, "\n\tDetails")?;
+                indented_check(f, check)?;
+            } else {
+                // Group of failures - use actual first and last from the group
+                let start = group.first().unwrap();
+                let end = group.last();
+                writeln!(f, "\tFailed checks: {}", group.len())?;
+                writeln!(f, "\tFirst Failure")?;
+                writeln!(f, "\n\tDetails")?;
+                indented_check(f, start)?;
+                writeln!(f, "\tLast Failure")?;
+                writeln!(f, "\n\tDetails")?;
+                if let Some(check) = end {
+                    indented_check(f, check)?;
+                } else {
+                    writeln!(f, "\t(None)")?;
+                }
             }
         }
     }
+    writeln!(f)?;
 
-    for outage in outages {
-        writeln!(f, "{outage}")?;
-    }
     Ok(())
 }
 

src/records.rs

@@ -462,6 +462,10 @@ pub fn display_group(group: &[&Check], f: &mut String) -> Result<(), std::fmt::E
     Ok(())
 }
 
+pub(crate) fn indented_check(buf: &mut String, check: &Check) -> Result<(), std::fmt::Error> {
+    writeln!(buf, "\t{}", check.to_string().replace("\n", "\n\t"))
+}
+
 #[cfg(test)]
 mod test {
     use crate::TIMEOUT_MS;