Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
Exclude diagnostic collector commands from profiles (#3900)
Maximilian Roosdee9d55f0d38
diff --git a/src/diagnostic.rs b/src/diagnostic.rsindex b815f2c96..e1687956c 100644--- a/src/diagnostic.rs+++ b/src/diagnostic.rs@@ -330,6 +330,15 @@ pub(crate) fn write_if_verbose(verbose: u8, command_line: &str, error_msg: Optioreturn;}+ // The collector runs after the command and writes to the same trace. Mark+ // all of its subprocesses at the source so aggregate profiles can exclude+ // them without recognizing individual commands or relying on their order.+ worktrunk::trace::emit::with_diagnostic_context(|| {+ write_diagnostic(command_line, error_msg);+ });+}++fn write_diagnostic(command_line: &str, error_msg: Option<&str>) {// Use Repository::current() which honors the -C flaglet Ok(repo) = Repository::current() else {return;diff --git a/src/shell_exec.rs b/src/shell_exec.rsindex 4a328bc16..b00b29435 100644--- a/src/shell_exec.rs+++ b/src/shell_exec.rs@@ -826,6 +826,7 @@ pub const SUBPROCESS_BOUNDED_TARGET: &str = "worktrunk::subprocess_bounded";/// that [`log_output`] prepends to each block in `subprocess.log`, so the two/// render the command identically.fn command_header(cmd: &str, context: Option<&str>) -> String {+ let context = crate::trace::emit::diagnostic_context().or(context);match context {Some(ctx) => format!("$ {cmd} [{ctx}]"),None => format!("$ {cmd}"),diff --git a/src/trace/emit.rs b/src/trace/emit.rsindex 6b1ee9a92..7beaf9d13 100644--- a/src/trace/emit.rs+++ b/src/trace/emit.rs@@ -79,6 +79,7 @@//! so it stays segmentable and joins back to this record via `seq`.use std::borrow::Cow;+use std::cell::Cell;use std::fmt::Display;use std::sync::OnceLock;use std::sync::atomic::{AtomicU64, Ordering};@@ -123,6 +124,41 @@ pub fn thread_id() -> u64 {/// regardless of whether the file layers are active. Starts at 1.static CMD_SEQ: AtomicU64 = AtomicU64::new(1);+/// Reserved context for subprocesses that build the `-vv` diagnostic report.+///+/// The raw trace retains these records, while aggregate profiles exclude them+/// so they describe the command being diagnosed rather than its collector.+pub const DIAGNOSTIC_CONTEXT: &str = "(diagnostic)";++thread_local! {+ static IN_DIAGNOSTIC_CONTEXT: Cell<bool> = const { Cell::new(false) };+}++struct DiagnosticContextGuard {+ previous: bool,+}++impl Drop for DiagnosticContextGuard {+ fn drop(&mut self) {+ IN_DIAGNOSTIC_CONTEXT.set(self.previous);+ }+}++/// Run `f` with subprocess trace records assigned to [`DIAGNOSTIC_CONTEXT`].+///+/// The override is thread-local so command work still completing on another+/// thread keeps its original context. Nested scopes restore the prior state.+pub fn with_diagnostic_context<T>(f: impl FnOnce() -> T) -> T {+ let previous = IN_DIAGNOSTIC_CONTEXT.replace(true);+ let _guard = DiagnosticContextGuard { previous };+ f()+}++/// Active trace-context override for the current thread, if any.+pub(crate) fn diagnostic_context() -> Option<&'static str> {+ IN_DIAGNOSTIC_CONTEXT.get().then_some(DIAGNOSTIC_CONTEXT)+}+/// Emit a completed-command record (`ok=true`/`ok=false`).////// Private and taking `&CommandTrace`: every per-command field but the@@ -244,7 +280,7 @@ impl CommandTrace {/// the captured start time brackets the subprocess.pub fn new(context: Option<&str>, cmd: &str) -> Self {Self {- context: context.map(ToOwned::to_owned),+ context: diagnostic_context().or(context).map(ToOwned::to_owned),cmd: cmd.to_owned(),start_ts_us: now_us(),start: Instant::now(),@@ -422,6 +458,23 @@ mod tests {CommandTrace::record_failed(None, "git nope", false, "precondition");}+ #[test]+ fn diagnostic_context_overrides_and_restores_command_context() {+ let assert_context = |expected: &str| {+ let mut trace = CommandTrace::new(Some("worktree"), "git status");+ assert_eq!(trace.context(), Some(expected));+ trace.complete(true);+ };++ assert_context("worktree");+ with_diagnostic_context(|| {+ assert_context(DIAGNOSTIC_CONTEXT);+ with_diagnostic_context(|| assert_context(DIAGNOSTIC_CONTEXT));+ assert_context(DIAGNOSTIC_CONTEXT);+ });+ assert_context("worktree");+ }+// A guard that reaches drop without complete()/fail() is a spawn site that// forgot to resolve its trace — the debug-build tripwire turns that into a// test failure rather than a silent unattributed gap.diff --git a/src/trace/profile.rs b/src/trace/profile.rsindex 209bd316b..24430bc99 100644--- a/src/trace/profile.rs+++ b/src/trace/profile.rs@@ -16,7 +16,9 @@//! - **Where is work wasted?** — [`CacheReport`] flags commands re-run with the//! same context (a cache miss that should have been a hit). Commands that read//! stdin are excluded — their real input isn't in the command string, so-//! identical command lines aren't necessarily identical work.+//! identical command lines aren't necessarily identical work. Subprocesses+//! that build the `-vv` diagnostic report are also excluded from every+//! aggregate; the raw trace retains them for debugging.//!//! The analysis ([`Profile::from_entries`], [`CacheReport::from_entries`]) is pure//! data over `&[TraceEntry]` and carries no styling, so it compiles without the@@ -34,6 +36,7 @@ use serde::Serialize;use crate::styling::format_heading;+use super::emit::DIAGNOSTIC_CONTEXT;use super::{TraceEntry, TraceEntryKind, TraceResult};/// How many individual calls [`Profile::slowest`] retains.@@ -79,12 +82,12 @@ fn ser_opt_dur_us<S: serde::Serializer>(d: &Option<Duration>, s: S) -> Result<S:/// same fields, so the two views can't drift.#[derive(Debug, Clone, PartialEq, Serialize)]pub struct Profile {- /// First → last record, across commands, spans, and instant events.+ /// First → last profiled record, across commands, spans, and instant events.#[serde(rename = "traced_us", serialize_with = "ser_dur_us")]pub traced: Duration,- /// Number of subprocess (command) records.+ /// Number of profiled subprocess (command) records.pub command_count: usize,- /// Σ of every subprocess duration.+ /// Σ of every profiled subprocess duration.#[serde(rename = "command_total_us", serialize_with = "ser_dur_us")]pub command_total: Duration,/// Σ of in-process span durations (config load, repo open, …).@@ -96,7 +99,7 @@ pub struct Profile {pub parallelism: Option<f64>,/// Most subprocesses in flight simultaneously. `None` without timestamps.pub peak_concurrency: Option<usize>,- /// Distinct thread IDs that ran subprocesses.+ /// Distinct thread IDs that ran profiled subprocesses.pub thread_count: usize,/// Derived `wt list` latencies from the collect milestones.pub key_intervals: KeyIntervals,@@ -302,6 +305,18 @@ pub(super) fn command_label(command: &str, context: Option<&str>, result: &Tracelabel}+/// Entries produced by the command being profiled.+///+/// The diagnostic collector runs after that command and appends to the same+/// trace under a reserved context. Every subprocess aggregate uses this+/// boundary — the timeline's `traced` span deliberately does not, since it+/// reconciles against a `wall` that includes the collector.+pub(super) fn profile_entries(entries: &[TraceEntry]) -> impl Iterator<Item = &TraceEntry> {+ entries+ .iter()+ .filter(|entry| entry.context.as_deref() != Some(DIAGNOSTIC_CONTEXT))+}+/// Microseconds of an entry's duration (zero for instant events).fn entry_dur_us(entry: &TraceEntry) -> u64 {match &entry.kind {@@ -315,9 +330,10 @@ fn entry_dur_us(entry: &TraceEntry) -> u64 {impl Profile {/// Build a profile from parsed trace entries.pub fn from_entries(entries: &[TraceEntry]) -> Self {- let min_start = entries.iter().filter_map(|e| e.start_time_us).min();- let max_end = entries- .iter()+ let min_start = profile_entries(entries)+ .filter_map(|e| e.start_time_us)+ .min();+ let max_end = profile_entries(entries).filter_map(|e| e.start_time_us.map(|s| s + entry_dur_us(e))).max();let traced = match (min_start, max_end) {@@ -335,7 +351,7 @@ impl Profile {let mut intervals: Vec<(u64, u64)> = Vec::new();let mut slowest: Vec<Slow> = Vec::new();- for entry in entries {+ for entry in profile_entries(entries) {match &entry.kind {TraceEntryKind::Command {command,@@ -409,8 +425,7 @@ impl Profile {let (parallelism, peak_concurrency) = concurrency(&intervals);let base = min_start.unwrap_or(0);- let mut milestones: Vec<(&str, u64)> = entries- .iter()+ let mut milestones: Vec<(&str, u64)> = profile_entries(entries).filter_map(|e| match &e.kind {TraceEntryKind::Instant { name } => e.start_time_us.map(|s| (name.as_str(), s)),_ => None,@@ -676,7 +691,7 @@ impl CacheReport {// (command, context) → durations of every run, in microseconds.let mut pair_durations: HashMap<(&str, &str), Vec<u64>> = HashMap::new();- for entry in entries {+ for entry in profile_entries(entries) {if let TraceEntryKind::Command {command,duration,diff --git a/src/trace/timeline.rs b/src/trace/timeline.rsindex f030652bf..21f936747 100644--- a/src/trace/timeline.rs+++ b/src/trace/timeline.rs@@ -15,7 +15,7 @@use std::time::Duration;use super::parse::{TraceEntry, TraceEntryKind};-use super::profile::{Align, command_label, fmt_dur, render_table};+use super::profile::{Align, command_label, fmt_dur, profile_entries, render_table};/// Duration of an entry (zero for instant events).fn duration_of(e: &TraceEntry) -> Duration {@@ -74,8 +74,7 @@ pub fn render_timeline(entries: &[TraceEntry], wall: Duration) -> String {);// Summary: subprocess totals + traced span + true process wall.- let cmds: Vec<(Duration, String)> = sorted- .iter()+ let cmds: Vec<(Duration, String)> = profile_entries(entries).filter_map(|e| match &e.kind {TraceEntryKind::Command {command,@@ -134,7 +133,7 @@ pub fn render_timeline(entries: &[TraceEntry], wall: Duration) -> String {#[cfg(test)]mod tests {use super::*;- use crate::trace::TraceResult;+ use crate::trace::{TraceResult, emit::DIAGNOSTIC_CONTEXT};fn span(name: &str, ts_us: u64, dur_us: u64, tid: u64) -> TraceEntry {TraceEntry {@@ -227,4 +226,32 @@ mod tests {");}++ #[test]+ fn diagnostic_commands_render_without_changing_the_summary() {+ let entries = vec![+ cmd("git status", Some("repo"), 0, 1_000, 1, true),+ cmd(+ "gh --version",+ Some(DIAGNOSTIC_CONTEXT),+ 1_000,+ 5_000,+ 1,+ true,+ ),+ ];++ insta::assert_snapshot!(+ render_timeline(&entries, Duration::from_millis(7)),+ @"+ ts(ms) dur tid kind name+ 0.000 1.00ms 1 cmd git status [repo]+ 1.000 5.00ms 1 cmd gh --version [(diagnostic)]++ 1 subprocess totaling 1.00ms (slowest: 1.00ms git status [repo])+ traced: 6.00ms (first → last record)+ wall: 7.00ms (spawn → wait; +1.00ms untraced prelude/epilogue)+ "+ );+ }}diff --git a/tests/integration_tests/diagnostic.rs b/tests/integration_tests/diagnostic.rsindex 65c3641ad..601b6364c 100644--- a/tests/integration_tests/diagnostic.rs+++ b/tests/integration_tests/diagnostic.rs@@ -429,6 +429,52 @@ fn test_diagnostic_leads_with_profile(repo: TestRepo) {);}+/// The subprocesses that assemble a `-vv` report stay visible in the raw trace+/// but do not change any aggregate in the profile read back from that trace.+#[rstest]+fn test_profile_excludes_diagnostic_collector(repo: TestRepo) {+ let output = repo.wt_command().args(["list", "-vv"]).output().unwrap();+ assert!(+ output.status.success(),+ "wt list -vv should succeed: {}",+ String::from_utf8_lossy(&output.stderr)+ );++ let logs_dir = repo.root_path().join(".git/wt/logs");+ let trace_jsonl = fs::read_to_string(logs_dir.join("trace.jsonl")).unwrap();+ let entries = worktrunk::trace::parse_lines(&trace_jsonl);+ let diagnostic_context = worktrunk::trace::emit::DIAGNOSTIC_CONTEXT;+ let profiled_entries: Vec<_> = entries+ .iter()+ .filter(|entry| entry.context.as_deref() != Some(diagnostic_context))+ .cloned()+ .collect();++ assert!(+ entries.iter().any(|entry| {+ entry.context.as_deref() == Some(diagnostic_context)+ && matches!(+ &entry.kind,+ worktrunk::trace::TraceEntryKind::Command { command, .. }+ if command == "git worktree list --porcelain"+ )+ }),+ "the diagnostic collector should mark its worktree-list record:\n{trace_jsonl}"+ );+ assert_eq!(+ worktrunk::trace::Profile::from_entries(&entries),+ worktrunk::trace::Profile::from_entries(&profiled_entries)+ );++ let trace_log = fs::read_to_string(logs_dir.join("trace.log")).unwrap();+ assert!(+ trace_log+ .lines()+ .any(|line| line.contains("$ git worktree list --porcelain [(diagnostic)]")),+ "the collector's command start and completion should share a context:\n{trace_log}"+ );+}+/// At `-vv`, the full (uncapped) subprocess stdout/stderr should land in/// `subprocess.log` via `shell_exec::SUBPROCESS_FULL_TARGET` — not in `trace.log`./// `trace.log` gets the bounded preview alongside trace records.