Turbopack: more traces

Author: mischnic

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -1,19 +1,19 @@
 use std::{
     env::current_dir,
     mem::forget,
-    path::{PathBuf, MAIN_SEPARATOR},
+    path::{MAIN_SEPARATOR, PathBuf},
     sync::Arc,
 };
 
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use rustc_hash::FxHashSet;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{
-    apply_effects, ReadConsistency, ResolvedVc, TransientInstance, TryJoinIterExt, TurboTasks,
-    Value, Vc,
+    ReadConsistency, ResolvedVc, TransientInstance, TryJoinIterExt, TurboTasks, Value, Vc,
+    apply_effects,
 };
 use turbo_tasks_backend::{
-    noop_backing_storage, BackendOptions, NoopBackingStorage, TurboTasksBackend,
+    BackendOptions, NoopBackingStorage, TurboTasksBackend, noop_backing_storage,
 };
 use turbo_tasks_fs::FileSystem;
 use turbopack::global_module_ids::get_global_module_id_strategy;
@@ -22,16 +22,16 @@ use turbopack_cli_utils::issue::{ConsoleUi, LogOptions};
 use turbopack_core::{
     asset::Asset,
     chunk::{
-        availability_info::AvailabilityInfo, ChunkingConfig, ChunkingContext, EvaluatableAsset,
-        EvaluatableAssets, MinifyType, SourceMapsType,
+        ChunkingConfig, ChunkingContext, EvaluatableAsset, EvaluatableAssets, MinifyType,
+        SourceMapsType, availability_info::AvailabilityInfo,
     },
     environment::{BrowserEnvironment, Environment, ExecutionEnvironment, NodeJsEnvironment},
     ident::AssetIdent,
-    issue::{handle_issues, IssueReporter, IssueSeverity},
+    issue::{IssueReporter, IssueSeverity, handle_issues},
     module::Module,
     module_graph::{
-        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
         ModuleGraph,
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
     },
     output::{OutputAsset, OutputAssets},
     reference::all_assets_from_entries,
@@ -48,9 +48,9 @@ use turbopack_nodejs::NodeJsChunkingContext;
 
 use crate::{
     arguments::{BuildArguments, Target},
-    contexts::{get_client_asset_context, get_client_compile_time_info, NodeEnv},
+    contexts::{NodeEnv, get_client_asset_context, get_client_compile_time_info},
     util::{
-        normalize_dirs, normalize_entries, output_fs, project_fs, EntryRequest, NormalizedDirs,
+        EntryRequest, NormalizedDirs, normalize_dirs, normalize_entries, output_fs, project_fs,
     },
 };
 
@@ -149,7 +149,9 @@ impl TurbopackBuildBuilder {
             // Await the result to propagate any errors.
             build_result_op.read_strongly_consistent().await?;
 
-            apply_effects(build_result_op).await?;
+            apply_effects(build_result_op)
+                .instrument(tracing::info_span!("apply effects"))
+                .await?;
 
             let issue_reporter: Vc<Box<dyn IssueReporter>> =
                 Vc::upcast(ConsoleUi::new(TransientInstance::new(LogOptions {
@@ -270,26 +272,30 @@ async fn build_internal(
 
     let origin = PlainResolveOrigin::new(asset_context, project_fs.root().join("_".into()));
     let project_dir = &project_dir;
-    let entries = entry_requests
-        .into_iter()
-        .map(|request_vc| async move {
-            let ty = Value::new(ReferenceType::Entry(EntryReferenceSubType::Undefined));
-            let request = request_vc.await?;
-            origin
-                .resolve_asset(request_vc, origin.resolve_options(ty.clone()), ty)
-                .await?
-                .first_module()
-                .await?
-                .with_context(|| {
-                    format!(
-                        "Unable to resolve entry {} from directory {}.",
-                        request.request().unwrap(),
-                        project_dir
-                    )
-                })
-        })
-        .try_join()
-        .await?;
+    let entries = async move {
+        entry_requests
+            .into_iter()
+            .map(|request_vc| async move {
+                let ty = Value::new(ReferenceType::Entry(EntryReferenceSubType::Undefined));
+                let request = request_vc.await?;
+                origin
+                    .resolve_asset(request_vc, origin.resolve_options(ty.clone()), ty)
+                    .await?
+                    .first_module()
+                    .await?
+                    .with_context(|| {
+                        format!(
+                            "Unable to resolve entry {} from directory {}.",
+                            request.request().unwrap(),
+                            project_dir
+                        )
+                    })
+            })
+            .try_join()
+            .await
+    }
+    .instrument(tracing::info_span!("resolve entries"))
+    .await?;
 
     let module_graph =
         ModuleGraph::from_modules(Vc::cell(vec![ChunkGroupEntry::Entry(entries.clone())]));
@@ -445,7 +451,11 @@ async fn build_internal(
 
     let mut chunks: FxHashSet<ResolvedVc<Box<dyn OutputAsset>>> = FxHashSet::default();
     for chunk_group in entry_chunk_groups {
-        chunks.extend(&*all_assets_from_entries(*chunk_group).await?);
+        chunks.extend(
+            &*async move { all_assets_from_entries(*chunk_group).await }
+                .instrument(tracing::info_span!("list chunks"))
+                .await?,
+        );
     }
 
     chunks

turbopack/crates/turbopack-cli/src/lib.rs

@@ -2,6 +2,7 @@
 #![feature(min_specialization)]
 #![feature(arbitrary_self_types)]
 #![feature(arbitrary_self_types_pointers)]
+#![feature(async_closure)]
 
 pub mod arguments;
 pub mod build;