Enable CPU profiling in metrics service and extract client binary (#12)

- Add standalone client binary (src/bin/client.rs)
- Enable CPU profiling in main service
- Update Cargo.toml dependencies
- Export lib.rs for client binary
- Add profiling routes

Author: rcoh

Cargo.toml

@@ -12,3 +12,6 @@ version = "0.1.0"
 [workspace.dependencies]
 libc = "0.2"
 dial9-perf-self-profile = { version = "0.1.0", path = "perf-self-profile" }
+
+[profile.release]
+debug = 1

dial9-tokio-telemetry/examples/blocking_sleep.rs

@@ -0,0 +1,34 @@
+use dial9_tokio_telemetry::telemetry::{SimpleBinaryWriter, TracedRuntime};
+use std::time::Duration;
+
+async fn blocking_task(id: usize) {
+    for _ in 0..5 {
+        // This blocks the worker thread — should show up as a sched event
+        std::thread::sleep(Duration::from_millis(10));
+        tokio::task::yield_now().await;
+    }
+    println!("Task {} done", id);
+}
+
+fn main() {
+    let mut builder = tokio::runtime::Builder::new_multi_thread();
+    builder.worker_threads(2).enable_all();
+
+    let writer = Box::new(SimpleBinaryWriter::new("blocking_sleep_trace.bin").unwrap());
+    let (runtime, _guard) = TracedRuntime::builder()
+        .with_task_tracking(true)
+        .with_cpu_profiling(Default::default())
+        .with_inline_callframe_symbols(true)
+        .with_sched_events(Default::default())
+        .build_and_start(builder, writer)
+        .unwrap();
+
+    runtime.block_on(async {
+        let tasks: Vec<_> = (0..4).map(|i| tokio::spawn(blocking_task(i))).collect();
+        for t in tasks {
+            let _ = t.await;
+        }
+    });
+
+    println!("Trace written to blocking_sleep_trace.bin");
+}

dial9-tokio-telemetry/src/telemetry/recorder/event_writer.rs

@@ -112,14 +112,11 @@ impl EventWriter {
             profiler.drain(|event, thread_name| {
                 if let TelemetryEvent::CpuSample { tid, worker_id, .. } = &event
                     && *worker_id == UNKNOWN_WORKER
+                    && let Some(ref mut cpu) = self.cpu_flush
+                    && !cpu.thread_name_intern.contains_key(tid)
+                    && let Some(name) = thread_name
                 {
-                    if let Some(ref mut cpu) = self.cpu_flush {
-                        if !cpu.thread_name_intern.contains_key(&tid) {
-                            if let Some(name) = thread_name {
-                                cpu.thread_name_intern.insert(*tid, name.to_string());
-                            }
-                        }
-                    }
+                    cpu.thread_name_intern.insert(*tid, name.to_string());
                 }
                 self.write_cpu_event(&event);
             });

examples/metrics-service/Cargo.toml

@@ -5,7 +5,7 @@ version = "0.1.0"
 publish = false
 
 [dependencies]
-tokio = { version = "1", features = ["rt-multi-thread", "macros", "time", "sync"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "time", "sync", "process"] }
 tokio-util = { version = "0.7", features = ["rt"] }
 axum = "0.8"
 axum-core = "0.5"
@@ -19,6 +19,6 @@ aws-config = "1"
 aws-sdk-dynamodb = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-dial9-tokio-telemetry = { path = "../../dial9-tokio-telemetry" }
+dial9-tokio-telemetry = { path = "../../dial9-tokio-telemetry", features = ["cpu-profiling"] }
 reqwest = { version = "0.12", features = ["json"] }
 clap = { version = "4", features = ["derive"] }

examples/metrics-service/src/bin/client.rs

@@ -0,0 +1,51 @@
+use std::time::Duration;
+
+use clap::Parser;
+use reqwest::Client;
+use tokio_util::sync::CancellationToken;
+
+#[derive(Parser)]
+#[command(about = "Load-test client for the metrics service")]
+struct Args {
+    #[arg(long, help = "Base URL of the metrics server")]
+    server_url: String,
+
+    #[arg(
+        long,
+        default_value = "55",
+        help = "How long to run the load profile (seconds)"
+    )]
+    run_duration: u64,
+}
+
+#[tokio::main]
+async fn main() {
+    let args = Args::parse();
+
+    let shutdown = CancellationToken::new();
+
+    // Internal timer: cancel the load loop after run_duration seconds.
+    let timer_shutdown = shutdown.clone();
+    tokio::spawn(async move {
+        tokio::time::sleep(Duration::from_secs(args.run_duration)).await;
+        timer_shutdown.cancel();
+    });
+
+    println!(
+        "Client starting load profile against {}...",
+        args.server_url
+    );
+    metrics_service::client::run(&args.server_url, shutdown).await;
+
+    // Load profile finished – tell the server to shut down gracefully.
+    println!("Client load complete, sending /terminate to server...");
+    let http = Client::new();
+    match http
+        .post(format!("{}/terminate", args.server_url))
+        .send()
+        .await
+    {
+        Ok(_) => println!("Server acknowledged termination."),
+        Err(e) => eprintln!("Warning: could not reach /terminate: {e}"),
+    }
+}

examples/metrics-service/src/buffer.rs

@@ -29,6 +29,12 @@ pub struct MetricsBuffer {
     inner: Mutex<HashMap<String, Aggregate>>,
 }
 
+impl Default for MetricsBuffer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MetricsBuffer {
     pub fn new() -> Self {
         Self {