feat: curl-style request timing via --timing flag

Add --timing global flag that prints per-request phase breakdown to
stderr after each HTTP response (success or error):

  namelookup       DNS resolution time (custom tokio resolver)
  connect (TCP+TLS) full connection time (connector_layer timing)
  starttransfer    time to first byte (TTFB)
  transfer         body transfer time
  total            end-to-end

Uses reqwest 0.13's dns_resolver() and connector_layer() hooks to
instrument each phase without modifying the request path.

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

Author: byshing

Cargo.lock

@@ -39,6 +39,8 @@ reedline = "0.38"
 nu-ansi-term = "0.50"
 rmcp = { version = "1.1", default-features = false, features = ["server", "transport-io", "transport-streamable-http-server"] }
 axum = "0.8"
+tower = { version = "0.5", features = ["util"] }
+pin-project-lite = "0.2"
 
 [dev-dependencies]
 assert_cmd = "2"

Cargo.toml

@@ -89,6 +89,7 @@ pub(crate) async fn run(ctx: &AppContext) -> Result<()> {
                             mcp_mode: false,
                             profile: cli.profile.or_else(|| ctx.profile.clone()),
                             no_keychain: cli.no_keychain || ctx.no_keychain,
+                            timing: cli.timing || ctx.timing,
                         };
                         if let Some(command) = cli.command {
                             if let Err(e) = Box::pin(dispatch(&shell_ctx, command)).await {

src/cli/shell.rs

@@ -7,7 +7,8 @@
 /// Rate limiting is server-authoritative: the client surfaces `x-ratelimit-*`
 /// headers in error responses so agents can adapt their behaviour.
 use std::env;
-use std::time::Duration;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 use reqwest::header::{HeaderMap, HeaderValue};
 use serde_json::Value;
@@ -64,14 +65,28 @@ pub struct BitmexClient {
     pub(crate) base_url: String,
     pub(crate) testnet: bool,
     verbose: bool,
+    /// When Some, timing phases are collected and printed for every request.
+    timing: Option<super::timing::TimingHandle>,
 }
 
-fn build_http_client() -> Result<reqwest::Client> {
+fn build_http_client(
+    timing: Option<&super::timing::TimingHandle>,
+) -> Result<reqwest::Client> {
     let mut builder = reqwest::Client::builder()
         .use_rustls_tls()
         .timeout(Duration::from_secs(30))
         .user_agent(concat!("bitmex-cli/", env!("CARGO_PKG_VERSION")));
 
+    if let Some(handle) = timing {
+        builder = builder
+            .dns_resolver(Arc::new(
+                super::timing::TimingDnsResolver::new(handle.clone())
+            ))
+            .connector_layer(
+                super::timing::TimingConnectorLayer::new(handle.clone())
+            );
+    }
+
     if let Ok(val) = env::var("BITMEX_DANGER_ACCEPT_INVALID_CERTS") {
         if matches!(val.as_str(), "1" | "true" | "yes") {
             eprintln!(
@@ -89,45 +104,44 @@ fn build_http_client() -> Result<reqwest::Client> {
 
 impl BitmexClient {
     /// Create a new client targeting mainnet or testnet.
-    pub fn new(testnet: bool, verbose: bool) -> Result<Self> {
+    pub fn new(testnet: bool, verbose: bool, timing: bool) -> Result<Self> {
         let base_url = if testnet {
             TESTNET_URL.to_string()
         } else {
             MAINNET_URL.to_string()
         };
+        let timing_handle = timing.then(super::timing::new_handle);
         Ok(Self {
-            http: build_http_client()?,
+            http: build_http_client(timing_handle.as_ref())?,
             base_url,
             testnet,
             verbose,
+            timing: timing_handle,
         })
     }
 
     /// Create a new client with an explicit base URL override.
-    pub fn new_with_url(base_url: String, testnet: bool, verbose: bool) -> Result<Self> {
+    pub fn new_with_url(base_url: String, testnet: bool, verbose: bool, timing: bool) -> Result<Self> {
+        let timing_handle = timing.then(super::timing::new_handle);
         Ok(Self {
-            http: build_http_client()?,
+            http: build_http_client(timing_handle.as_ref())?,
             base_url,
             testnet,
             verbose,
+            timing: timing_handle,
         })
     }
 
     /// Public GET — no authentication headers.
     pub async fn get(&self, path: &str, query: &str) -> Result<Value> {
         let url = self.url(path, query);
-        if self.verbose {
-            crate::cli::output::verbose(&format!("GET {url}"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("GET {url}")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
-            self.http
-                .get(&url)
-                .send()
-                .await
+            self.http.get(&url).send().await
                 .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+        }).await?;
+        self.parse_response(resp, "GET", &url).await
     }
 
     /// Authenticated GET.
@@ -138,97 +152,73 @@ impl BitmexClient {
             format!("/api/v1{path}?{query}")
         };
         let url = self.url(path, query);
-        if self.verbose {
-            crate::cli::output::verbose(&format!("GET {url} (auth)"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("GET {url} (auth)")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
             let expires = auth::generate_expires()?;
             let sig = auth::sign("GET", &full_path, expires, "", &creds.api_secret)?;
             let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
-            self.http
-                .get(&url)
-                .headers(headers)
-                .send()
-                .await
+            self.http.get(&url).headers(headers).send().await
                 .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+        }).await?;
+        self.parse_response(resp, "GET", &url).await
     }
 
     /// Authenticated POST with JSON body.
     pub async fn post(&self, path: &str, body: &Value, creds: &Credentials) -> Result<Value> {
         let full_path = format!("/api/v1{path}");
         let body_str = serde_json::to_string(body)?;
         let url = self.url(path, "");
-        if self.verbose {
-            crate::cli::output::verbose(&format!("POST {url}"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("POST {url}")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
             let expires = auth::generate_expires()?;
             let sig = auth::sign("POST", &full_path, expires, &body_str, &creds.api_secret)?;
             let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
-            self.http
-                .post(&url)
-                .headers(headers)
+            self.http.post(&url).headers(headers)
                 .header("Content-Type", "application/json")
-                .body(body_str.clone())
-                .send()
-                .await
+                .body(body_str.clone()).send().await
                 .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+        }).await?;
+        self.parse_response(resp, "POST", &url).await
     }
 
     /// Authenticated PUT with JSON body.
     pub async fn put(&self, path: &str, body: &Value, creds: &Credentials) -> Result<Value> {
         let full_path = format!("/api/v1{path}");
         let body_str = serde_json::to_string(body)?;
         let url = self.url(path, "");
-        if self.verbose {
-            crate::cli::output::verbose(&format!("PUT {url}"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("PUT {url}")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
             let expires = auth::generate_expires()?;
             let sig = auth::sign("PUT", &full_path, expires, &body_str, &creds.api_secret)?;
             let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
-            self.http
-                .put(&url)
-                .headers(headers)
+            self.http.put(&url).headers(headers)
                 .header("Content-Type", "application/json")
-                .body(body_str.clone())
-                .send()
-                .await
+                .body(body_str.clone()).send().await
                 .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+        }).await?;
+        self.parse_response(resp, "PUT", &url).await
     }
 
     /// Authenticated PATCH with JSON body.
     pub async fn patch(&self, path: &str, body: &Value, creds: &Credentials) -> Result<Value> {
         let full_path = format!("/api/v1{path}");
         let body_str = serde_json::to_string(body)?;
         let url = self.url(path, "");
-        if self.verbose {
-            crate::cli::output::verbose(&format!("PATCH {url}"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("PATCH {url}")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
             let expires = auth::generate_expires()?;
             let sig = auth::sign("PATCH", &full_path, expires, &body_str, &creds.api_secret)?;
             let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
-            self.http
-                .patch(&url)
-                .headers(headers)
+            self.http.patch(&url).headers(headers)
                 .header("Content-Type", "application/json")
-                .body(body_str.clone())
-                .send()
-                .await
+                .body(body_str.clone()).send().await
                 .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+        }).await?;
+        self.parse_response(resp, "PATCH", &url).await
     }
 
     /// Authenticated DELETE, optional JSON body.
@@ -244,31 +234,21 @@ impl BitmexClient {
         } else {
             format!("/api/v1{path}?{query}")
         };
-        let body_str = body
-            .map(|b| serde_json::to_string(b))
-            .transpose()?
-            .unwrap_or_default();
+        let body_str = body.map(|b| serde_json::to_string(b)).transpose()?.unwrap_or_default();
         let url = self.url(path, query);
-        if self.verbose {
-            crate::cli::output::verbose(&format!("DELETE {url}"));
-        }
+        if self.verbose { crate::cli::output::verbose(&format!("DELETE {url}")); }
+        self.begin_request();
         let resp = super::middleware::execute_with_retry(self.verbose, || async {
             let expires = auth::generate_expires()?;
-            let sig =
-                auth::sign("DELETE", &full_path, expires, &body_str, &creds.api_secret)?;
+            let sig = auth::sign("DELETE", &full_path, expires, &body_str, &creds.api_secret)?;
             let headers = self.auth_headers(&creds.api_key, expires, &sig)?;
             let mut req = self.http.delete(&url).headers(headers);
             if !body_str.is_empty() {
-                req = req
-                    .header("Content-Type", "application/json")
-                    .body(body_str.clone());
+                req = req.header("Content-Type", "application/json").body(body_str.clone());
             }
-            req.send()
-                .await
-                .map_err(|e| BitmexError::Network { message: e.to_string() })
-        })
-        .await?;
-        self.parse_response(resp).await
+            req.send().await.map_err(|e| BitmexError::Network { message: e.to_string() })
+        }).await?;
+        self.parse_response(resp, "DELETE", &url).await
     }
 
     fn url(&self, path: &str, query: &str) -> String {
@@ -299,7 +279,28 @@ impl BitmexClient {
         Ok(headers)
     }
 
-    async fn parse_response(&self, resp: reqwest::Response) -> Result<Value> {
+    /// Reset timing state and record request_start. Call before each request.
+    fn begin_request(&self) {
+        if let Some(ref handle) = self.timing {
+            if let Ok(mut phases) = handle.lock() {
+                *phases = super::timing::Phases {
+                    request_start: Some(Instant::now()),
+                    ..Default::default()
+                };
+            }
+        }
+    }
+
+    /// Print timing summary to stderr. Call after body is fully read.
+    fn end_request(&self, method: &str, url: &str) {
+        if let Some(ref handle) = self.timing {
+            if let Ok(phases) = handle.lock() {
+                super::timing::print_timing(&phases, method, url);
+            }
+        }
+    }
+
+    async fn parse_response(&self, resp: reqwest::Response, method: &str, url: &str) -> Result<Value> {
         let status = resp.status();
         let remaining = resp
             .headers()
@@ -312,8 +313,24 @@ impl BitmexClient {
             .and_then(|v| v.to_str().ok())
             .and_then(|s| s.parse::<u64>().ok());
 
+        // Record TTFB — response headers have arrived.
+        if let Some(ref handle) = self.timing {
+            if let Ok(mut phases) = handle.lock() {
+                phases.ttfb = Some(Instant::now());
+            }
+        }
+
         let body = resp.text().await.map_err(BitmexError::from)?;
 
+        // Record transfer end — body fully received. Print timing now so it
+        // appears regardless of whether the response is a success or an error.
+        if let Some(ref handle) = self.timing {
+            if let Ok(mut phases) = handle.lock() {
+                phases.transfer_end = Some(Instant::now());
+            }
+        }
+        self.end_request(method, url);
+
         if self.verbose {
             crate::cli::output::verbose(&format!("Status: {status}"));
             if let Some(r) = remaining {
@@ -348,6 +365,7 @@ impl BitmexClient {
 
         let value: Value = serde_json::from_str(&body)
             .map_err(|e| BitmexError::Parse { message: format!("Failed to parse response JSON: {e}") })?;
+
         Ok(value)
     }
 

src/exchange/client.rs

@@ -1,4 +1,5 @@
 pub mod client;
 pub(crate) mod auth;
 pub(crate) mod middleware;
+pub(crate) mod timing;