Merge pull request #816 from hatoo/fix-dns-stat

Fix dns and connection time stats

Author: hatoo

src/client.rs

@@ -43,8 +43,8 @@ fn format_host_port(host: &str, port: u16) -> String {
 
 #[derive(Debug, Clone, Copy)]
 pub struct ConnectionTime {
-    pub dns_lookup: std::time::Instant,
-    pub dialup: std::time::Instant,
+    pub dns_lookup: std::time::Duration,
+    pub dialup: std::time::Duration,
 }
 
 #[derive(Debug, Clone)]
@@ -698,7 +698,10 @@ impl Client {
                     self.client_http1(&self.url, &mut client_state.rng).await?;
                 let dialup = std::time::Instant::now();
 
-                connection_time = Some(ConnectionTime { dns_lookup, dialup });
+                connection_time = Some(ConnectionTime {
+                    dns_lookup: dns_lookup - start,
+                    dialup: dialup - start,
+                });
                 send_request
             };
             while send_request.ready().await.is_err() {
@@ -709,7 +712,10 @@ impl Client {
                     self.client_http1(&self.url, &mut client_state.rng).await?;
                 send_request = send_request_;
                 let dialup = std::time::Instant::now();
-                connection_time = Some(ConnectionTime { dns_lookup, dialup });
+                connection_time = Some(ConnectionTime {
+                    dns_lookup: dns_lookup - start,
+                    dialup: dialup - start,
+                });
             }
             match send_request.send_request(request).await {
                 Ok(res) => {
@@ -787,6 +793,7 @@ impl Client {
         url: &Url,
         rng: &mut R,
     ) -> Result<(ConnectionTime, SendRequestHttp2), ClientError> {
+        let start = std::time::Instant::now();
         if let Some(proxy_url) = &self.proxy_url {
             let http_proxy_version = if self.is_proxy_http2() {
                 http::Version::HTTP_2
@@ -838,17 +845,35 @@ impl Client {
                 tokio::spawn(conn);
                 let dialup = std::time::Instant::now();
 
-                Ok((ConnectionTime { dns_lookup, dialup }, send_request))
+                Ok((
+                    ConnectionTime {
+                        dns_lookup: dns_lookup - start,
+                        dialup: dialup - start,
+                    },
+                    send_request,
+                ))
             } else {
                 let send_request = stream.handshake_http2().await?;
                 let dialup = std::time::Instant::now();
-                Ok((ConnectionTime { dns_lookup, dialup }, send_request))
+                Ok((
+                    ConnectionTime {
+                        dns_lookup: dns_lookup - start,
+                        dialup: dialup - start,
+                    },
+                    send_request,
+                ))
             }
         } else {
             let (dns_lookup, stream) = self.client(url, rng, self.http_version).await?;
             let send_request = stream.handshake_http2().await?;
             let dialup = std::time::Instant::now();
-            Ok((ConnectionTime { dns_lookup, dialup }, send_request))
+            Ok((
+                ConnectionTime {
+                    dns_lookup: dns_lookup - start,
+                    dialup: dialup - start,
+                },
+                send_request,
+            ))
         }
     }
 

src/client_h3.rs

@@ -68,10 +68,17 @@ impl Client {
         url: &Url,
         rng: &mut R,
     ) -> Result<(ConnectionTime, SendRequestHttp3), ClientError> {
+        let start = std::time::Instant::now();
         let (dns_lookup, stream) = self.client(url, rng, http::Version::HTTP_3).await?;
         let send_request = stream.handshake_http3().await?;
         let dialup = std::time::Instant::now();
-        Ok((ConnectionTime { dns_lookup, dialup }, send_request))
+        Ok((
+            ConnectionTime {
+                dns_lookup: dns_lookup - start,
+                dialup: dialup - start,
+            },
+            send_request,
+        ))
     }
 
     pub(crate) async fn quic_client(

src/printer.rs

@@ -392,10 +392,7 @@ fn print_csv<W: Write>(w: &mut W, start: Instant, res: &ResultData) -> std::io::
 
     for request in success_requests {
         let dns_and_dialup = match request.connection_time {
-            Some(connection_time) => (
-                connection_time.dns_lookup - request.start,
-                connection_time.dialup - request.start,
-            ),
+            Some(connection_time) => (connection_time.dns_lookup, connection_time.dialup),
             None => (std::time::Duration::ZERO, std::time::Duration::ZERO),
         };
         let first_byte = match request.first_byte {

src/result_data.rs

@@ -123,20 +123,14 @@ impl ResultData {
     pub fn dns_dialup_stat(&self) -> MinMaxMean {
         self.success
             .iter()
-            .filter_map(|r| {
-                r.connection_time
-                    .map(|ct| (ct.dialup - r.start).as_secs_f64())
-            })
+            .filter_map(|r| r.connection_time.map(|ct| ct.dialup.as_secs_f64()))
             .collect()
     }
 
     pub fn dns_lookup_stat(&self) -> MinMaxMean {
         self.success
             .iter()
-            .filter_map(|r| {
-                r.connection_time
-                    .map(|ct| (ct.dns_lookup - r.start).as_secs_f64())
-            })
+            .filter_map(|r| r.connection_time.map(|ct| ct.dns_lookup.as_secs_f64()))
             .collect()
     }
 
@@ -207,12 +201,8 @@ mod tests {
             start_latency_correction: None,
             start: now,
             connection_time: Some(ConnectionTime {
-                dns_lookup: now
-                    .checked_add(Duration::from_millis(connection_time_dns_lookup))
-                    .unwrap(),
-                dialup: now
-                    .checked_add(Duration::from_millis(connection_time_dialup))
-                    .unwrap(),
+                dns_lookup: Duration::from_millis(connection_time_dns_lookup),
+                dialup: Duration::from_millis(connection_time_dialup),
             }),
             first_byte: Some(now.checked_add(Duration::from_millis(first_byte)).unwrap()),
             end: now