Unify log source labeling and env inheritance

Author: pasunboneleve

CHANGELOG.md

@@ -5,13 +5,14 @@ All notable changes to `devloop` will be recorded in this file.
 ## [Unreleased]
 
 ### Fixed
-- Stopped `devloop`'s own `RUST_LOG` setting from leaking into managed
-  child processes unless the child explicitly sets `RUST_LOG` in
-  config.
-- Defaulted managed child `RUST_LOG` to `info` when unset so Rust-based
-  child processes do not surprise users with verbose debug output.
 - Removed bright white from inherited output label colors and dimmed
   source labels alongside dimmed inherited process bodies.
+- Restored managed child-process environment inheritance so `devloop`
+  and supervised processes read the same ambient `RUST_LOG` unless repo
+  config explicitly overrides it.
+- Prefixed internal dependency logs under `devloop`, for example
+  `[devloop hyper_util ...]`, and reordered managed-process labels to
+  `[executable process-name]` so the emitting process is visible first.
 
 ## [0.4.0] - 2026-03-25
 

README.md

@@ -122,18 +122,18 @@ At the same time, the tunnel itself is described as a managed process:
 * inherited process output is source-labeled without wrapper scripts
 
 When you need to identify which managed process emitted a line in mixed
-output, inherited process lines include the configured process name and
-executable automatically. The label is color-coded per process, and the
-body style is configurable:
+output, inherited process lines include the executable first and the
+configured process name second. The label is color-coded per process,
+and the body style is configurable:
 
 ```toml
 [process.tunnel]
 command = ["cloudflared", "tunnel", "--url", "http://127.0.0.1:18080"]
 output = { inherit = true, body_style = "plain", rules = [{ state_key = "tunnel_url", extract = "url_token" }] }
 ```
 
-That renders inherited lines with the process name and executable, for
-example `[tunnel cloudflared] ...`, using ANSI color when stdout is a
+That renders inherited lines with the executable and process name, for
+example `[cloudflared tunnel] ...`, using ANSI color when stdout is a
 terminal and `NO_COLOR` is not set.
 
 For the runtime behavior reference, see

docs/behavior.md

@@ -59,8 +59,9 @@ Managed processes are long-running child commands.
   `devloop` is shutting down.
 - `restart = "on_failure"` restarts only after unsuccessful exit.
 - `restart = "never"` never restarts automatically.
-- Managed child processes default to `RUST_LOG=info` unless the process
-  config explicitly sets `env.RUST_LOG`.
+- Managed child processes inherit the ambient environment unless the
+  process config explicitly overrides individual variables such as
+  `env.RUST_LOG`.
 
 Liveness probes are checked on the configured interval while the process
 is running. If a liveness probe fails and the restart policy allows it,
@@ -90,8 +91,11 @@ Hooks are one-shot commands executed inside workflows.
 - Child stdout is forwarded to `devloop` stdout.
 - Child stderr is forwarded to `devloop` stderr.
 - `devloop` engine and process logs are emitted through `tracing`.
-- Managed-process and hook output is source-labeled with the configured
-  name and executable.
+- Managed-process and hook output is source-labeled as
+  `[executable process-name]`.
+- Internal `devloop` and dependency logs are grouped under
+  `[devloop ...]` labels so the emitting supervisor remains visible
+  first.
 - When output color is enabled, labels are colorized per source.
 
 ### Color rules

src/main.rs

@@ -17,7 +17,7 @@ use tracing_subscriber::registry::LookupSpan;
 
 use crate::config::Config;
 use crate::engine::Engine;
-use crate::output::{format_output_prefix, normalize_source_label, should_colorize_output};
+use crate::output::{format_output_prefix, normalize_internal_log_label, should_colorize_output};
 
 #[derive(Debug, Parser)]
 #[command(
