More otel debug tracing

Author: nojaf

rewatch/src/build/compile_dependencies.rs

@@ -27,6 +27,13 @@ pub fn compile_dependencies(
         .cloned()
         .collect();
 
+    tracing::debug!(
+        starts = ?module_names.iter().collect::<Vec<_>>(),
+        closure_size = closure.len(),
+        needs_compile_count = needs_compile.len(),
+        "compile_dependencies: closure computed"
+    );
+
     let params = CompileParams {
         modules: closure,
         filter: CompileFilter::DirtyOnly(needs_compile),
@@ -53,6 +60,12 @@ pub fn compile_dependencies(
 
     if !result.compile_errors.is_empty() {
         let _error_span = info_span!("build.compile_error", error = %result.compile_errors).entered();
+        if !result.skipped_modules.is_empty() {
+            tracing::debug!(
+                skipped = ?result.skipped_modules.iter().collect::<Vec<_>>(),
+                "compile_dependencies: modules skipped due to errors"
+            );
+        }
         Err(IncrementalBuildError {
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: OutputMode::Silent,

rewatch/src/build/full_typecheck.rs

@@ -39,12 +39,18 @@ pub fn full_typecheck(
 
     if !result.compile_errors.is_empty() {
         let _error_span = info_span!("build.compile_error", error = %result.compile_errors).entered();
+        if !result.skipped_modules.is_empty() {
+            tracing::debug!(
+                skipped = ?result.skipped_modules.iter().collect::<Vec<_>>(),
+                "full_typecheck: modules skipped due to errors"
+            );
+        }
         Err(IncrementalBuildError {
             kind: IncrementalBuildErrorKind::CompileError(None),
             output_mode: OutputMode::Silent,
             diagnostics: result.to_diagnostics(),
             modules: Box::new(params.modules),
-            skipped_modules: Box::default(),
+            skipped_modules: Box::new(result.skipped_modules),
         })
     } else {
         write_compiler_info(build_state, OutputTarget::Lsp);

rewatch/src/lsp/queue.rs

@@ -617,14 +617,33 @@ async fn flush_inner(
     // full_compile_intent. Intent drain piggybacks on the same
     // take-build-replace cycle — no extra locking needed.
     let errored_files = if has_incremental_builds || (has_full_builds && has_pending_intents) {
-        file_build::run(
+        if has_pending_intents {
+            for (root, names) in state.full_compile_intent.iter() {
+                tracing::debug!(
+                    project = %root.display(),
+                    modules = ?names.iter().collect::<Vec<_>>(),
+                    "flush: full_compile_intent before file_build"
+                );
+            }
+        }
+        let errored = file_build::run(
             &compile_files,
             &mut state.full_compile_intent,
             projects,
             client,
             store_ref,
         )
-        .await
+        .await;
+        if !state.full_compile_intent.is_empty() {
+            for (root, names) in state.full_compile_intent.iter() {
+                tracing::debug!(
+                    project = %root.display(),
+                    modules = ?names.iter().collect::<Vec<_>>(),
+                    "flush: full_compile_intent remaining after file_build"
+                );
+            }
+        }
+        errored
     } else {
         HashSet::new()
     };

rewatch/src/lsp/queue/file_build.rs

@@ -290,7 +290,7 @@ fn build_batch(
     let mut intent_names = intent.unwrap_or_default();
     if !skipped_modules.is_empty() {
         tracing::debug!(
-            skipped_count = skipped_modules.len(),
+            skipped = ?skipped_modules.iter().collect::<Vec<_>>(),
             "build_batch: registering skipped modules as FullCompile intent"
         );
         intent_names.extend(skipped_modules);
@@ -516,33 +516,45 @@ fn drain_full_compile_intent(
     let mut pending = AHashSet::new();
     let mut not_ready = HashSet::new();
 
+    let mut already_built = Vec::new();
+    let mut discarded = Vec::new();
+
     for name in names {
         match build_state.build_state.modules.get(&name) {
             Some(Module::SourceFile(sf)) => match sf.compilation_stage() {
                 CompilationStage::Built(..) => {
-                    // Already compiled — nothing to do.
+                    already_built.push(name);
                 }
                 CompilationStage::TypeChecked { .. } => {
                     pending.insert(name);
                 }
-                _ => {
-                    // Not ready yet (e.g. CompileError, SourceDirty).
+                other => {
+                    tracing::debug!(
+                        module = %name,
+                        stage = ?std::mem::discriminant(other),
+                        "drain_intent: module not ready"
+                    );
                     not_ready.insert(name);
                 }
             },
             _ => {
-                // Module no longer exists — discard.
+                discarded.push(name);
             }
         }
     }
 
+    tracing::debug!(
+        built_count = already_built.len(),
+        pending_count = pending.len(),
+        not_ready_count = not_ready.len(),
+        discarded_count = discarded.len(),
+        built = ?already_built,
+        pending_modules = ?pending.iter().collect::<Vec<_>>(),
+        not_ready_modules = ?not_ready.iter().collect::<Vec<_>>(),
+        "drain_intent: partition"
+    );
+
     if pending.is_empty() {
-        if !not_ready.is_empty() {
-            tracing::debug!(
-                "drain_intent: no TypeChecked modules to compile ({} still pending)",
-                not_ready.len()
-            );
-        }
         return not_ready;
     }
 
@@ -563,7 +575,14 @@ fn drain_full_compile_intent(
         }
         Err(e) => {
             tracing::warn!("drain_intent completed with errors: {e}");
+            if !e.skipped_modules.is_empty() {
+                tracing::debug!(
+                    skipped = ?e.skipped_modules.iter().collect::<Vec<_>>(),
+                    "drain_intent: skipped modules from compile_dependencies"
+                );
+            }
             // Keep failed modules in intent for next attempt.
+            let mut became_built = Vec::new();
             for name in &pending {
                 if build_state.build_state.modules.get(name).is_some_and(|m| {
                     !matches!(
@@ -573,8 +592,16 @@ fn drain_full_compile_intent(
                     )
                 }) {
                     not_ready.insert(name.clone());
+                } else {
+                    became_built.push(name.clone());
                 }
             }
+            if !became_built.is_empty() {
+                tracing::debug!(
+                    modules = ?became_built,
+                    "drain_intent: modules reached Built despite errors (dropped from intent)"
+                );
+            }
             diagnostics.extend(e.diagnostics);
             touched_files.extend(module_names_to_paths(build_state, &e.modules));
         }

rewatch/src/lsp/queue/project_build.rs

@@ -269,6 +269,12 @@ pub(super) async fn run(
                             }
                         }
 
+                        tracing::debug!(
+                            built_snapshot_modules = ?built_snap.keys().collect::<Vec<_>>(),
+                            error_fullcompile_modules = ?error_fc.iter().collect::<Vec<_>>(),
+                            "project_build: snapshot from old state"
+                        );
+
                         (
                             collect_source_uris(old_state),
                             old_state.get_warn_error_override().clone(),
@@ -344,14 +350,14 @@ pub(super) async fn run(
                         }
                     }
 
-                    if promoted > 0 || !intent.is_empty() {
-                        tracing::debug!(
-                            project = %project_root.display(),
-                            promoted,
-                            intent_count = intent.len(),
-                            "project_build: hash promotion results"
-                        );
-                    }
+                    tracing::debug!(
+                        project = %project_root.display(),
+                        snapshot_size = built_snapshot.len(),
+                        promoted,
+                        intent_count = intent.len(),
+                        intent_modules = ?intent.iter().collect::<Vec<_>>(),
+                        "project_build: hash promotion results"
+                    );
 
                     // Replace state under lock
                     if let Ok(mut guard) = projects_clone.lock() {