feat: add server processing time and request ID to timing output

Print x-envoy-upstream-service-time (server processing) and
x-request-id from response headers when --timing flag is set.
Also sort IPv4 before IPv6 in DNS resolver to avoid IPv6 fallback
timeout inflating connect (TCP+TLS) time.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: byshing

src/exchange/client.rs

@@ -292,10 +292,16 @@ impl BitmexClient {
     }
 
     /// Print timing summary to stderr. Call after body is fully read.
-    fn end_request(&self, method: &str, url: &str) {
+    fn end_request(
+        &self,
+        method: &str,
+        url: &str,
+        server_ms: Option<&str>,
+        request_id: Option<&str>,
+    ) {
         if let Some(ref handle) = self.timing {
             if let Ok(phases) = handle.lock() {
-                super::timing::print_timing(&phases, method, url);
+                super::timing::print_timing(&phases, method, url, server_ms, request_id);
             }
         }
     }
@@ -312,6 +318,16 @@ impl BitmexClient {
             .get("x-ratelimit-reset")
             .and_then(|v| v.to_str().ok())
             .and_then(|s| s.parse::<u64>().ok());
+        let server_ms = resp
+            .headers()
+            .get("x-envoy-upstream-service-time")
+            .and_then(|v| v.to_str().ok())
+            .map(str::to_owned);
+        let request_id = resp
+            .headers()
+            .get("x-request-id")
+            .and_then(|v| v.to_str().ok())
+            .map(str::to_owned);
 
         // Record TTFB — response headers have arrived.
         if let Some(ref handle) = self.timing {
@@ -329,7 +345,7 @@ impl BitmexClient {
                 phases.transfer_end = Some(Instant::now());
             }
         }
-        self.end_request(method, url);
+        self.end_request(method, url, server_ms.as_deref(), request_id.as_deref());
 
         if self.verbose {
             crate::cli::output::verbose(&format!("Status: {status}"));

src/exchange/timing.rs

@@ -71,25 +71,40 @@ pub(crate) fn new_handle() -> TimingHandle {
 // Output
 // ---------------------------------------------------------------------------
 
-pub(crate) fn print_timing(phases: &Phases, method: &str, url: &str) {
+pub(crate) fn print_timing(
+    phases: &Phases,
+    method: &str,
+    url: &str,
+    server_ms: Option<&str>,
+    request_id: Option<&str>,
+) {
     let ms = |d: Option<Duration>| -> String {
         d.map(|d| format!("{:.0}ms", d.as_secs_f64() * 1000.0))
             .unwrap_or_else(|| "-".to_string())
     };
 
-    eprintln!(
+    let mut output = format!(
         "\n── Timing: {method} {url}\n\
-         {:>16}  {}\n\
-         {:>16}  {}\n\
-         {:>16}  {}\n\
-         {:>16}  {}\n\
-         {:>16}  {}",
+         {:>22}  {}\n\
+         {:>22}  {}\n\
+         {:>22}  {}\n\
+         {:>22}  {}\n\
+         {:>22}  {}",
         "namelookup:", ms(phases.namelookup()),
         "connect (TCP+TLS):", ms(phases.appconnect()),
         "starttransfer:", ms(phases.starttransfer()),
         "transfer:", ms(phases.transfer()),
         "total:", ms(phases.total()),
     );
+
+    if let Some(s) = server_ms {
+        output.push_str(&format!("\n{:>22}  {}ms", "server processing:", s));
+    }
+    if let Some(id) = request_id {
+        output.push_str(&format!("\n{:>22}  {}", "x-request-id:", id));
+    }
+
+    eprintln!("{output}");
 }
 
 // ---------------------------------------------------------------------------
@@ -116,10 +131,20 @@ impl Resolve for TimingDnsResolver {
                 phases.dns_start = Some(Instant::now());
             }
 
+            let lookup = tokio::net::lookup_host(format!("{}:0", host)).await;
+
             let addrs: Result<Vec<SocketAddr>, Box<dyn std::error::Error + Send + Sync>> =
-                tokio::net::lookup_host(format!("{}:0", host))
-                    .await
-                    .map(|iter| iter.collect())
+                lookup
+                    .map(|iter| {
+                        // Sort IPv4 before IPv6 so hyper connects without waiting
+                        // for an IPv6 timeout when IPv6 is unreachable. This matches
+                        // what reqwest's default resolver does on most platforms.
+                        let all: Vec<SocketAddr> = iter.collect();
+                        let mut v4: Vec<SocketAddr> = all.iter().filter(|a| a.is_ipv4()).cloned().collect();
+                        let v6: Vec<SocketAddr> = all.iter().filter(|a| a.is_ipv6()).cloned().collect();
+                        v4.extend(v6);
+                        v4
+                    })
                     .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>);
 
             if let Ok(mut phases) = handle.lock() {