feat: add tracing instrumentation for performance measurement (#178)

## Summary
- Add `#[tracing::instrument(level = "debug", skip_all)]` attributes to key performance-critical functions across `vite_task`, `vite_task_graph`, `vite_task_plan`, and `vite_workspace` crates
- Add `tracing` as a dependency to `vite_task_graph` and `vite_workspace` crates (other crates already had it)
- Fix a drop-order warning in `execute_synthetic` by binding match result to a variable

## Instrumented functions
- **Session**: `init`, `init_with`, `main`, `ensure_task_graph_loaded`, `execute_synthetic`, `plan_from_cli_run`, `execute_graph`
- **Execution**: `execute_expanded_graph`, `execute_leaf`, `execute_spawn`, `spawn_inherited`, `spawn_with_tracking`
- **Cache**: `load_from_path`, `try_hit`, `update`
- **Fingerprint**: `PostRunFingerprint::create`, `PostRunFingerprint::validate`
- **Task graph**: `IndexedTaskGraph::load`, `load_task_graph`
- **Planning**: `plan_query`, `plan_synthetic`
- **Workspace**: `load_package_graph`, `discover_package_graph`

## Test plan
- [x] `cargo check --all-targets` passes with no errors
- [ ] CI passes on all platforms


🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: branchseer

Cargo.lock

@@ -75,6 +75,7 @@ impl Display for FingerprintMismatch {
 }
 
 impl ExecutionCache {
+    #[tracing::instrument(level = "debug", skip_all)]
     pub fn load_from_path(path: &AbsolutePath) -> anyhow::Result<Self> {
         tracing::info!("Creating task cache directory at {:?}", path);
         std::fs::create_dir_all(path)?;
@@ -130,6 +131,7 @@ impl ExecutionCache {
 
     /// Try to hit cache with spawn fingerprint.
     /// Returns `Ok(Ok(cache_value))` on cache hit, `Ok(Err(cache_miss))` on miss.
+    #[tracing::instrument(level = "debug", skip_all)]
     pub async fn try_hit(
         &self,
         cache_metadata: &CacheMetadata,
@@ -175,6 +177,7 @@ impl ExecutionCache {
     }
 
     /// Update cache after successful execution.
+    #[tracing::instrument(level = "debug", skip_all)]
     pub async fn update(
         &self,
         cache_metadata: &CacheMetadata,

crates/vite_task/src/session/cache/mod.rs

@@ -73,6 +73,7 @@ impl PostRunFingerprint {
     /// * `path_reads` - Map of paths that were read during execution
     /// * `base_dir` - Workspace root for resolving relative paths
     /// * `fingerprint_ignores` - Optional glob patterns to exclude from fingerprinting
+    #[tracing::instrument(level = "debug", skip_all, name = "create_post_run_fingerprint")]
     pub fn create(
         path_reads: &HashMap<RelativePathBuf, PathRead>,
         base_dir: &AbsolutePath,
@@ -102,6 +103,7 @@ impl PostRunFingerprint {
 
     /// Validates the fingerprint against current filesystem state.
     /// Returns `Some(mismatch)` if validation fails, `None` if valid.
+    #[tracing::instrument(level = "debug", skip_all, name = "validate_post_run_fingerprint")]
     pub fn validate(
         &self,
         base_dir: &AbsolutePath,

crates/vite_task/src/session/execute/fingerprint.rs

@@ -72,6 +72,7 @@ impl ExecutionContext<'_> {
     ///
     /// Leaf-level errors are reported through the reporter and do not abort the graph.
     /// Cycle detection is handled at plan time, so this function cannot encounter cycles.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(clippy::future_not_send, reason = "uses !Send types internally")]
     async fn execute_expanded_graph(
         &mut self,
@@ -117,6 +118,7 @@ impl ExecutionContext<'_> {
     ///
     /// Creates a [`LeafExecutionReporter`] from the graph reporter and delegates
     /// to the appropriate execution method.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(clippy::future_not_send, reason = "uses !Send types internally")]
     async fn execute_leaf(
         &mut self,
@@ -174,6 +176,7 @@ impl ExecutionContext<'_> {
 ///
 /// Errors (cache lookup failure, spawn failure, cache update failure) are reported
 /// through `leaf_reporter.finish()` and do not abort the caller.
+#[tracing::instrument(level = "debug", skip_all)]
 #[expect(clippy::future_not_send, reason = "uses !Send types internally")]
 #[expect(
     clippy::too_many_lines,
@@ -371,6 +374,7 @@ pub async fn execute_spawn(
 ///
 /// The child process will see `is_terminal() == true` for stdout/stderr when the
 /// parent is running in a terminal. This is expected behavior.
+#[tracing::instrument(level = "debug", skip_all)]
 async fn spawn_inherited(spawn_command: &SpawnCommand) -> anyhow::Result<SpawnResult> {
     let mut cmd = fspy::Command::new(spawn_command.program_path.as_path());
     cmd.args(spawn_command.args.iter().map(vite_str::Str::as_str));
@@ -427,6 +431,7 @@ impl Session<'_> {
     ///
     /// Returns `Err(ExitStatus)` to indicate the caller should exit with the given status code.
     /// Returns `Ok(())` when all tasks succeeded.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(clippy::future_not_send, reason = "uses !Send types internally")]
     pub(crate) async fn execute_graph(
         &self,

crates/vite_task/src/session/execute/mod.rs

@@ -64,6 +64,7 @@ pub struct SpawnTrackResult {
 /// - stdin is always `/dev/null` (piped mode is for non-interactive execution).
 /// - `stdout_writer`/`stderr_writer` receive the child's stdout/stderr output in real-time.
 /// - `track_result` if provided, will be populated with captured outputs and path accesses for caching. If `None`, tracking is disabled.
+#[tracing::instrument(level = "debug", skip_all)]
 #[expect(clippy::future_not_send, reason = "uses !Send dyn AsyncWrite writers internally")]
 #[expect(
     clippy::too_many_lines,

crates/vite_task/src/session/execute/spawn.rs

@@ -42,6 +42,7 @@ impl TaskGraphLoader for LazyTaskGraph<'_> {
     async fn load_task_graph(
         &mut self,
     ) -> Result<&vite_task_graph::IndexedTaskGraph, TaskGraphLoadError> {
+        let _span = tracing::debug_span!("load_task_graph").entered();
         Ok(match self {
             Self::Uninitialized { workspace_root, config_loader } => {
                 let graph = IndexedTaskGraph::load(workspace_root, *config_loader).await?;
@@ -159,6 +160,7 @@ impl<'a> Session<'a> {
     ///
     /// Returns an error if the current directory cannot be determined or
     /// if workspace initialization fails.
+    #[tracing::instrument(level = "debug", skip_all)]
     pub fn init(callbacks: SessionCallbacks<'a>) -> anyhow::Result<Self> {
         let envs = std::env::vars_os()
             .map(|(k, v)| (Arc::<OsStr>::from(k.as_os_str()), Arc::<OsStr>::from(v.as_os_str())))
@@ -171,6 +173,7 @@ impl<'a> Session<'a> {
     /// # Errors
     ///
     /// Returns an error if the task graph cannot be loaded from the workspace configuration.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::future_not_send,
         reason = "session is single-threaded, futures do not need to be Send"
@@ -186,6 +189,7 @@ impl<'a> Session<'a> {
     /// # Errors
     ///
     /// Returns an error if workspace root cannot be found or PATH env cannot be prepended.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::needless_pass_by_value,
         reason = "cwd is an Arc that gets cloned internally, pass by value is intentional"
@@ -222,6 +226,7 @@ impl<'a> Session<'a> {
     /// # Errors
     ///
     /// Returns an error if planning or execution fails.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::future_not_send,
         reason = "session is single-threaded, futures do not need to be Send"
@@ -500,6 +505,7 @@ impl<'a> Session<'a> {
     /// # Errors
     ///
     /// Returns an error if planning or execution of the synthetic command fails.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::future_not_send,
         reason = "session is single-threaded, futures do not need to be Send"
@@ -531,14 +537,14 @@ impl<'a> Session<'a> {
             reporter::PlainReporter::new(silent_if_cache_hit, Box::new(tokio::io::stdout()));
 
         // Execute the spawn directly using the free function, bypassing the graph pipeline
-        match execute::execute_spawn(
+        let outcome = execute::execute_spawn(
             Box::new(plain_reporter),
             &spawn_execution,
             cache,
             &self.workspace_path,
         )
-        .await
-        {
+        .await;
+        match outcome {
             // Cache hit — no process was spawned, success
             execute::SpawnOutcome::CacheHit => Ok(ExitStatus::SUCCESS),
             // Process ran successfully
@@ -562,6 +568,7 @@ impl<'a> Session<'a> {
     /// # Errors
     ///
     /// Returns an error if the plan request cannot be parsed or if planning fails.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::future_not_send,
         reason = "session is single-threaded, futures do not need to be Send"
@@ -575,6 +582,7 @@ impl<'a> Session<'a> {
     }
 
     /// Internal: plans execution from a resolved run command.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::future_not_send,
         reason = "session is single-threaded, futures do not need to be Send"

crates/vite_task/src/session/mod.rs

@@ -15,6 +15,7 @@ rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+tracing = { workspace = true }
 vite_graph_ser = { workspace = true }
 vite_path = { workspace = true }
 vite_str = { workspace = true }

crates/vite_task_graph/Cargo.toml

@@ -180,6 +180,7 @@ impl IndexedTaskGraph {
     /// Returns [`TaskGraphLoadError`] if the package graph fails to load, a config file
     /// cannot be read, a task config cannot be resolved, a dependency specifier is invalid,
     /// or `cacheScripts` is set in a non-root package.
+    #[tracing::instrument(level = "debug", skip_all)]
     #[expect(
         clippy::too_many_lines,
         reason = "graph loading is inherently sequential and multi-step"

crates/vite_task_graph/src/lib.rs

@@ -187,6 +187,7 @@ pub trait TaskGraphLoader {
 ///
 /// # Errors
 /// Returns an error if task graph loading, query, or execution planning fails.
+#[tracing::instrument(level = "debug", skip_all)]
 #[expect(clippy::future_not_send, reason = "PlanRequestParser and TaskGraphLoader are !Send")]
 #[expect(clippy::implicit_hasher, reason = "FxHashMap is the only hasher used in this codebase")]
 pub async fn plan_query(
@@ -217,6 +218,7 @@ pub async fn plan_query(
 ///
 /// # Errors
 /// Returns an error if the program is not found or path fingerprinting fails.
+#[tracing::instrument(level = "debug", skip_all)]
 #[expect(clippy::result_large_err, reason = "Error is large for diagnostics")]
 pub fn plan_synthetic(
     workspace_path: &Arc<AbsolutePath>,

crates/vite_task_plan/src/lib.rs

@@ -17,6 +17,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["preserve_order"] }
 serde_yml = { workspace = true }
 thiserror = { workspace = true }
+tracing = { workspace = true }
 vec1 = { workspace = true, features = ["smallvec-v1"] }
 vite_glob = { workspace = true }
 vite_path = { workspace = true }