update tracing log format, remove unnessary rustwide log fields

crates/bin/docs_rs_builder/Cargo.toml

@@ -41,7 +41,6 @@ thiserror = { workspace = true }
 tokio = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
-tracing-log = "0.2.0"
 
 [dev-dependencies]
 docs_rs_build_queue = { path = "../../lib/docs_rs_build_queue", features = ["testing"] }

crates/bin/docs_rs_builder/src/logging.rs

@@ -1,10 +1,65 @@
 use docs_rs_logging::Config;
-use tracing_log::LogTracer;
+use log::{Level, Log, Metadata, Record};
 
 pub fn init(config: &Config) {
     if config.log_build_logs {
-        rustwide::logging::init_with(LogTracer::new());
+        rustwide::logging::init_with(RustwideLogTracer);
     } else {
         rustwide::logging::init();
     }
 }
+
+/// Forwards Rustwide's `log` records as tracing events containing their level,
+/// formatted message, and original log target.
+///
+/// Unlike `tracing_log::LogTracer`, this deliberately omits origin fields
+/// such as `log.module_path`, `log.file`, and `log.line`. Events retain the
+/// currently entered tracing span context, use `rustwide` as their tracing target,
+/// and preserve the original target in the `log.target` field.
+///
+/// Later we'll migrate rustwide to directly emitting tracing-events.
+#[derive(Debug, Default)]
+struct RustwideLogTracer;
+
+impl Log for RustwideLogTracer {
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        match metadata.level() {
+            Level::Error => tracing::enabled!(target: "rustwide", tracing::Level::ERROR),
+            Level::Warn => tracing::enabled!(target: "rustwide", tracing::Level::WARN),
+            Level::Info => tracing::enabled!(target: "rustwide", tracing::Level::INFO),
+            Level::Debug => tracing::enabled!(target: "rustwide", tracing::Level::DEBUG),
+            Level::Trace => tracing::enabled!(target: "rustwide", tracing::Level::TRACE),
+        }
+    }
+
+    fn log(&self, record: &Record<'_>) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+
+        match record.level() {
+            Level::Error => tracing::event!(
+                target: "rustwide", tracing::Level::ERROR,
+                { "log.target" = record.target(), message = format_args!("{}", record.args()) }
+            ),
+            Level::Warn => tracing::event!(
+                target: "rustwide", tracing::Level::WARN,
+                { "log.target" = record.target(), message = format_args!("{}", record.args()) }
+            ),
+            Level::Info => tracing::event!(
+                target: "rustwide", tracing::Level::INFO,
+                { "log.target" = record.target(), message = format_args!("{}", record.args()) }
+            ),
+            Level::Debug => tracing::event!(
+                target: "rustwide", tracing::Level::DEBUG,
+                { "log.target" = record.target(), message = format_args!("{}", record.args()) }
+            ),
+            Level::Trace => tracing::event!(
+                target: "rustwide", tracing::Level::TRACE,
+                { "log.target" = record.target(), message = format_args!("{}", record.args()) }
+            ),
+        }
+    }
+
+    fn flush(&self) {}
+}

crates/lib/docs_rs_logging/Cargo.toml

@@ -14,7 +14,7 @@ docs_rs_env_vars = { path = "../docs_rs_env_vars" }
 docs_rs_utils = { path = "../docs_rs_utils" }
 sentry = { workspace = true }
 tracing = { workspace = true }
-tracing-subscriber = { version = "0.3.20", default-features = false, features = ["ansi", "env-filter", "fmt", "json", "tracing-log"] }
+tracing-subscriber = { version = "0.3.20", default-features = false, features = ["ansi", "env-filter", "fmt", "json"] }
 
 [dev-dependencies]
 docs_rs_config = { path = "../docs_rs_config", features = ["testing"] }

crates/lib/docs_rs_logging/src/lib.rs

@@ -33,8 +33,10 @@ pub fn init_from_environment() -> anyhow::Result<Guard> {
 
 pub fn init_with_config(config: &Config) -> anyhow::Result<Guard> {
     let log_formatter = match config.format {
+        LogFormat::Full => tracing_subscriber::fmt::layer().boxed(),
+        LogFormat::Compact => tracing_subscriber::fmt::layer().compact().boxed(),
+        LogFormat::Pretty => tracing_subscriber::fmt::layer().pretty().boxed(),
         LogFormat::Json => tracing_subscriber::fmt::layer().json().boxed(),
-        LogFormat::Pretty => tracing_subscriber::fmt::layer().boxed(),
     };
 
     let tracing_registry = tracing_subscriber::registry()

crates/lib/docs_rs_logging/src/log_format.rs

@@ -1,10 +1,25 @@
-use std::{fmt, str::FromStr};
+use std::{
+    fmt,
+    io::{self, IsTerminal as _},
+    str::FromStr,
+};
 
-#[derive(Debug, Default)]
+#[derive(Debug, Clone, Copy)]
 pub enum LogFormat {
-    Json,
-    #[default]
+    Full,
+    Compact,
     Pretty,
+    Json,
+}
+
+impl Default for LogFormat {
+    fn default() -> Self {
+        if io::stdout().is_terminal() {
+            LogFormat::Compact
+        } else {
+            LogFormat::Json
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -22,10 +37,16 @@ impl FromStr for LogFormat {
     type Err = InvalidLogFormat;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "json" => Ok(Self::Json),
-            "pretty" => Ok(Self::Pretty),
-            _ => Err(InvalidLogFormat(s.to_string())),
+        if s.eq_ignore_ascii_case("full") {
+            Ok(Self::Full)
+        } else if s.eq_ignore_ascii_case("compact") {
+            Ok(Self::Compact)
+        } else if s.eq_ignore_ascii_case("pretty") {
+            Ok(Self::Pretty)
+        } else if s.eq_ignore_ascii_case("json") {
+            Ok(Self::Json)
+        } else {
+            Err(InvalidLogFormat(s.to_string()))
         }
     }
 }

crates/lib/docs_rs_logging/src/testing.rs

@@ -1,8 +1,9 @@
 use std::str::FromStr as _;
-use tracing_subscriber::{EnvFilter, filter::Directive};
+use tracing_subscriber::{EnvFilter, filter::Directive, fmt};
 
 pub fn init() {
     let subscriber = tracing_subscriber::FmtSubscriber::builder()
+        .event_format(fmt::format().compact())
         .with_env_filter(
             EnvFilter::builder()
                 .with_default_directive(Directive::from_str("docs_rs=info").unwrap())