ccc675b cli: Have a way of enabling logging in helper — heartwood

Radicle Heartwood Protocol & Stack

cli: Have a way of enabling logging in helper

cloudhead committed 2 years ago

commit ccc675b304139b783975b1c78c260c6ccc5c840c
parent 55d16ff2ae8e4fbacf4fb0cfe1afed00512bde78

4 files changed +45 -5

modified Cargo.lock

@@ -2613,6 +2613,7 @@ dependencies = [

 name = "radicle-remote-helper"
 version = "0.2.0"
 dependencies = [
  "log",
  "radicle",
  "radicle-cli",
  "radicle-crypto",

modified radicle-remote-helper/Cargo.toml

@@ -7,7 +7,8 @@ edition = "2021"

 build = "../build.rs"
 [dependencies]
 thiserror = "1"
 thiserror = { version = "1" }
 log = { version = "0.4.17" }
 radicle-git-ext = { version = "0.7.0" }
 [dependencies.radicle]

modified radicle-remote-helper/src/git-remote-rad.rs

@@ -10,6 +10,9 @@ pub const GIT_HEAD: &str = env!("GIT_HEAD");

 fn main() {
     let mut args = env::args();
     if let Some(lvl) = radicle::logger::env_level() {
         radicle::logger::set(radicle::logger::StderrLogger::new(lvl), lvl).ok();
     }
     if args.nth(1).as_deref() == Some("--version") {
         if let Err(e) = version::print(std::io::stdout(), NAME, VERSION, GIT_HEAD) {
             eprintln!("error: {e}");

modified radicle/src/logger.rs

@@ -5,13 +5,15 @@

 #[cfg(feature = "test")]
 pub mod test;
 use std::io::{self, Write};
 use std::io;
 use std::io::Write;
 use chrono::prelude::*;
 use colored::*;
 use log::{Level, Log, Metadata, Record, SetLoggerError};
 struct Logger {
 /// A logger that logs to `stdout`.
 pub struct Logger {
     level: Level,
 }

@@ -44,8 +46,38 @@ impl Log for Logger {

                 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 }
     }
 }
             writeln!(io::stdout(), "{message}").expect("write shouldn't fail");
 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");
         }
     }

@@ -54,8 +86,11 @@ impl Log for Logger {

 /// Initialize a new logger.
 pub fn init(level: Level) -> Result<(), SetLoggerError> {
     let logger = Logger { level };
     set(Logger { level }, level)
 }
 /// Set a logger.
 pub fn set(logger: impl Log + 'static, level: Level) -> Result<(), SetLoggerError> {
     log::set_boxed_logger(Box::new(logger))?;
     log::set_max_level(level.to_level_filter());