feat: support enabling tracing

.vscode/settings.json

@@ -28,6 +28,7 @@
     "Finalizer",
     "hasher",
     "importee",
+    "napi",
     "oxlint",
     "oxlintignore",
     "Renamer",

crates/rolldown/examples/basic.rs

@@ -6,23 +6,15 @@ use sugar_path::SugarPathBuf;
 #[tokio::main]
 async fn main() -> Result<()> {
   let root = PathBuf::from(&std::env::var("CARGO_MANIFEST_DIR").unwrap());
-  let repo_root = root.parent().unwrap().parent().unwrap();
   let cwd = root.join("./examples").into_normalize();
   let mut bundler = Bundler::new(InputOptions {
-    input: vec![InputItem {
-      name: Some("basic".to_string()),
-      import: repo_root
-        .join("temp/three10x/entry.js")
-        .into_normalize()
-        .to_string_lossy()
-        .to_string(),
-    }],
+    input: vec![InputItem { name: Some("basic".to_string()), import: "./index.js".to_string() }],
     cwd,
     ..Default::default()
   });
 
-  let outputs = bundler.write(Default::default()).await.unwrap();
-  println!("{outputs:#?}");
+  let _outputs = bundler.write(Default::default()).await.unwrap();
+  // println!("{outputs:#?}");
 
   Ok(())
 }

crates/rolldown/src/bundler/bundler.rs

