feat(rustup-init): (wip) use process().stderr() as a tracing output, pt. 2

Author: rami3l

src/bin/rustup-init.rs

@@ -55,12 +55,16 @@ fn main() {
 }
 
 async fn maybe_trace_rustup() -> Result<utils::ExitCode> {
-    #[cfg(not(feature = "otel"))]
-    {
-        run_rustup().await
-    }
+    use tracing_subscriber::{
+        filter::LevelFilter, layer::SubscriberExt, EnvFilter, Layer, Registry,
+    };
+
+    let curr_process = process();
+    let has_ansi = curr_process.stderr().is_a_tty();
+    let maybe_rust_log_directives = curr_process.var_os("RUST_LOG").clone();
+
     #[cfg(feature = "otel")]
-    {
+    let telemetry = {
         use std::time::Duration;
 
         use opentelemetry::{global, KeyValue};
@@ -70,11 +74,9 @@ async fn maybe_trace_rustup() -> Result<utils::ExitCode> {
             trace::{self, Sampler},
             Resource,
         };
-        use tracing_subscriber::{fmt, layer::SubscriberExt, EnvFilter, Registry};
-
-        let curr_process = process();
 
         global::set_text_map_propagator(TraceContextPropagator::new());
+
         let tracer = opentelemetry_otlp::new_pipeline()
             .tracing()
             .with_exporter(
@@ -89,23 +91,44 @@ async fn maybe_trace_rustup() -> Result<utils::ExitCode> {
             )
             .install_batch(opentelemetry_sdk::runtime::Tokio)?;
         let env_filter = EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("INFO"));
-        let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
-        let subscriber = Registry::default()
-            .with(
-                fmt::layer()
-                    .with_ansi(curr_process.stderr().is_a_tty())
-                    .with_writer(move || curr_process.stderr()),
-            )
-            .with(env_filter)
-            .with(telemetry);
-        tracing::subscriber::set_global_default(subscriber)?;
-        let result = run_rustup().await;
-        // We're tracing, so block until all spans are exported.
-        opentelemetry::global::shutdown_tracer_provider();
-        result
-    }
+        tracing_opentelemetry::layer()
+            .with_tracer(tracer)
+            .with_filter(env_filter)
+    };
+    let console_logger = {
+        let logger = tracing_subscriber::fmt::layer()
+            .with_writer(move || curr_process.stderr())
+            .with_ansi(has_ansi);
+        if let Some(directives) = maybe_rust_log_directives {
+            let env_filter = EnvFilter::builder()
+                .with_default_directive(LevelFilter::INFO.into())
+                .parse_lossy(directives.to_string_lossy());
+            logger.compact().with_filter(env_filter).boxed()
+        } else {
+            let env_filter = EnvFilter::new("DEBUG");
+            // FIXME: Add "classical" formatting
+            logger.with_filter(env_filter).boxed()
+        }
+    };
+    let subscriber = {
+        #[cfg(feature = "otel")]
+        {
+            Registry::default().with(console_logger).with(telemetry)
+        }
+        #[cfg(not(feature = "otel"))]
+        {
+            Registry::default().with(console_logger)
+        }
+    };
+    tracing::subscriber::set_global_default(subscriber)?;
+    let result = run_rustup().await;
+    // We're tracing, so block until all spans are exported.
+    #[cfg(feature = "otel")]
+    opentelemetry::global::shutdown_tracer_provider();
+    result
 }
 
+// FIXME: Make `tracing::instrument` always run
 #[cfg_attr(feature = "otel", tracing::instrument)]
 async fn run_rustup() -> Result<utils::ExitCode> {
     if let Ok(dir) = process().var("RUSTUP_TRACE_DIR") {