From 22c5618ca96267114afed9c36e2e5039f0224280 Mon Sep 17 00:00:00 2001
From: Mathias Wagner <germannewsmaker@gmail.com>
Date: Thu, 12 Jun 2025 12:14:45 +0200
Subject: [PATCH 1/2] Add detailed latency measurements to output and logging

---
 src/measurements.rs | 24 +++++++++++++++++++++---
 src/speedtest.rs    | 15 ++++++++++++++-
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/src/measurements.rs b/src/measurements.rs
index d063e8d..9d77504 100644
--- a/src/measurements.rs
+++ b/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,21 @@ 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 => {}
diff --git a/src/speedtest.rs b/src/speedtest.rs
index 262071f..37e59a6 100644
--- a/src/speedtest.rs
+++ b/src/speedtest.rs
@@ -1,6 +1,7 @@
 use crate::measurements::format_bytes;
 use crate::measurements::log_measurements;
 use crate::measurements::Measurement;
+use crate::measurements::LatencyMeasurement;
 use crate::progress::print_progress;
 use crate::OutputFormat;
 use crate::SpeedTestCLIOptions;
@@ -87,7 +88,18 @@ 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();
 
@@ -117,6 +129,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,

From 81e7eb3092dd3daf6d2f6d34332111efbf7ad405 Mon Sep 17 00:00:00 2001
From: Mathias Wagner <germannewsmaker@gmail.com>
Date: Sun, 29 Jun 2025 11:15:41 +0200
Subject: [PATCH 2/2] style: format rust code using cargo fmt

---
 src/measurements.rs | 20 ++++++++++++++++----
 src/speedtest.rs    | 17 ++++++++++++-----
 2 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/measurements.rs b/src/measurements.rs
index 5db0ebb..08871b5 100644
--- a/src/measurements.rs
+++ b/src/measurements.rs
@@ -80,18 +80,30 @@ pub(crate) fn log_measurements(
         }
         OutputFormat::Json => {
             let mut output = serde_json::Map::new();
-            output.insert("speed_measurements".to_string(), serde_json::to_value(&stat_measurements).unwrap());
+            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());
+                output.insert(
+                    "latency_measurement".to_string(),
+                    serde_json::to_value(latency).unwrap(),
+                );
             }
             serde_json::to_writer(io::stdout(), &output).unwrap();
             println!();
         }
         OutputFormat::JsonPretty => {
             let mut output = serde_json::Map::new();
-            output.insert("speed_measurements".to_string(), serde_json::to_value(&stat_measurements).unwrap());
+            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());
+                output.insert(
+                    "latency_measurement".to_string(),
+                    serde_json::to_value(latency).unwrap(),
+                );
             }
             serde_json::to_writer_pretty(io::stdout(), &output).unwrap();
             println!();
diff --git a/src/speedtest.rs b/src/speedtest.rs
index d0205bf..cc0ba73 100644
--- a/src/speedtest.rs
+++ b/src/speedtest.rs
@@ -1,7 +1,7 @@
 use crate::measurements::format_bytes;
 use crate::measurements::log_measurements;
-use crate::measurements::Measurement;
 use crate::measurements::LatencyMeasurement;
+use crate::measurements::Measurement;
 use crate::progress::print_progress;
 use crate::OutputFormat;
 use crate::SpeedTestCLIOptions;
@@ -88,18 +88,25 @@ pub fn speed_test(client: Client, options: SpeedTestCLIOptions) -> Vec<Measureme
     if options.output_format == OutputFormat::StdOut {
         println!("{metadata}");
     }
-    let (latency_measurements, avg_latency) = 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),
+            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();