@@ -40,7 +40,7 @@ impl Bundler<OsFileSystem> {
 
 impl<T: FileSystem + Default + 'static> Bundler<T> {
   pub fn with_plugins_and_fs(input_options: InputOptions, plugins: Vec<BoxPlugin>, fs: T) -> Self {
-    // rolldown_tracing::enable_tracing_on_demand();
+    rolldown_tracing::try_init_tracing();
     Self {
       resolver: Resolver::with_cwd_and_fs(input_options.cwd.clone(), false, fs.share()).into(),
       plugin_driver: Arc::new(PluginDriver::new(plugins)),
@@ -107,6 +107,7 @@ impl<T: FileSystem + Default + 'static> Bundler<T> {
     build_ret
   }
 
+  #[tracing::instrument(skip_all)]
   async fn try_build(&mut self) -> BatchedResult<LinkStageOutput> {
     let build_info = ScanStage::new(
       Arc::clone(&self.input_options),
@@ -122,6 +123,7 @@ impl<T: FileSystem + Default + 'static> Bundler<T> {
     Ok(link_stage.link())
   }
 
+  #[tracing::instrument(skip_all)]
   async fn bundle_up(&mut self, output_options: OutputOptions) -> BuildResult<Vec<Output>> {
     tracing::trace!("InputOptions {:#?}", self.input_options);
     tracing::trace!("OutputOptions: {output_options:#?}",);

crates/rolldown/src/bundler/stages/bundle_stage.rs

@@ -34,6 +34,7 @@ impl<'a> BundleStage<'a> {
     Self { link_output, output_options, input_options }
   }
 
+  #[tracing::instrument(skip_all)]
   pub fn bundle(&mut self) -> Vec<Output> {
     use rayon::prelude::*;
     let mut chunk_graph = self.generate_chunks();

crates/rolldown/src/bundler/stages/link_stage.rs

@@ -42,6 +42,7 @@ impl LinkStage {
     }
   }
 
+  #[tracing::instrument(skip_all)]
   pub fn link(mut self) -> LinkStageOutput {
     self.sort_modules();
     Linker::new(&mut self).link();

crates/rolldown/src/bundler/stages/scan_stage.rs

@@ -46,6 +46,7 @@ impl<Fs: FileSystem + Default + 'static> ScanStage<Fs> {
     Self { input_options, plugin_driver, fs, resolver }
   }
 
+  #[tracing::instrument(skip_all)]
   pub async fn scan(&self) -> BatchedResult<ScanStageOutput> {
     assert!(!self.input_options.input.is_empty(), "You must supply options.input to rolldown");
 

crates/rolldown_binding/src/bundler.rs

@@ -6,7 +6,7 @@ use tracing::instrument;
 
 use crate::{
   options::InputOptions, options::OutputOptions, output::Outputs,
-  utils::init_custom_trace_subscriber, NAPI_ENV,
+  utils::try_init_custom_trace_subscriber, NAPI_ENV,
 };
 
 #[napi]
@@ -18,7 +18,7 @@ pub struct Bundler {
 impl Bundler {
   #[napi(constructor)]
   pub fn new(env: Env, input_opts: InputOptions) -> napi::Result<Self> {
-    init_custom_trace_subscriber(env);
+    try_init_custom_trace_subscriber(env);
     Self::new_impl(env, input_opts)
   }
 

crates/rolldown_binding/src/utils/mod.rs

@@ -1,26 +1,24 @@
 pub mod napi_error_ext;
 use napi::Env;
-use std::env;
-use std::sync::atomic::AtomicBool;
 mod into_js_unknown_vec;
 pub use into_js_unknown_vec::*;
 mod js_callback;
 pub use js_callback::*;
-use rolldown_tracing::enable_tracing_on_demand;
+use rolldown_tracing::try_init_tracing_with_chrome_layer;
 
-static IS_ENABLE_TRACING: AtomicBool = AtomicBool::new(false);
-
-pub fn init_custom_trace_subscriber(mut napi_env: Env) {
-  let value = env::var("TRACE").unwrap_or_default();
-  if value == "1" && !IS_ENABLE_TRACING.swap(true, std::sync::atomic::Ordering::SeqCst) {
-    let guard = enable_tracing_on_demand();
-    if let Some(guard) = guard {
-      napi_env
-        .add_env_cleanup_hook(guard, |flush_guard| {
-          flush_guard.flush();
-          drop(flush_guard);
-        })
-        .expect("Should able to initialize cleanup for custom trace subscriber");
+pub fn try_init_custom_trace_subscriber(mut napi_env: Env) {
+  match std::env::var("LOG_LAYER") {
+    Ok(val) if val == "chrome" => {
+      let guard = try_init_tracing_with_chrome_layer();
+      if let Some(guard) = guard {
+        napi_env
+          .add_env_cleanup_hook(guard, |flush_guard| {
+            flush_guard.flush();
+            drop(flush_guard);
+          })
+          .expect("Should able to initialize cleanup for custom trace subscriber");
+      }
     }
+    _ => {}
   }
 }

crates/rolldown_tracing/Cargo.toml

@@ -10,7 +10,12 @@ license.workspace    = true
 edition.workspace    = true
 repository.workspace = true
 
+[lib]
+bench   = false
+test    = false
+doctest = false
+
 [dependencies]
 tracing            = { workspace = true }
-tracing-chrome     = "0.7.0"
+tracing-chrome     = "0.7.1"
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }

crates/rolldown_tracing/src/lib.rs

@@ -1,20 +1,65 @@
+/// Some guidelines for tracing:
+/// - By default, only allow tracing events from crates of this repo.
+/// - Using `LOG_OUTPUT=chrome` to collect tracing events into a json file.
+///   - This only works on using `@rolldown/node`. If you are running rolldown in rust, this doesn't works.
+/// - Using `LOG=TRACE` to enable tracing or other values for more specific tracing.
+///   - See  https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#example-syntax for more syntax details.
 use std::sync::atomic::AtomicBool;
 
-use tracing::{metadata::LevelFilter, Level};
+use tracing::{level_filters::LevelFilter, Level};
 use tracing_chrome::FlushGuard;
+use tracing_subscriber::EnvFilter;
+use tracing_subscriber::{fmt, prelude::*};
 
-static IS_INITIALIZE: AtomicBool = AtomicBool::new(false);
+static IS_INITIALIZED: AtomicBool = AtomicBool::new(false);
 
-pub fn enable_tracing_on_demand() -> Option<FlushGuard> {
-  use tracing_subscriber::{fmt, prelude::*, EnvFilter};
-  if !IS_INITIALIZE.swap(true, std::sync::atomic::Ordering::SeqCst) {
+pub fn try_init_tracing() {
+  if std::env::var("LOG").is_err() {
+    // tracing will slow down the bundling process, so we only enable it when `LOG` is set.
+    return;
+  }
+  if !IS_INITIALIZED.swap(true, std::sync::atomic::Ordering::SeqCst) {
     tracing_subscriber::registry()
-      .with(fmt::layer())
       .with(
-        tracing_subscriber::filter::Targets::new().with_targets(vec![("rolldown", Level::TRACE)]),
+        tracing_subscriber::filter::Targets::new()
+          .with_targets(vec![("rolldown", Level::TRACE), ("rolldown_binding", Level::TRACE)]),
+      )
+      .with(
+        EnvFilter::builder()
+          .with_env_var("LOG")
+          .with_default_directive(LevelFilter::TRACE.into())
+          .from_env_lossy(),
+      )
+      .with(fmt::layer().pretty().without_time())
+      .init();
+    tracing::trace!("Tracing is initialized.");
+  }
+}
+
+pub fn try_init_tracing_with_chrome_layer() -> Option<FlushGuard> {
+  use tracing_chrome::ChromeLayerBuilder;
+  use tracing_subscriber::prelude::*;
+  if std::env::var("LOG").is_err() {
+    // tracing will slow down the bundling process, so we only enable it when `LOG` is set.
+    return None;
+  }
+  if IS_INITIALIZED.swap(true, std::sync::atomic::Ordering::SeqCst) {
+    None
+  } else {
+    let (chrome_layer, guard) = ChromeLayerBuilder::new().build();
+    tracing_subscriber::registry()
+      .with(
+        tracing_subscriber::filter::Targets::new()
+          .with_targets(vec![("rolldown", Level::TRACE), ("rolldown_binding", Level::TRACE)]),
+      )
+      .with(
+        EnvFilter::builder()
+          .with_env_var("LOG")
+          .with_default_directive(LevelFilter::TRACE.into())
+          .from_env_lossy(),
       )
-      .with(EnvFilter::builder().with_default_directive(LevelFilter::TRACE.into()).from_env_lossy())
+      .with(chrome_layer)
       .init();
+    Some(guard)
   }
-  None
 }