@@ -93,7 +93,7 @@ where
         event: &Event<'_>,
     ) -> std::fmt::Result {
         let metadata = event.metadata();
-        let label = normalize_source_label(metadata.target());
+        let label = normalize_internal_log_label(metadata.target());
         writer.write_str(&format_output_prefix(&label, should_colorize_output()))?;
         write!(writer, "{} ", metadata.level())?;
         self.timer.format_time(&mut writer)?;
@@ -122,7 +122,9 @@ fn resolve_config_path(config: Option<PathBuf>) -> Result<PathBuf> {
 #[cfg(test)]
 mod tests {
     use super::default_rust_log;
-    use crate::output::{format_output_prefix, normalize_source_label};
+    use crate::output::{
+        format_output_prefix, normalize_internal_log_label, normalize_source_label,
+    };
     use std::sync::{Mutex, OnceLock};
 
     fn rust_log_lock() -> &'static Mutex<()> {
@@ -158,4 +160,15 @@ mod tests {
             "[devloop processes] "
         );
     }
+
+    #[test]
+    fn tracing_prefix_wraps_dependency_targets_under_devloop() {
+        assert_eq!(
+            format_output_prefix(
+                &normalize_internal_log_label("hyper_util::client::legacy::connect::http"),
+                false
+            ),
+            "[devloop hyper_util client legacy connect http] "
+        );
+    }
 }

src/output.rs

@@ -7,6 +7,15 @@ pub(crate) fn normalize_source_label(source_label: &str) -> String {
     source_label.replace("::", " ")
 }
 
+pub(crate) fn normalize_internal_log_label(source_label: &str) -> String {
+    let normalized = normalize_source_label(source_label);
+    if normalized.starts_with("devloop ") {
+        normalized
+    } else {
+        format!("devloop {normalized}")
+    }
+}
+
 pub(crate) fn format_output_prefix(source_label: &str, colorize: bool) -> String {
     format_output_prefix_with_style(source_label, colorize, OutputBodyStyle::Plain)
 }
@@ -68,8 +77,9 @@ fn colorize_label(source_label: &str, body_style: OutputBodyStyle) -> String {
 #[cfg(test)]
 mod tests {
     use super::{
-        dim_start, format_output_prefix, format_output_prefix_with_style, normalize_source_label,
-        output_color_code, style_output_text, style_reset,
+        dim_start, format_output_prefix, format_output_prefix_with_style,
+        normalize_internal_log_label, normalize_source_label, output_color_code, style_output_text,
+        style_reset,
     };
     use crate::config::OutputBodyStyle;
 
@@ -81,6 +91,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn normalize_internal_log_label_prefixes_non_devloop_targets() {
+        assert_eq!(
+            normalize_internal_log_label("hyper_util::client::legacy::connect::http"),
+            "devloop hyper_util client legacy connect http"
+        );
+    }
+
+    #[test]
+    fn normalize_internal_log_label_keeps_devloop_targets_stable() {
+        assert_eq!(
+            normalize_internal_log_label("devloop::engine"),
+            "devloop engine"
+        );
+    }
+
     #[test]
     fn format_output_prefix_falls_back_without_color() {
         assert_eq!(

src/processes.rs

@@ -724,7 +724,7 @@ fn process_output_source_label(name: &str, command: &[String]) -> String {
         .first()
         .map(|program| executable_display_name(program))
         .unwrap_or_else(|| "unknown".to_owned());
-    format!("{name} {executable}")
+    format!("{executable} {name}")
 }
 
 fn executable_display_name(program: &str) -> String {
@@ -752,10 +752,6 @@ fn configure_command(
     let mut cmd = Command::new(program);
     cmd.args(&command[1..]);
     cmd.current_dir(cwd);
-    cmd.env_remove("RUST_LOG");
-    if !env.contains_key("RUST_LOG") {
-        cmd.env("RUST_LOG", "info");
-    }
     cmd.envs(env);
     cmd.env("DEVLOOP_ROOT", root);
     cmd.env("DEVLOOP_STATE", state_path);
@@ -1237,7 +1233,7 @@ mod tests {
 
         write_captured_output_to_writer(
             &writer,
-            "build_css build-css.sh",
+            "build-css.sh build_css",
             b"Done in 73ms\n",
             OutputBodyStyle::Dim,
         )
@@ -1252,7 +1248,7 @@ mod tests {
             .await
             .expect("read rendered output");
 
-        assert!(rendered.contains("[build_css build-css.sh]"));
+        assert!(rendered.contains("[build-css.sh build_css]"));
         if should_colorize_output() {
             assert!(rendered.contains("\u{1b}[2mDone in 73ms\u{1b}[0m"));
         } else {
@@ -1261,13 +1257,13 @@ mod tests {
     }
 
     #[test]
-    fn process_output_source_label_uses_process_name_and_executable() {
+    fn process_output_source_label_uses_executable_before_process_name() {
         let label = process_output_source_label(
             "build_css",
             &["./scripts/build-css.sh".into(), "--watch".into()],
         );
 
-        assert_eq!(label, "build_css build-css.sh");
+        assert_eq!(label, "build-css.sh build_css");
     }
 
     #[test]
@@ -1276,7 +1272,7 @@ mod tests {
     }
 
     #[test]
-    fn configure_command_defaults_child_rust_log_to_info() {
+    fn configure_command_inherits_parent_rust_log_by_default() {
         let original = std::env::var_os("RUST_LOG");
         unsafe {
             std::env::set_var("RUST_LOG", "debug");
@@ -1296,11 +1292,12 @@ mod tests {
         let rust_log = command
             .as_std()
             .get_envs()
-            .find(|(key, _)| *key == std::ffi::OsStr::new("RUST_LOG"))
-            .and_then(|(_, value)| value)
-            .expect("RUST_LOG entry should be set");
+            .find(|(key, _)| *key == std::ffi::OsStr::new("RUST_LOG"));
 
-        assert_eq!(rust_log, "info");
+        assert!(
+            rust_log.is_none(),
+            "RUST_LOG should not be overridden in child env"
+        );
 
         restore_rust_log(original);
     }