perf: Enable chrome tracing at shim startup for complete profiles

The profile was still missing ~500ms because chrome tracing was only
enabled inside the Command::Run match arm, after clap parsing, config
resolution, and repo inference had already completed.

This extracts --profile/--anon-profile from the shim's argument parser
and enables chrome tracing immediately after TurboSubscriber creation,
before any repo inference or CLI parsing occurs. Also instruments
Args::new, get_command, initialize_telemetry_client, and
run_with_args for full startup visibility.

Author: anthonyshew

crates/turborepo-lib/src/cli/mod.rs

@@ -300,6 +300,7 @@ fn format_error_message(mut err_str: String) -> String {
 }
 
 impl Args {
+    #[tracing::instrument(skip_all)]
     pub fn new(os_args: Vec<OsString>) -> Self {
         let clap_args = match Args::parse(os_args) {
             Ok(args) => args,
@@ -1137,6 +1138,7 @@ impl RunArgs {
     }
 }
 
+#[tracing::instrument(skip_all)]
 fn initialize_telemetry_client(
     color_config: ColorConfig,
     version: &str,
@@ -1262,6 +1264,7 @@ fn default_to_run_command(cli_args: &Args) -> Result<Command, Error> {
     })
 }
 
+#[tracing::instrument(skip_all)]
 fn get_command(cli_args: &mut Args) -> Result<Command, Error> {
     if let Some(command) = mem::take(&mut cli_args.command) {
         Ok(command)
@@ -1587,13 +1590,6 @@ pub async fn run(
             let event = CommandEventBuilder::new("run").with_parent(&root_telemetry);
             event.track_call();
 
-            // Enable chrome tracing before any real work so that config
-            // resolution and CommandBase construction are captured.
-            let profile_file = run_args.profile_file_and_include_args();
-            if let Some((ref file_path, include_args)) = profile_file {
-                let _ = logger.enable_chrome_tracing(file_path, include_args);
-            }
-
             let base = CommandBase::new(cli_args.clone(), repo_root, version, color_config)?;
             event.track_ui_mode(base.opts.run_opts.ui_mode);
 
@@ -1609,14 +1605,14 @@ pub async fn run(
                 }
             })?;
 
-            if let Some((ref file_path, _)) = profile_file {
-                // Flush the chrome trace so the file is fully written
-                // before we read it for markdown generation.
+            // Chrome tracing is enabled early in shim::run(). Here we just
+            // flush and generate the markdown summary.
+            if let Some(file_path) = logger.chrome_tracing_file() {
                 let _ = logger.flush_chrome_tracing();
 
                 let md_path = format!("{file_path}.md");
                 if let Err(e) = turborepo_profile_md::trace_to_markdown(
-                    std::path::Path::new(file_path),
+                    std::path::Path::new(&file_path),
                     std::path::Path::new(&md_path),
                 ) {
                     warn!("Failed to generate profile markdown: {e}");

crates/turborepo-lib/src/shim.rs

@@ -144,6 +144,12 @@ pub fn run() -> Result<i32, Error> {
     let color_config = args.color_config();
     let subscriber = TurboSubscriber::new_with_verbosity(args.verbosity, &color_config);
 
+    // Enable chrome tracing as early as possible so that repo inference,
+    // config resolution, and CLI parsing are all captured in profiles.
+    if let Some((ref file_path, include_args)) = args.profile_file_and_include_args() {
+        let _ = subscriber.enable_chrome_tracing(file_path, include_args);
+    }
+
     // Create the runtime with all implementations
     let runtime = ShimRuntime::new(
         TurboCliRunner::new(&subscriber),

crates/turborepo-lib/src/tracing.rs

@@ -80,6 +80,9 @@ pub struct TurboSubscriber {
     chrome_update: Handle<Option<ChromeLog>, DaemonLogLayered>,
     chrome_guard: Mutex<Option<tracing_chrome::FlushGuard>>,
 
+    /// The resolved file path for chrome tracing output, if enabled.
+    chrome_tracing_file: Mutex<Option<String>>,
+
     #[cfg(feature = "pprof")]
     pprof_guard: pprof::ProfilerGuard<'static>,
 }
@@ -158,6 +161,7 @@ impl TurboSubscriber {
             daemon_guard: Mutex::new(None),
             chrome_update,
             chrome_guard: Mutex::new(None),
+            chrome_tracing_file: Mutex::new(None),
             #[cfg(feature = "pprof")]
             pprof_guard,
         }
@@ -191,6 +195,8 @@ impl TurboSubscriber {
         to_file: P,
         include_args: bool,
     ) -> Result<(), Error> {
+        let file_path = to_file.as_ref().to_string_lossy().to_string();
+
         let (layer, guard) = tracing_chrome::ChromeLayerBuilder::new()
             .file(to_file)
             .include_args(include_args)
@@ -203,10 +209,23 @@ impl TurboSubscriber {
             .lock()
             .expect("not poisoned")
             .replace(guard);
+        self.chrome_tracing_file
+            .lock()
+            .expect("not poisoned")
+            .replace(file_path);
 
         Ok(())
     }
 
+    /// Returns the chrome tracing output file path, if chrome tracing is
+    /// enabled.
+    pub fn chrome_tracing_file(&self) -> Option<String> {
+        self.chrome_tracing_file
+            .lock()
+            .expect("not poisoned")
+            .clone()
+    }
+
     /// Flushes and closes the chrome tracing layer so the trace file is
     /// fully written. This must be called before reading the trace file
     /// for post-processing (e.g., markdown generation).

crates/turborepo-shim/src/parser.rs

@@ -81,6 +81,11 @@ pub struct ShimArgs {
     pub color: bool,
     pub no_color: bool,
     pub root_turbo_json: Option<AbsoluteSystemPathBuf>,
+    /// Raw value from `--profile` (Some("") means flag present with no value).
+    pub profile: Option<String>,
+    /// Raw value from `--anon-profile` (Some("") means flag present with no
+    /// value).
+    pub anon_profile: Option<String>,
 }
 
 impl ShimArgs {
@@ -106,6 +111,10 @@ impl ShimArgs {
         let mut no_color = false;
         let mut root_turbo_json_flag_idx = None;
         let mut root_turbo_json = None;
+        let mut profile: Option<String> = None;
+        let mut anon_profile: Option<String> = None;
+        let mut found_profile_flag = false;
+        let mut found_anon_profile_flag = false;
 
         let args = args.skip(1);
         for (idx, arg) in args.enumerate() {
@@ -170,6 +179,40 @@ impl ShimArgs {
                 // `--root-turbo-json=./path/to/turbo.json`, that entire chunk
                 // is a single arg, so we need to split it up.
                 root_turbo_json = Some(AbsoluteSystemPathBuf::from_unknown(&invocation_dir, path));
+            } else if found_profile_flag {
+                // Previous arg was `--profile`, this arg is the optional value.
+                // If it looks like a flag, it's not our value — treat `--profile`
+                // as having no value and re-process this arg next iteration.
+                found_profile_flag = false;
+                if arg.starts_with('-') {
+                    profile = Some(String::new());
+                    // Re-process this arg: push it to remaining for clap
+                    remaining_turbo_args.push(arg);
+                } else {
+                    profile = Some(arg.clone());
+                    remaining_turbo_args.push(arg);
+                }
+            } else if found_anon_profile_flag {
+                found_anon_profile_flag = false;
+                if arg.starts_with('-') {
+                    anon_profile = Some(String::new());
+                    remaining_turbo_args.push(arg);
+                } else {
+                    anon_profile = Some(arg.clone());
+                    remaining_turbo_args.push(arg);
+                }
+            } else if arg == "--profile" {
+                remaining_turbo_args.push(arg);
+                found_profile_flag = true;
+            } else if let Some(value) = arg.strip_prefix("--profile=") {
+                profile = Some(value.to_string());
+                remaining_turbo_args.push(arg);
+            } else if arg == "--anon-profile" {
+                remaining_turbo_args.push(arg);
+                found_anon_profile_flag = true;
+            } else if let Some(value) = arg.strip_prefix("--anon-profile=") {
+                anon_profile = Some(value.to_string());
+                remaining_turbo_args.push(arg);
             } else if arg == "--debug" {
                 return Err(Error::UnsupportedFlag {
                     flag: "--debug".to_string(),
@@ -189,6 +232,14 @@ impl ShimArgs {
             }
         }
 
+        // If --profile or --anon-profile was the last arg, treat as no value
+        if found_profile_flag {
+            profile = Some(String::new());
+        }
+        if found_anon_profile_flag {
+            anon_profile = Some(String::new());
+        }
+
         if let Some(idx) = cwd_flag_idx {
             let (spans, args_string) =
                 Self::get_spans_in_args_string(vec![idx], env::args().skip(1));
@@ -241,9 +292,34 @@ impl ShimArgs {
             color,
             no_color,
             root_turbo_json,
+            profile,
+            anon_profile,
         })
     }
 
+    /// Returns the resolved profile file path and whether to include args
+    /// (true for `--profile`, false for `--anon-profile`).
+    pub fn profile_file_and_include_args(&self) -> Option<(String, bool)> {
+        let resolve = |file: &str| -> String {
+            if file.is_empty() {
+                let now = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .expect("system clock is before unix epoch")
+                    .as_millis();
+                format!("profile.{now}")
+            } else {
+                file.to_string()
+            }
+        };
+
+        match (self.profile.as_deref(), self.anon_profile.as_deref()) {
+            (Some(file), None) => Some((resolve(file), true)),
+            (None, Some(file)) => Some((resolve(file), false)),
+            // Both set should be caught by clap later; just ignore here.
+            _ => None,
+        }
+    }
+
     /// Takes a list of indices into a Vec of arguments, i.e. ["--graph", "foo",
     /// "--cwd"] and converts them into `SourceSpan`'s into the string of those
     /// arguments, i.e. "-- graph foo --cwd". Returns the spans and the args
@@ -401,6 +477,8 @@ mod test {
                 no_color,
                 root_turbo_json: relative_root_turbo_json
                     .map(|path| AbsoluteSystemPathBuf::from_unknown(invocation_dir, path)),
+                profile: None,
+                anon_profile: None,
             }
         }
     }

crates/turborepo-shim/src/run.rs

@@ -183,6 +183,7 @@ where
 ///
 /// A `ShimResult` containing either the exit code, a shim error, or a CLI
 /// error.
+#[tracing::instrument(skip_all)]
 pub fn run_with_args<R, C, S, V>(
     runtime: &ShimRuntime<R, C, S, V>,
     args: ShimArgs,