feat! change logging to use log/env_logger instead of tracing

We don't use async in Subplot, and the mental overhead of learning
tracing and the code overhead to add support for logging custom
values (implementing the Value trait for Subplot internal types) does
not seem worthwhile.

Sponsored-by: author

1 files changed, 12 insertions, 82 deletions

diff --git a/src/bin/subplot.rs b/src/bin/subplot.rs
index 6028f76..2ad2df1 100644
--- a/src/bin/subplot.rs
+++ b/src/bin/subplot.rs
@@ -3,13 +3,13 @@
 
 use anyhow::Result;
 
+use log::{debug, trace};
 use structopt::StructOpt;
 use subplot::{
     codegen, load_document, load_document_with_pullmark, resource, DataFile, Document, MarkupOpts,
     Style,
 };
 use time::{format_description::FormatItem, macros::format_description, OffsetDateTime};
-use tracing::{event, instrument, span, Level, Subscriber};
 
 use std::convert::TryFrom;
 use std::ffi::OsString;
@@ -39,6 +39,7 @@ struct Toplevel {
 
 impl Toplevel {
     fn run(&self) -> Result<()> {
+        trace!("Toplevel: {:?}", self);
         self.command.run()
     }
 
@@ -161,8 +162,6 @@ impl Extract {
     }
 
     fn run(&self) -> Result<()> {
-        let span = span!(Level::TRACE, "extract");
-        let _enter = span.enter();
         let doc = load_document(&self.filename, Style::default(), None)?;
 
         let files: Vec<&DataFile> = if self.embedded.is_empty() {
@@ -217,8 +216,6 @@ impl Filter {
     }
 
     fn run(&self) -> Result<()> {
-        let span = span!(Level::TRACE, "filter");
-        let _enter = span.enter();
         let mut buffer = String::new();
         if let Some(filename) = &self.input {
             File::open(filename)?.read_to_string(&mut buffer)?;
@@ -267,8 +264,6 @@ impl Metadata {
     }
 
     fn run(&self) -> Result<()> {
-        let span = span!(Level::TRACE, "metadata");
-        let _enter = span.enter();
         let mut doc = load_document_with_pullmark(&self.filename, Style::default(), None)?;
         let meta = cli::Metadata::try_from(&mut doc)?;
         match self.output_format {
@@ -308,21 +303,18 @@ impl Docgen {
         self.input.parent()
     }
 
-    #[instrument(level = "trace", skip(self))]
     fn run(&self) -> Result<()> {
-        let span = span!(Level::TRACE, "docgen");
-        let _enter = span.enter();
         let mut style = Style::default();
         if self.output.extension() == Some(&OsString::from("pdf")) {
-            event!(Level::TRACE, "PDF output chosen");
+            trace!("PDF output chosen");
             style.typeset_links_as_notes();
         }
         let mut doc = load_document(&self.input, style, None)?;
-        event!(Level::TRACE, "Got doc, now linting it");
+        trace!("Got doc, now linting it");
         doc.lint()?;
-        event!(Level::TRACE, "Doc linted ok");
+        trace!("Doc linted ok");
         let meta = doc.meta();
-        event!(Level::TRACE, ?meta, "Looking for template");
+        trace!("Looking for template, meta={:#?}", meta);
         let template = self
             .template
             .as_deref()
@@ -330,7 +322,7 @@ impl Docgen {
             .unwrap_or_else(|| doc.template())
             .unwrap_or("");
         let template = template.to_string();
-        event!(Level::TRACE, ?template);
+        trace!("Template: {:#?}", template);
         if !doc.check_named_files_exist(&template)?
             || !doc.check_matched_steps_have_impl(&template)
             || !doc.check_embedded_files_are_used(&template)?
@@ -437,9 +429,6 @@ impl Codegen {
     }
 
     fn run(&self) -> Result<()> {
-        let span = span!(Level::TRACE, "codegen");
-        let _enter = span.enter();
-
         let output = codegen(&self.filename, &self.output, self.template.as_deref())?;
         if self.run {
             let spec = output
@@ -470,7 +459,7 @@ impl Codegen {
 }
 
 fn real_main() {
-    event!(Level::TRACE, "Starting Subplot");
+    trace!("Starting Subplot");
     let argparser = Toplevel::clap();
     let version = long_version().unwrap();
     let argparser = argparser.long_version(version.as_str());
@@ -479,76 +468,17 @@ fn real_main() {
     args.handle_special_args();
     match args.run() {
         Ok(_) => {
-            event!(Level::TRACE, "Finished successfully");
+            trace!("Subplot finished successfully");
         }
         Err(e) => {
-            event!(Level::DEBUG, error = ?e, "Failed: {:?}", e);
+            debug!("Failed: {:?}", e);
             eprintln!("Failure: {:?}", e);
             process::exit(1);
         }
     }
 }
 
-enum LogFormat {
-    Pretty,
-    OneLine,
-    Json,
-}
-
 fn main() {
-    let filter = match tracing_subscriber::EnvFilter::try_from_env("SUBPLOT_LOG") {
-        Ok(f) => f,
-        Err(e) => {
-            if std::env::var_os("SUBPLOT_LOG").is_none() {
-                // Missing SUBPLOT_LOG, default filter should be INFO
-                tracing_subscriber::EnvFilter::new("info")
-            } else {
-                eprintln!("Unable to parse log directive from SUBPLOT_LOG: {:?}", e);
-                process::exit(1);
-            }
-        }
-    };
-    let format = match std::env::var("SUBPLOT_LOG_FORMAT")
-        .map(|v| v.to_ascii_lowercase())
-        .as_deref()
-    {
-        Err(_) | Ok("oneline") | Ok("default") => LogFormat::OneLine,
-        Ok("pretty") => LogFormat::Pretty,
-        Ok("json") => LogFormat::Json,
-        Ok(v) => {
-            eprintln!("Unknown log format: {:?}", v);
-            process::exit(1);
-        }
-    };
-    match std::env::var("SUBPLOT_LOG_FILE").ok().as_deref() {
-        None | Some("") | Some("-") => {
-            let subscriber = tracing_subscriber::fmt().with_env_filter(filter);
-            let subscriber: Box<dyn Subscriber + Send + Sync + 'static> = match format {
-                LogFormat::OneLine => Box::new(subscriber.finish()),
-                LogFormat::Pretty => Box::new(subscriber.pretty().finish()),
-                LogFormat::Json => Box::new(subscriber.json().with_ansi(false).finish()),
-            };
-            tracing::subscriber::with_default(subscriber, real_main);
-        }
-        Some(fname) => {
-            let curdir = std::path::Component::CurDir;
-            let location = PathBuf::from(fname);
-            let parent = location.parent().unwrap_or_else(|| curdir.as_ref());
-            let fname = location
-                .file_name()
-                .expect("No filename given in SUBPLOT_TRACE_LOG");
-            let appender = tracing_appender::rolling::never(parent, fname);
-            let (non_blocking, _guard) = tracing_appender::non_blocking(appender);
-            let subscriber = tracing_subscriber::fmt()
-                .with_writer(non_blocking)
-                .with_env_filter(filter)
-                .with_ansi(false);
-            let subscriber: Box<dyn Subscriber + Send + Sync + 'static> = match format {
-                LogFormat::OneLine => Box::new(subscriber.finish()),
-                LogFormat::Pretty => Box::new(subscriber.pretty().finish()),
-                LogFormat::Json => Box::new(subscriber.json().finish()),
-            };
-            tracing::subscriber::with_default(subscriber, real_main);
-        }
-    }
+    env_logger::init_from_env("SUBPLOT_LOG");
+    real_main();
 }