refactor: Replace debugln! macro with log crate

Migrate all `debugln!` calls to `log::debug!` and remove the
old debug infrastructure (`ENABLE_DEBUG`, `--debug` flag, and
`debugln!` macro definitions). Debug output is now controlled
via the `-v/-vv/-vvv` verbosity levels introduced in the
previous commit.

Author: febyeji

src/cli.rs

@@ -29,7 +29,7 @@ use crate::diagnostic::{Diagnostics, Warnings};
 use crate::error::*;
 use crate::lockfile::*;
 use crate::sess::{Session, SessionArenas, SessionIo};
-use crate::{debugln, fmt_path, fmt_pkg, stageln};
+use crate::{fmt_path, fmt_pkg, stageln};
 
 #[derive(Parser, Debug)]
 #[command(name = "bender")]
@@ -84,16 +84,6 @@ struct Cli {
     )]
     verbose: u8,
 
-    /// Print additional debug information
-    #[cfg(debug_assertions)]
-    #[arg(
-        long,
-        global = true,
-        help_heading = "Global Options",
-        env = "BENDER_DEBUG"
-    )]
-    debug: bool,
-
     #[command(subcommand)]
     command: Commands,
 }
@@ -170,11 +160,6 @@ pub fn main() -> Result<()> {
     // Initialize warning and error handling with the suppression arguments.
     Diagnostics::init(suppressed_warnings);
 
-    #[cfg(debug_assertions)]
-    if cli.debug {
-        ENABLE_DEBUG.store(true, std::sync::atomic::Ordering::Relaxed);
-    }
-
     // Handle commands that do not require a session.
     match &cli.command {
         Commands::Completion(args) => {
@@ -202,16 +187,16 @@ pub fn main() -> Result<()> {
         None => find_package_root(Path::new("."))
             .map_err(|cause| Error::chain("Cannot find root directory of package.", cause))?,
     };
-    debugln!("main: root dir {:?}", root_dir);
+    log::debug!("root dir {:?}", root_dir);
 
     // Parse the manifest file of the package.
     let manifest_path = root_dir.join("Bender.yml");
     let manifest = read_manifest(&manifest_path)?;
-    debugln!("main: {:#?}", manifest);
+    log::debug!("{:#?}", manifest);
 
     // Gather and parse the tool configuration.
     let config = load_config(&root_dir, matches!(cli.command, Commands::Update(_)))?;
-    debugln!("main: {:#?}", config);
+    log::debug!("{:#?}", config);
 
     // Determine git throttle. The precedence is: CLI argument, env variable, config file, default (4).
     let git_throttle = cli.git_throttle.or(config.git_throttle).unwrap_or(4);
@@ -251,7 +236,7 @@ pub fn main() -> Result<()> {
             cmd::update::run_plain(false, &sess, locked_existing.as_ref(), IndexSet::new())?
         }
         _ => {
-            debugln!("main: lockfile {:?} up-to-date", lock_path);
+            log::debug!("lockfile {:?} up-to-date", lock_path);
             (locked_existing.unwrap(), Vec::new())
         }
     };
@@ -262,7 +247,7 @@ pub fn main() -> Result<()> {
     {
         let io = SessionIo::new(&sess);
         for (path, pkg_name) in &sess.manifest.workspace.package_links {
-            debugln!("main: maintaining link to {} at {:?}", pkg_name, path);
+            log::debug!("maintaining link to {} at {:?}", pkg_name, path);
 
             // Determine the checkout path for this package.
             let pkg_path = io.get_package_path(sess.dependency_with_name(pkg_name)?);
@@ -293,7 +278,7 @@ pub fn main() -> Result<()> {
                     continue;
                 }
                 if path.read_link().map(|d| d != pkg_path).unwrap_or(true) {
-                    debugln!("main: removing existing link {:?}", path);
+                    log::debug!("removing existing link {:?}", path);
                     remove_symlink_dir(path).map_err(|cause| {
                         Error::chain(
                             format!("Failed to remove symlink at path {:?}.", path),
@@ -400,18 +385,18 @@ fn find_package_root(from: &Path) -> Result<PathBuf> {
     // Canonicalize the path. This will resolve any intermediate links.
     let mut path = canonicalize(from)
         .map_err(|cause| Error::chain(format!("Failed to canonicalize path {:?}.", from), cause))?;
-    debugln!("find_package_root: canonicalized to {:?}", path);
+    log::debug!("canonicalized to {:?}", path);
 
     // Look up the device at the current path. This information will then be
     // used to stop at filesystem boundaries.
     #[cfg(unix)]
     let limit_rdev: Option<_> = metadata(&path).map(|m| m.dev()).ok();
     #[cfg(unix)]
-    debugln!("find_package_root: limit rdev = {:?}", limit_rdev);
+    log::debug!("limit rdev = {:?}", limit_rdev);
 
     // Step upwards through the path hierarchy.
     for _ in 0..100 {
-        debugln!("find_package_root: looking in {:?}", path);
+        log::debug!("looking in {:?}", path);
 
         // Check if we can find a package manifest here.
         if path.join("Bender.yml").exists() {
@@ -430,7 +415,7 @@ fn find_package_root(from: &Path) -> Result<PathBuf> {
         #[cfg(unix)]
         {
             let rdev: Option<_> = metadata(&path).map(|m| m.dev()).ok();
-            debugln!("find_package_root: rdev = {:?}", rdev);
+            log::debug!("rdev = {:?}", rdev);
             if rdev != limit_rdev {
                 return Err(Error::new(format!(
                     "No manifest (`Bender.yml` file) found. Stopped searching at filesystem boundary {:?}.",
@@ -449,7 +434,7 @@ fn find_package_root(from: &Path) -> Result<PathBuf> {
 pub fn read_manifest(path: &Path) -> Result<Manifest> {
     use crate::config::PartialManifest;
     use std::fs::File;
-    debugln!("read_manifest: {:?}", path);
+    log::debug!("reading manifest {:?}", path);
     let file = File::open(path)
         .map_err(|cause| Error::chain(format!("Cannot open manifest {:?}.", path), cause))?;
     let partial: PartialManifest = serde_yaml_ng::from_reader(file)
@@ -471,14 +456,14 @@ fn load_config(from: &Path, warn_config_loaded: bool) -> Result<Config> {
     // Canonicalize the path. This will resolve any intermediate links.
     let mut path = canonicalize(from)
         .map_err(|cause| Error::chain(format!("Failed to canonicalize path {:?}.", from), cause))?;
-    debugln!("load_config: canonicalized to {:?}", path);
+    log::debug!("canonicalized to {:?}", path);
 
     // Look up the device at the current path. This information will then be
     // used to stop at filesystem boundaries.
     #[cfg(unix)]
     let limit_rdev: Option<_> = metadata(&path).map(|m| m.dev()).ok();
     #[cfg(unix)]
-    debugln!("load_config: limit rdev = {:?}", limit_rdev);
+    log::debug!("limit rdev = {:?}", limit_rdev);
 
     // Step upwards through the path hierarchy.
     for _ in 0..100 {
@@ -487,7 +472,7 @@ fn load_config(from: &Path, warn_config_loaded: bool) -> Result<Config> {
             out = out.merge(cfg);
         }
 
-        debugln!("load_config: looking in {:?}", path);
+        log::debug!("looking in {:?}", path);
 
         if let Some(cfg) = maybe_load_config(&path.join(".bender.yml"), warn_config_loaded)? {
             out = out.merge(cfg);
@@ -502,7 +487,7 @@ fn load_config(from: &Path, warn_config_loaded: bool) -> Result<Config> {
         #[cfg(unix)]
         {
             let rdev: Option<_> = metadata(&path).map(|m| m.dev()).ok();
-            debugln!("load_config: rdev = {:?}", rdev);
+            log::debug!("rdev = {:?}", rdev);
             if rdev != limit_rdev {
                 break;
             }
@@ -551,7 +536,7 @@ fn load_config(from: &Path, warn_config_loaded: bool) -> Result<Config> {
 /// Load a configuration file if it exists.
 fn maybe_load_config(path: &Path, warn_config_loaded: bool) -> Result<Option<PartialConfig>> {
     use std::fs::File;
-    debugln!("maybe_load_config: {:?}", path);
+    log::debug!("maybe loading config {:?}", path);
     if !path.exists() {
         return Ok(None);
     }
@@ -570,7 +555,7 @@ fn maybe_load_config(path: &Path, warn_config_loaded: bool) -> Result<Option<Par
 
 /// Execute a plugin.
 fn execute_plugin(sess: &Session, plugin: &str, args: &[String]) -> Result<()> {
-    debugln!("main: execute plugin `{}`", plugin);
+    log::debug!("execute plugin `{}`", plugin);
 
     // Obtain a list of declared plugins.
     let runtime = Runtime::new()?;
@@ -582,7 +567,7 @@ fn execute_plugin(sess: &Session, plugin: &str, args: &[String]) -> Result<()> {
         Some(p) => p,
         None => return Err(Error::new(format!("Unknown command `{}`.", plugin))),
     };
-    debugln!("main: found plugin {:#?}", plugin);
+    log::debug!("found plugin {:#?}", plugin);
 
     // Assemble a command that executes the plugin with the appropriate
     // environment and forwards command line arguments.
@@ -601,7 +586,7 @@ fn execute_plugin(sess: &Session, plugin: &str, args: &[String]) -> Result<()> {
     cmd.current_dir(sess.root);
     cmd.args(args);
 
-    debugln!("main: executing plugin {:#?}", cmd);
+    log::debug!("executing plugin {:#?}", cmd);
     let stat = cmd.status().map_err(|cause| {
         Error::chain(
             format!(

src/cmd/clone.rs

@@ -16,7 +16,7 @@ use crate::config::{Locked, LockedSource};
 use crate::diagnostic::Warnings;
 use crate::error::*;
 use crate::sess::{DependencyRef, DependencySource, Session, SessionIo};
-use crate::{debugln, fmt_path, fmt_pkg, stageln};
+use crate::{fmt_path, fmt_pkg, stageln};
 
 /// Clone dependency to a working directory
 #[derive(Args, Debug)]
@@ -82,9 +82,9 @@ pub fn run(sess: &Session, path: &Path, args: &CloneArgs) -> Result<()> {
         eprintln!("Please manually ensure the correct checkout.");
     } else {
         let id = sess.dependency_with_name(&args.name.to_lowercase())?;
-        debugln!("main: obtain checkout {:?}", id);
+        log::debug!("obtain checkout {:?}", id);
         let checkout = rt.block_on(io.checkout(id, false, &[]))?;
-        debugln!("main: checkout {:#?}", checkout);
+        log::debug!("checkout {:#?}", checkout);
         if let Some(s) = checkout.to_str() {
             if !Path::new(s).exists() {
                 Err(Error::new(format!("`{dep}` path `{s}` does not exist")))?;
@@ -247,7 +247,7 @@ pub fn run(sess: &Session, path: &Path, args: &CloneArgs) -> Result<()> {
     // Update any possible workspace symlinks
     for (link_path, pkg_name) in &sess.manifest.workspace.package_links {
         if pkg_name == dep {
-            debugln!("main: maintaining link to {} at {:?}", pkg_name, link_path);
+            log::debug!("maintaining link to {} at {:?}", pkg_name, link_path);
 
             // Determine the checkout path for this package.
             let pkg_path = &path.join(path_mod).join(dep);
@@ -270,7 +270,7 @@ pub fn run(sess: &Session, path: &Path, args: &CloneArgs) -> Result<()> {
                     continue;
                 }
                 if link_path.read_link().map(|d| d != pkg_path).unwrap_or(true) {
-                    debugln!("main: removing existing link {:?}", link_path);
+                    log::debug!("removing existing link {:?}", link_path);
                     remove_symlink_dir(link_path).map_err(|cause| {
                         Error::chain(
                             format!("Failed to remove symlink at path {:?}.", link_path),

src/cmd/path.rs

@@ -9,7 +9,6 @@ use clap::Args;
 use futures::future::join_all;
 use tokio::runtime::Runtime;
 
-use crate::debugln;
 use crate::error::*;
 use crate::sess::{Session, SessionIo};
 
@@ -43,7 +42,7 @@ pub fn run(sess: &Session, args: &PathArgs) -> Result<()> {
 
     // Check out if requested or not done yet
     if args.checkout || !paths.iter().all(|p| p.exists()) {
-        debugln!("main: obtain checkouts {:?}", ids);
+        log::debug!("obtain checkouts {:?}", ids);
         let rt = Runtime::new()?;
         let _checkouts = rt
             .block_on(join_all(
@@ -53,7 +52,7 @@ pub fn run(sess: &Session, args: &PathArgs) -> Result<()> {
             ))
             .into_iter()
             .collect::<Result<Vec<_>>>()?;
-        debugln!("main: checkouts {:#?}", _checkouts);
+        log::debug!("checkouts {:#?}", _checkouts);
     }
 
     // Print paths

src/cmd/snapshot.rs

@@ -16,7 +16,7 @@ use crate::config::{Dependency, Locked, LockedSource};
 use crate::diagnostic::Warnings;
 use crate::error::*;
 use crate::sess::{DependencySource, Session, SessionIo};
-use crate::{debugln, fmt_path, fmt_pkg, stageln};
+use crate::{fmt_path, fmt_pkg, stageln};
 
 /// Snapshot the cloned IPs from the working directory into the Bender.lock file
 #[derive(Args, Debug)]
@@ -224,7 +224,7 @@ pub fn run(sess: &Session, args: &SnapshotArgs) -> Result<()> {
     // Update any possible workspace symlinks
     for (link_path, pkg_name) in &sess.manifest.workspace.package_links {
         if updated_deps.contains(&pkg_name.as_str()) {
-            debugln!("main: maintaining link to {} at {:?}", pkg_name, link_path);
+            log::debug!("maintaining link to {} at {:?}", pkg_name, link_path);
 
             // Determine the checkout path for this package.
             let pkg_path = if snapshotted_deps.contains(&pkg_name.as_str()) {
@@ -262,7 +262,7 @@ pub fn run(sess: &Session, args: &SnapshotArgs) -> Result<()> {
                     continue;
                 }
                 if link_path.read_link().map(|d| d != pkg_path).unwrap_or(true) {
-                    debugln!("main: removing existing link {:?}", link_path);
+                    log::debug!("removing existing link {:?}", link_path);
                     remove_symlink_dir(link_path).map_err(|cause| {
                         Error::chain(
                             format!("Failed to remove symlink at path {:?}.", link_path),

src/cmd/update.rs

@@ -12,7 +12,6 @@ use tabwriter::TabWriter;
 
 use crate::cmd;
 use crate::config::{Locked, LockedPackage};
-use crate::debugln;
 use crate::diagnostic::Warnings;
 use crate::error::*;
 use crate::lockfile::*;
@@ -121,8 +120,8 @@ pub fn run_plain<'ctx>(
             sess.root.join("Bender.yml")
         )));
     }
-    debugln!(
-        "main: lockfile {:?} outdated",
+    log::debug!(
+        "lockfile {:?} outdated",
         sess.root.join("Bender.lock")
     );
 

src/error.rs

@@ -6,12 +6,9 @@
 use std;
 use std::fmt;
 use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
 
 use owo_colors::Style;
 
-pub static ENABLE_DEBUG: AtomicBool = AtomicBool::new(false);
-
 /// Print an error.
 #[macro_export]
 macro_rules! errorln {
@@ -24,30 +21,12 @@ macro_rules! infoln {
     ($($arg:tt)*) => { $crate::diagnostic!($crate::error::Severity::Info; $($arg)*); }
 }
 
-/// Print debug information. Omitted in release builds.
-#[macro_export]
-#[cfg(debug_assertions)]
-macro_rules! debugln {
-    ($($arg:tt)*) => {
-        if $crate::error::ENABLE_DEBUG.load(std::sync::atomic::Ordering::Relaxed) {
-            $crate::diagnostic!($crate::error::Severity::Debug; $($arg)*);
-        }
-    }
-}
-
 /// Format and print stage progress.
 #[macro_export]
 macro_rules! stageln {
     ($stage_name:expr, $($arg:tt)*) => { $crate::diagnostic!($crate::error::Severity::Stage($stage_name); $($arg)*); }
 }
 
-/// Print debug information. Omitted in release builds.
-#[macro_export]
-#[cfg(not(debug_assertions))]
-macro_rules! debugln {
-    ($($arg:tt)*) => {};
-}
-
 /// Emit a diagnostic message.
 #[macro_export]
 macro_rules! diagnostic {
@@ -59,7 +38,6 @@ macro_rules! diagnostic {
 /// The severity of a diagnostic message.
 #[derive(PartialEq, Eq)]
 pub enum Severity {
-    Debug,
     Info,
     Error,
     Stage(&'static str),
@@ -70,7 +48,6 @@ impl fmt::Display for Severity {
         let (severity, style) = match *self {
             Severity::Error => ("Error:", Style::new().red().bold()),
             Severity::Info => ("Info:", Style::new().white().bold()),
-            Severity::Debug => ("Debug:", Style::new().blue().bold()),
             Severity::Stage(name) => (name, Style::new().green().bold()),
         };
         write!(f, "{:>14}", crate::fmt_with_style!(severity, style))

src/git.rs

@@ -18,7 +18,6 @@ use walkdir::WalkDir;
 
 use crate::progress::{ProgressHandler, monitor_stderr};
 
-use crate::debugln;
 use crate::error::*;
 
 /// A git repository.
@@ -101,8 +100,6 @@ impl<'ctx> Git<'ctx> {
             }
         })?;
 
-        debugln!("git: {:?} in {:?}", cmd, self.path);
-
         // Setup Streaming for Stderr (Progress + Error Collection)
         // We need to capture stderr in case the command fails, so we collect it while parsing.
         let stderr = child.stderr.take().unwrap();