Merge branch 'pr/cpu-sched-profiling' of github.com:dial9-rs/dial9-tokio-telemetry into pr/metrics-service-updates

Author: rcoh

dial9-tokio-telemetry/src/telemetry/cpu_profile.rs

@@ -44,18 +44,12 @@ impl Default for CpuProfilingConfig {
 /// Uses `perf_event_open` with `SwContextSwitches` in per-thread mode,
 /// so each worker thread gets its own perf fd via `on_thread_start`.
 #[derive(Debug, Clone)]
+#[derive(Default)]
 pub struct SchedEventConfig {
     /// Whether to include kernel stack frames.
     pub include_kernel: bool,
 }
 
-impl Default for SchedEventConfig {
-    fn default() -> Self {
-        Self {
-            include_kernel: false,
-        }
-    }
-}
 
 /// Manages the perf sampler and converts samples to telemetry events.
 pub(crate) struct CpuProfiler {
@@ -109,11 +103,10 @@ impl CpuProfiler {
                 .unwrap_or(UNKNOWN_WORKER);
             // Eagerly cache thread name for non-worker tids while the thread
             // is still alive and /proc/self/task/<tid>/comm is readable.
-            if worker_id == UNKNOWN_WORKER && !self.tid_to_name.contains_key(&sample.tid) {
-                if let Some(name) = read_thread_name(sample.tid) {
+            if worker_id == UNKNOWN_WORKER && !self.tid_to_name.contains_key(&sample.tid)
+                && let Some(name) = read_thread_name(sample.tid) {
                     self.tid_to_name.insert(sample.tid, name);
                 }
-            }
             events.push(TelemetryEvent::CpuSample {
                 timestamp_nanos,
                 worker_id,

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

@@ -467,15 +467,12 @@ impl TelemetryRecorder {
                 cpu_events = profiler.drain();
                 // Pull eagerly-cached thread names into our intern table
                 for event in &cpu_events {
-                    if let TelemetryEvent::CpuSample { tid, worker_id, .. } = event {
-                        if *worker_id == UNKNOWN_WORKER
+                    if let TelemetryEvent::CpuSample { tid, worker_id, .. } = event
+                        && *worker_id == UNKNOWN_WORKER
                             && !self.thread_name_intern.contains_key(tid)
-                        {
-                            if let Some(name) = profiler.thread_name(*tid) {
+                            && let Some(name) = profiler.thread_name(*tid) {
                                 self.thread_name_intern.insert(*tid, name.to_string());
                             }
-                        }
-                    }
                 }
             }
             {
@@ -486,8 +483,8 @@ impl TelemetryRecorder {
             }
             for event in &cpu_events {
                 // Emit ThreadNameDef for non-worker tids before their first sample in this file
-                if let TelemetryEvent::CpuSample { worker_id, tid, .. } = event {
-                    if *worker_id == UNKNOWN_WORKER
+                if let TelemetryEvent::CpuSample { worker_id, tid, .. } = event
+                    && *worker_id == UNKNOWN_WORKER
                         && !self.thread_name_emitted_this_file.contains(tid)
                     {
                         if self.writer.take_rotated() {
@@ -504,9 +501,8 @@ impl TelemetryRecorder {
                         }
                         self.thread_name_emitted_this_file.insert(*tid);
                     }
-                }
-                if self.inline_callframe_symbols {
-                    if let TelemetryEvent::CpuSample { callchain, .. } = event {
+                if self.inline_callframe_symbols
+                    && let TelemetryEvent::CpuSample { callchain, .. } = event {
                         // Check for rotation before writing defs
                         if self.writer.take_rotated() {
                             self.flush_state.on_rotate();
@@ -516,15 +512,15 @@ impl TelemetryRecorder {
                         for &addr in callchain {
                             if !self.callframe_emitted_this_file.contains(&addr) {
                                 // Symbolicate if not yet interned
-                                if !self.callframe_intern.contains_key(&addr) {
+                                self.callframe_intern.entry(addr).or_insert_with(|| {
                                     let sym = perf_self_profile::resolve_symbol(addr);
                                     let symbol = sym.name.unwrap_or_else(|| format!("{:#x}", addr));
                                     let location = sym.code_info.map(|info| match info.line {
                                         Some(line) => format!("{}:{}", info.file, line),
                                         None => info.file,
                                     });
-                                    self.callframe_intern.insert(addr, (symbol, location));
-                                }
+                                    (symbol, location)
+                                });
                                 let (symbol, location) = self.callframe_intern[&addr].clone();
                                 let def = TelemetryEvent::CallframeDef {
                                     address: addr,
@@ -536,7 +532,6 @@ impl TelemetryRecorder {
                             }
                         }
                     }
-                }
                 let _ = self.writer.write_event(event);
             }
         }
@@ -641,18 +636,16 @@ impl TelemetryRecorder {
             let s_stop = shared.clone();
             builder
                 .on_thread_start(move || {
-                    if let Ok(mut prof) = s_start.sched_profiler.lock() {
-                        if let Some(ref mut p) = *prof {
+                    if let Ok(mut prof) = s_start.sched_profiler.lock()
+                        && let Some(ref mut p) = *prof {
                             let _ = p.track_current_thread();
                         }
-                    }
                 })
                 .on_thread_stop(move || {
-                    if let Ok(mut prof) = s_stop.sched_profiler.lock() {
-                        if let Some(ref mut p) = *prof {
+                    if let Ok(mut prof) = s_stop.sched_profiler.lock()
+                        && let Some(ref mut p) = *prof {
                             p.stop_tracking_current_thread();
                         }
-                    }
                 });
         }
 
@@ -862,25 +855,17 @@ impl TracedRuntimeBuilder {
 
         // Start CPU profiler if configured
         #[cfg(feature = "cpu-profiling")]
-        let sampler = if let Some(config) = self.cpu_profiling_config {
-            Some(crate::telemetry::cpu_profile::CpuProfiler::start(
+        let sampler = self.cpu_profiling_config.map(|config| crate::telemetry::cpu_profile::CpuProfiler::start(
                 config,
                 start_mono_ns,
-            ))
-        } else {
-            None
-        };
+            ));
 
         // Start sched event profiler if configured
         #[cfg(feature = "cpu-profiling")]
-        let sched = if let Some(config) = self.sched_event_config {
-            Some(crate::telemetry::cpu_profile::SchedProfiler::new(
+        let sched = self.sched_event_config.map(|config| crate::telemetry::cpu_profile::SchedProfiler::new(
                 config,
                 start_mono_ns,
-            ))
-        } else {
-            None
-        };
+            ));
 
         let recorder = TelemetryRecorder::install(
             &mut builder,