47a440a radicle: expose shared logger — heartwood

modified Cargo.lock

@@ -2354,6 +2354,8 @@ name = "radicle"

 version = "0.2.0"
 dependencies = [
  "amplify",
  "chrono",
  "colored",
  "crossbeam-channel",
  "cyphernet",
  "fastrand",

@@ -2430,6 +2432,7 @@ dependencies = [

  "escargot",
  "log",
  "pretty_assertions",
  "radicle",
  "shlex",
  "snapbox",
  "thiserror",

modified radicle-cli-test/Cargo.toml

@@ -21,3 +21,8 @@ pretty_assertions = { version = "1.3.0" }

 shlex = { version = "1.1.0" }
 snapbox = { version = "0.4.3" }
 thiserror = { version = "1" }
 [dependencies.radicle]
 path = "../radicle"
 version = "0.2.0"
 features = ["logger", "test"]

modified radicle-cli-test/src/lib.rs

@@ -192,6 +192,10 @@ impl TestFormula {

         // We don't need to re-build everytime the `build` function is called. Once is enough.
         BUILD.call_once(|| {
             use escargot::format::Message;
             use radicle::logger::env_level;
             use radicle::logger::test as logger;
             logger::init(env_level().unwrap_or(log::Level::Debug));
             for (package, binary) in binaries {
                 log::debug!(target: "test", "Building binaries for package `{package}`..");

modified radicle-node/Cargo.toml

@@ -42,6 +42,7 @@ thiserror = { version = "1" }

 [dependencies.radicle]
 path = "../radicle"
 version = "0.2.0"
 features = ["logger"]
 [dependencies.radicle-fetch]
 path = "../radicle-fetch"

modified radicle-node/src/lib.rs

@@ -1,7 +1,6 @@

 pub mod bounded;
 pub mod control;
 pub mod deserializer;
 pub mod logger;
 pub mod runtime;
 pub mod service;
 pub mod signals;

deleted radicle-node/src/logger.rs

@@ -1,57 +0,0 @@

 //! Logging module.
 use std::io::{self, Write};
 use chrono::prelude::*;
 use colored::*;
 use log::{Level, Log, Metadata, Record, SetLoggerError};
 struct Logger {
     level: Level,
 }
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
             let target = record.target();
             let message = format!(
                 "{:<5} {:<8} {}",
                 record.level(),
                 target.cyan(),
                 record.args()
             );
             let message = format!(
                 "{} {}",
                 Local::now().to_rfc3339_opts(SecondsFormat::Millis, true),
                 message,
             );
             let message = match record.level() {
                 Level::Error => message.red(),
                 Level::Warn => message.yellow(),
                 Level::Info => message.normal(),
                 Level::Debug => message.dimmed(),
                 Level::Trace => message.white().dimmed(),
             };
             writeln!(io::stdout(), "{message}").expect("write shouldn't fail");
         }
     }
     fn flush(&self) {}
 }
 /// Initialize a new logger.
 pub fn init(level: Level) -> Result<(), SetLoggerError> {
     let logger = Logger { level };
     log::set_boxed_logger(Box::new(logger))?;
     log::set_max_level(level.to_level_filter());
     Ok(())
 }

modified radicle-node/src/main.rs

@@ -4,12 +4,13 @@ use std::{env, fs, net, path::PathBuf, process};

 use anyhow::Context;
 use crossbeam_channel as chan;
 use radicle::logger;
 use radicle::prelude::Signer;
 use radicle::profile;
 use radicle::version;
 use radicle_node::crypto::ssh::keystore::{Keystore, MemorySigner};
 use radicle_node::signals;
 use radicle_node::Runtime;
 use radicle_node::{logger, signals};
 pub const NAME: &str = "radicle-node";
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

modified radicle-node/src/test.rs

@@ -2,9 +2,9 @@ pub mod arbitrary;

 pub mod environment;
 pub mod gossip;
 pub mod handle;
 pub mod logger;
 pub mod peer;
 pub mod simulator;
 pub use radicle::assert_matches;
 pub use radicle::logger::test as logger;
 pub use radicle::test::*;

deleted radicle-node/src/test/logger.rs

@@ -1,58 +0,0 @@

 use localtime::LocalTime;
 use log::*;
 struct Logger {
     level: Level,
 }
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         use colored::Colorize;
         match record.target() {
             "test" => {
                 println!("{} {}", "test:".cyan(), record.args().to_string().cyan())
             }
             "sim" => {
                 println!("{}  {}", "sim:".bold(), record.args().to_string().bold())
             }
             target => {
                 if self.enabled(record.metadata()) {
                     let current = std::thread::current();
                     let msg = format!("{:>10} {}", format!("{target}:"), record.args());
                     let time = LocalTime::now().as_secs();
                     let s = if let Some(name) = current.name() {
                         format!("{time} {name:<16} {msg}")
                     } else {
                         format!("{time} {msg}")
                     };
                     match record.level() {
                         log::Level::Warn => {
                             println!("{}", s.yellow());
                         }
                         log::Level::Error => {
                             println!("{}", s.red());
                         }
                         _ => {
                             println!("{}", s.dimmed());
                         }
                     }
                 }
             }
         }
     }
     fn flush(&self) {}
 }
 #[allow(dead_code)]
 pub fn init(level: Level) {
     let logger = Logger { level };
     log::set_boxed_logger(Box::new(logger)).ok();
     log::set_max_level(level.to_level_filter());
 }

modified radicle/Cargo.toml

@@ -11,6 +11,7 @@ edition = "2021"

 [features]
 default = []
 test = ["qcheck", "radicle-crypto/test"]
 logger = ["colored", "chrono"]
 [dependencies]
 amplify = { version = "4.0.0", default-features = false, features = ["std"] }

@@ -31,6 +32,16 @@ tempfile = { version = "3.3.0" }

 thiserror = { version = "1" }
 unicode-normalization = { version = "0.1" }
 [dependencies.chrono]
 version = "0.4.0"
 default-features = false
 features = ["clock"]
 optional = true
 [dependencies.colored]
 version = "1.9.0"
 optional = true
 [dependencies.git2]
 version = "0.18.1"
 default-features = false

modified radicle/src/lib.rs

@@ -15,6 +15,8 @@ pub mod cob;

 pub mod collections;
 pub mod git;
 pub mod identity;
 #[cfg(feature = "logger")]
 pub mod logger;
 pub mod node;
 pub mod profile;
 pub mod rad;

added radicle/src/logger.rs

@@ -0,0 +1,70 @@

 //! Logging module.
 //!
 //! For test logging see [`test`].
 #[cfg(feature = "test")]
 pub mod test;
 use std::io::{self, Write};
 use chrono::prelude::*;
 use colored::*;
 use log::{Level, Log, Metadata, Record, SetLoggerError};
 struct Logger {
     level: Level,
 }
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
             let target = record.target();
             let message = format!(
                 "{:<5} {:<8} {}",
                 record.level(),
                 target.cyan(),
                 record.args()
             );
             let message = format!(
                 "{} {}",
                 Local::now().to_rfc3339_opts(SecondsFormat::Millis, true),
                 message,
             );
             let message = match record.level() {
                 Level::Error => message.red(),
                 Level::Warn => message.yellow(),
                 Level::Info => message.normal(),
                 Level::Debug => message.dimmed(),
                 Level::Trace => message.white().dimmed(),
             };
             writeln!(io::stdout(), "{message}").expect("write shouldn't fail");
         }
     }
     fn flush(&self) {}
 }
 /// Initialize a new logger.
 pub fn init(level: Level) -> Result<(), SetLoggerError> {
     let logger = Logger { level };
     log::set_boxed_logger(Box::new(logger))?;
     log::set_max_level(level.to_level_filter());
     Ok(())
 }
 /// Get the level set by the environment variable `RUST_LOG`, if
 /// present.
 pub fn env_level() -> Option<Level> {
     let level = std::env::var("RUST_LOG").ok()?;
     level.parse().ok()
 }

