Add latency measurements to json outputs

src/measurements.rs

@@ -24,6 +24,14 @@ pub struct Measurement {
     pub mbit: f64,
 }
 
+#[derive(Serialize)]
+pub struct LatencyMeasurement {
+    pub avg_latency_ms: f64,
+    pub min_latency_ms: f64,
+    pub max_latency_ms: f64,
+    pub latency_measurements: Vec<f64>,
+}
+
 impl Display for Measurement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -38,6 +46,7 @@ impl Display for Measurement {
 
 pub(crate) fn log_measurements(
     measurements: &[Measurement],
+    latency_measurement: Option<&LatencyMeasurement>,
     payload_sizes: Vec<usize>,
     verbose: bool,
     output_format: OutputFormat,
@@ -70,12 +79,33 @@ pub(crate) fn log_measurements(
             wtr.flush().unwrap();
         }
         OutputFormat::Json => {
-            serde_json::to_writer(io::stdout(), &stat_measurements).unwrap();
+            let mut output = serde_json::Map::new();
+            output.insert(
+                "speed_measurements".to_string(),
+                serde_json::to_value(&stat_measurements).unwrap(),
+            );
+            if let Some(latency) = latency_measurement {
+                output.insert(
+                    "latency_measurement".to_string(),
+                    serde_json::to_value(latency).unwrap(),
+                );
+            }
+            serde_json::to_writer(io::stdout(), &output).unwrap();
             println!();
         }
         OutputFormat::JsonPretty => {
-            // json_pretty output test
-            serde_json::to_writer_pretty(io::stdout(), &stat_measurements).unwrap();
+            let mut output = serde_json::Map::new();
+            output.insert(
+                "speed_measurements".to_string(),
+                serde_json::to_value(&stat_measurements).unwrap(),
+            );
+            if let Some(latency) = latency_measurement {
+                output.insert(
+                    "latency_measurement".to_string(),
+                    serde_json::to_value(latency).unwrap(),
+                );
+            }
+            serde_json::to_writer_pretty(io::stdout(), &output).unwrap();
             println!();
         }
         OutputFormat::StdOut => {}

src/speedtest.rs

@@ -1,5 +1,6 @@
 use crate::measurements::format_bytes;
 use crate::measurements::log_measurements;
+use crate::measurements::LatencyMeasurement;
 use crate::measurements::Measurement;
 use crate::progress::print_progress;
 use crate::OutputFormat;
@@ -93,7 +94,25 @@ pub fn speed_test(client: Client, options: SpeedTestCLIOptions) -> Vec<Measureme
     if options.output_format == OutputFormat::StdOut {
         println!("{metadata}");
     }
-    run_latency_test(&client, options.nr_latency_tests, options.output_format);
+    let (latency_measurements, avg_latency) =
+        run_latency_test(&client, options.nr_latency_tests, options.output_format);
+    let latency_measurement = if !latency_measurements.is_empty() {
+        Some(LatencyMeasurement {
+            avg_latency_ms: avg_latency,
+            min_latency_ms: latency_measurements
+                .iter()
+                .copied()
+                .fold(f64::INFINITY, f64::min),
+            max_latency_ms: latency_measurements
+                .iter()
+                .copied()
+                .fold(f64::NEG_INFINITY, f64::max),
+            latency_measurements,
+        })
+    } else {
+        None
+    };
+
     let payload_sizes = PayloadSize::sizes_from_max(options.max_payload_size.clone());
     let mut measurements = Vec::new();
 
@@ -123,6 +142,7 @@ pub fn speed_test(client: Client, options: SpeedTestCLIOptions) -> Vec<Measureme
 
     log_measurements(
         &measurements,
+        latency_measurement.as_ref(),
         payload_sizes,
         options.verbose,
         options.output_format,