feat: Support send_delay and include_first_message in standalone client

- Add --send-delay support: inserts a configurable pause after each
  message send (blocking uses thread::sleep, async uses tokio::sleep)
- Add --include-first-message support: when false (default), sends a
  canary message before measurement to warm up the connection, matching
  the existing BenchmarkRunner behavior
- Applied to both one-way and round-trip tests in both blocking and
  async client paths

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

Author: sberg-rh

src/main.rs

@@ -1435,6 +1435,12 @@ fn run_standalone_client_blocking(
     if config.one_way {
         let mut metrics = MetricsCollector::new(None, config.percentiles.clone())?;
 
+        // Send canary to warm up the connection if first message excluded
+        if !config.include_first_message {
+            let canary = Message::new(u64::MAX, payload.clone(), MessageType::OneWay);
+            let _ = transport.send_blocking(&canary);
+        }
+
         let start = std::time::Instant::now();
         let count = if let Some(test_duration) = config.duration {
             info!(
@@ -1446,6 +1452,9 @@ fn run_standalone_client_blocking(
                 let msg = Message::new(c, payload.clone(), MessageType::OneWay);
                 transport.send_blocking(&msg)?;
                 metrics.record_message(config.message_size, None)?;
+                if let Some(delay) = config.send_delay {
+                    std::thread::sleep(delay);
+                }
                 c += 1;
             }
             c
@@ -1458,6 +1467,9 @@ fn run_standalone_client_blocking(
                 let msg = Message::new(i as u64, payload.clone(), MessageType::OneWay);
                 transport.send_blocking(&msg)?;
                 metrics.record_message(config.message_size, None)?;
+                if let Some(delay) = config.send_delay {
+                    std::thread::sleep(delay);
+                }
             }
             msg_count as u64
         };
@@ -1478,6 +1490,14 @@ fn run_standalone_client_blocking(
         let mut metrics =
             MetricsCollector::new(Some(LatencyType::RoundTrip), config.percentiles.clone())?;
 
+        // Send canary to warm up the connection if first message excluded
+        if !config.include_first_message {
+            let canary = Message::new(u64::MAX, payload.clone(), MessageType::Request);
+            if transport.send_blocking(&canary).is_ok() {
+                let _ = transport.receive_blocking();
+            }
+        }
+
         if let Some(test_duration) = config.duration {
             info!(
                 "Running round-trip latency test (duration={:.2?})...",
@@ -1502,6 +1522,9 @@ fn run_standalone_client_blocking(
                 );
                 let _ = results_manager.stream_latency_record(&record);
 
+                if let Some(delay) = config.send_delay {
+                    std::thread::sleep(delay);
+                }
                 i += 1;
             }
         } else {
@@ -1525,6 +1548,10 @@ fn run_standalone_client_blocking(
                     latency,
                 );
                 let _ = results_manager.stream_latency_record(&record);
+
+                if let Some(delay) = config.send_delay {
+                    std::thread::sleep(delay);
+                }
             }
         }
 
@@ -1620,6 +1647,12 @@ async fn run_standalone_client_async(
     if config.one_way {
         let mut metrics = MetricsCollector::new(None, config.percentiles.clone())?;
 
+        // Send canary to warm up the connection if first message excluded
+        if !config.include_first_message {
+            let canary = Message::new(u64::MAX, payload.clone(), MessageType::OneWay);
+            let _ = transport.send(&canary).await;
+        }
+
         let start = std::time::Instant::now();
         let count = if let Some(test_duration) = config.duration {
             info!(
@@ -1631,6 +1664,9 @@ async fn run_standalone_client_async(
                 let msg = Message::new(c, payload.clone(), MessageType::OneWay);
                 transport.send(&msg).await?;
                 metrics.record_message(config.message_size, None)?;
+                if let Some(delay) = config.send_delay {
+                    tokio::time::sleep(delay).await;
+                }
                 c += 1;
             }
             c
@@ -1643,6 +1679,9 @@ async fn run_standalone_client_async(
                 let msg = Message::new(i as u64, payload.clone(), MessageType::OneWay);
                 transport.send(&msg).await?;
                 metrics.record_message(config.message_size, None)?;
+                if let Some(delay) = config.send_delay {
+                    tokio::time::sleep(delay).await;
+                }
             }
             msg_count as u64
         };
@@ -1663,6 +1702,14 @@ async fn run_standalone_client_async(
         let mut metrics =
             MetricsCollector::new(Some(LatencyType::RoundTrip), config.percentiles.clone())?;
 
+        // Send canary to warm up the connection if first message excluded
+        if !config.include_first_message {
+            let canary = Message::new(u64::MAX, payload.clone(), MessageType::Request);
+            if transport.send(&canary).await.is_ok() {
+                let _ = transport.receive().await;
+            }
+        }
+
         if let Some(test_duration) = config.duration {
             info!(
                 "Running round-trip latency test (duration={:.2?})...",
@@ -1687,6 +1734,9 @@ async fn run_standalone_client_async(
                 );
                 let _ = results_manager.stream_latency_record(&record);
 
+                if let Some(delay) = config.send_delay {
+                    tokio::time::sleep(delay).await;
+                }
                 i += 1;
             }
         } else {
@@ -1710,6 +1760,10 @@ async fn run_standalone_client_async(
                     latency,
                 );
                 let _ = results_manager.stream_latency_record(&record);
+
+                if let Some(delay) = config.send_delay {
+                    tokio::time::sleep(delay).await;
+                }
             }
         }