added radicle/src/logger/test.rs

@@ -0,0 +1,58 @@

 use localtime::LocalTime;
 use log::*;
 struct Logger {
     level: Level,
 }
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         use colored::Colorize;
         match record.target() {
             "test" => {
                 println!("{} {}", "test:".cyan(), record.args().to_string().cyan())
             }
             "sim" => {
                 println!("{}  {}", "sim:".bold(), record.args().to_string().bold())
             }
             target => {
                 if self.enabled(record.metadata()) {
                     let current = std::thread::current();
                     let msg = format!("{:>10} {}", format!("{target}:"), record.args());
                     let time = LocalTime::now().as_secs();
                     let s = if let Some(name) = current.name() {
                         format!("{time} {name:<16} {msg}")
                     } else {
                         format!("{time} {msg}")
                     };
                     match record.level() {
                         log::Level::Warn => {
                             println!("{}", s.yellow());
                         }
                         log::Level::Error => {
                             println!("{}", s.red());
                         }
                         _ => {
                             println!("{}", s.dimmed());
                         }
                     }
                 }
             }
         }
     }
     fn flush(&self) {}
 }
 #[allow(dead_code)]
 pub fn init(level: Level) {
     let logger = Logger { level };
     log::set_boxed_logger(Box::new(logger)).ok();
     log::set_max_level(level.to_level_filter());
 }