a6f0697 radicle: drop logger.rs and logger/test.rs and replace with radicle-log — heartwood

Radicle Heartwood Protocol & Stack

radicle: drop logger.rs and logger/test.rs and replace with radicle-log

Adrian Duke committed 3 months ago

commit a6f0697a57f226f011bd96eeda20dce9d9aeff96
parent 31e75c3264b50914638f4cf96bf4428141d80ba1

4 files changed +3 -167

modified crates/radicle/Cargo.toml

@@ -12,7 +12,7 @@ rust-version.workspace = true

 [features]
 default = []
 test = ["tempfile", "qcheck", "radicle-crypto/test", "radicle-cob/test"]
 logger = ["colored", "chrono"]
 logger = ["dep:radicle-log"]
 qcheck = [
   "radicle-core/qcheck",
   "dep:qcheck"

@@ -28,8 +28,6 @@ schemars = [

 amplify = { workspace = true, features = ["std"] }
 base64 = "0.21.3"
 bytesize = { version = "2", features = ["serde"] }
 chrono = { workspace = true, features = ["clock"], optional = true }
 colored = { workspace = true, optional = true }
 crossbeam-channel = { workspace = true }
 cyphernet = { workspace = true, features = ["tor", "dns", "p2p-ed25519"] }
 dunce = { workspace = true }

@@ -46,6 +44,7 @@ radicle-core = { workspace = true, features = ["git2", "serde", "sqlite"] }

 radicle-crypto = { workspace = true, features = ["git-ref-format-core", "ssh", "sqlite", "cyphernet"] }
 radicle-git-ref-format = { workspace = true, features = ["macro", "serde"] }
 radicle-localtime = { workspace = true, features = ["serde"] }
 radicle-log = { workspace = true, optional = true }
 radicle-oid = { workspace = true, features = ["git2", "serde", "std", "sha1"] }
 radicle-ssh = { workspace = true }
 schemars = { workspace = true, optional = true, features = ["derive", "std"] }

modified crates/radicle/src/lib.rs

@@ -20,7 +20,7 @@ pub mod git;

 pub mod identity;
 pub mod io;
 #[cfg(feature = "logger")]
 pub mod logger;
 pub use radicle_log as logger;
 pub mod node;
 pub mod profile;
 pub mod rad;

deleted crates/radicle/src/logger.rs

@@ -1,98 +0,0 @@

 //! Logging module.
 //!
 //! For test logging see [`mod@test`].
 #[cfg(feature = "test")]
 pub mod test;
 use std::io;
 use std::io::Write;
 use chrono::prelude::*;
 use colored::*;
 use log::{Level, Log, Metadata, Record};
 /// A logger that logs to `stdout`.
 pub struct Logger {
     level: Level,
 }
 impl Logger {
     pub fn new(level: Level) -> Self {
         Self { 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!(&mut io::stdout(), "{message}").expect("write shouldn't fail");
         }
     }
     fn flush(&self) {}
 }
 /// A logger that logs to `stderr`.
 pub struct StderrLogger {
     level: Level,
 }
 impl StderrLogger {
     pub fn new(level: Level) -> Self {
         Self { level }
     }
 }
 impl Log for StderrLogger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
             let message = format!(
                 "{:<5} {:<8} {}",
                 record.level(),
                 record.target(),
                 record.args()
             );
             writeln!(&mut io::stderr(), "{message}").expect("write shouldn't fail");
         }
     }
     fn flush(&self) {}
 }
 /// 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()
 }

deleted crates/radicle/src/logger/test.rs

@@ -1,65 +0,0 @@

 use localtime::LocalTime;
 use log::*;
 pub struct Logger {
     level: Level,
 }
 impl Logger {
     pub fn new(level: Level) -> Self {
         Self { level }
     }
 }
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata) -> bool {
         metadata.level() <= self.level
     }
     fn log(&self, record: &Record) {
         use colored::Colorize;
         let time = LocalTime::now().as_secs();
         match record.target() {
             "test" => {
                 println!(
                     "{time} {} {}",
                     "test:".cyan(),
                     record.args().to_string().cyan()
                 )
             }
             "sim" => {
                 println!(
                     "{time} {}  {}",
                     "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) {}
 }