Radish alpha
h
heartwood
Radicle Heartwood Protocol & Stack
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
log: New crate for logger implementations
Adrian Duke committed 2 months ago
commit 2eaf8a2d0357f8e1f828b97341260d76b1bdb529
parent 993428df5657e18b167ac0e6206efa0b6908d8c0
20 files changed +225 -184
modified Cargo.lock
@@ -2815,8 +2815,6 @@ dependencies = [
 "amplify",

 "base64 0.21.7",

 "bytesize",
- 
 "chrono",
- 
 "colored",

 "crossbeam-channel",

 "cyphernet",

 "dunce",
@@ -2873,6 +2871,7 @@ dependencies = [
 "radicle-crypto",

 "radicle-git-ref-format",

 "radicle-localtime",
+ 
 "radicle-log",

 "radicle-node",

 "radicle-surf",

 "radicle-term",
@@ -2909,6 +2908,8 @@ dependencies = [
 "log",

 "pretty_assertions",

 "radicle",
+ 
 "radicle-log",
+ 
 "radicle-term",

 "shlex",

 "snapbox",

 "thiserror 2.0.17",
@@ -3045,6 +3046,18 @@ dependencies = [
]



[[package]]
+ 
name = "radicle-log"
+ 
version = "0.1.0"
+ 
dependencies = [
+ 
 "chrono",
+ 
 "colored",
+ 
 "log",
+ 
 "radicle-localtime",
+ 
 "radicle-term",
+ 
 "regex",
+ 
]
+
+ 
[[package]]

name = "radicle-node"

version = "0.16.0"

dependencies = [
@@ -3066,6 +3079,7 @@ dependencies = [
 "radicle-crypto",

 "radicle-fetch",

 "radicle-localtime",
+ 
 "radicle-log",

 "radicle-protocol",

 "radicle-signals",

 "radicle-systemd",
@@ -3131,6 +3145,7 @@ dependencies = [
 "radicle",

 "radicle-cli",

 "radicle-crypto",
+ 
 "radicle-log",

 "thiserror 2.0.17",

]
modified Cargo.toml
@@ -52,6 +52,7 @@ radicle-fetch = { version = "0.16", path = "crates/radicle-fetch" }
radicle-git-metadata = { version = "0.1.0", path = "crates/radicle-git-metadata", default-features = false }

radicle-git-ref-format = { version = "0.1.0", path = "crates/radicle-git-ref-format", default-features = false }

radicle-localtime = { version = "0.1", path = "crates/radicle-localtime" }
+ 
radicle-log = { version = "0.1", path = "crates/radicle-log" }

radicle-node = { version = "0.16", path = "crates/radicle-node" }

radicle-oid = { version = "0.1.0", path = "crates/radicle-oid", default-features = false }

radicle-protocol = { version = "0.4", path = "crates/radicle-protocol" }
modified crates/radicle-cli-test/Cargo.toml
@@ -15,7 +15,9 @@ rust-version.workspace = true
escargot = "0.5.7"

log = { workspace = true, features = ["std"] }

pretty_assertions = { workspace = true }
- 
radicle = { workspace = true, features = ["logger", "test"]}
+ 
radicle = { workspace = true, features = ["test"] }
+ 
radicle-log = { workspace = true, features = ["test"] }
+ 
radicle-term = { workspace = true }

snapbox = { workspace = true }

thiserror = { workspace = true, default-features = true }
modified crates/radicle-cli-test/src/lib.rs
@@ -213,8 +213,11 @@ impl TestFormula {
        // We don't need to re-build every time the `build` function is called. Once is enough.

        BUILD.call_once(|| {

            use escargot::format::Message;
- 
            use radicle::logger::env_level;
- 
            use radicle::logger::test::Logger;
+ 
            use radicle_log::env_level;
+ 
            use radicle_log::test::Logger;
+ 
            use radicle_term::Paint;
+
+ 
            Paint::force(true);



            let level = env_level().unwrap_or(log::Level::Debug);

            let logger = Box::new(Logger::new(level));
modified crates/radicle-cli/Cargo.toml
@@ -23,13 +23,14 @@ human-panic.workspace = true
itertools.workspace = true

log = { workspace = true, features = ["std"] }

nonempty = { workspace = true }
- 
radicle = { workspace = true, features = ["logger", "schemars"] }
+ 
radicle = { workspace = true, features = ["schemars"] }

radicle-cob = { workspace = true }

radicle-crypto = { workspace = true }

radicle-git-ref-format = { workspace = true, features = ["macro"] }

radicle-localtime = { workspace = true }

radicle-surf = { workspace = true }

radicle-term = { workspace = true }
+ 
radicle-log = { workspace = true }

schemars = { workspace = true }

serde = { workspace = true }

serde_json = { workspace = true }
@@ -64,6 +65,7 @@ radicle = { workspace = true, features = ["test"] }
radicle-cli-test = { workspace = true }

radicle-localtime = { workspace = true }

radicle-node = { workspace = true, features = ["test"] }
+ 
radicle-log = { workspace = true, features = ["test"] }



[lints]

workspace = true
modified crates/radicle-cli/src/main.rs
@@ -118,8 +118,8 @@ fn main() {
    .homepage(env!("CARGO_PKG_HOMEPAGE"))

    .support("Open a support request at https://radicle.zulipchat.com/ or file an issue via Radicle itself, or e-mail to team@radicle.xyz"));
- 
    if let Some(lvl) = radicle::logger::env_level() {
- 
        let logger = Box::new(radicle::logger::Logger::new(lvl));
+ 
    if let Some(lvl) = radicle_log::env_level() {
+ 
        let logger = Box::new(radicle_log::Logger::new(lvl));

        log::set_boxed_logger(logger).expect("no other logger should have been set already");

        log::set_max_level(lvl.to_level_filter());

    }
modified crates/radicle-cli/tests/commands.rs
@@ -22,7 +22,7 @@ use radicle::test::fixtures;


use radicle_localtime::LocalTime;

#[allow(unused_imports)]
- 
use radicle_node::test::logger;
+ 
use radicle_log::test::Logger;

use radicle_node::test::node::Node;

use radicle_node::PROTOCOL_VERSION;
added crates/radicle-log/Cargo.toml
@@ -0,0 +1,20 @@
+ 
[package]
+ 
name = "radicle-log"
+ 
description = "Radicle loggers"
+ 
homepage.workspace = true
+ 
repository.workspace = true
+ 
license.workspace = true
+ 
version = "0.1.0"
+ 
edition.workspace = true
+ 
rust-version.workspace = true
+
+ 
[features]
+ 
test = []
+
+ 
[dependencies]
+ 
chrono = { workspace = true, features = ["clock"] }
+ 
colored = { workspace = true }
+ 
radicle-localtime = { workspace = true, features = ["serde"] }
+ 
log = { version = "0.4", features = ["std"] }
+ 
radicle-term = { workspace = true }
+ 
regex = "1"
added crates/radicle-log/src/lib.rs
@@ -0,0 +1,97 @@
+ 
//! Logging module.
+ 
//!
+ 
//! For test logging see [`mod@test`].
+
+ 
#[cfg(feature = "test")]
+ 
pub mod test;
+
+ 
use std::io::{self, 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()
+ 
}
added crates/radicle-log/src/test.rs
@@ -0,0 +1,65 @@
+ 
use log::*;
+ 
use radicle_localtime::LocalTime;
+
+ 
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) {}
+ 
}
modified crates/radicle-node/Cargo.toml
@@ -28,11 +28,12 @@ log = { workspace = true, features = ["kv", "std"] }
mio = { version = "1", features = ["net", "os-poll"] }

nonempty = { workspace = true, features = ["serialize"] }

qcheck = { workspace = true, optional = true }
- 
radicle = { workspace = true, features = ["logger"] }
+ 
radicle = { workspace = true }

radicle-fetch = { workspace = true }

radicle-localtime = { workspace = true }

radicle-protocol = { workspace = true }

radicle-signals = { workspace = true }
+ 
radicle-log = { workspace = true }

sqlite = { workspace = true, features = ["bundled"] }

scrypt = { version = "0.11.0", default-features = false }

serde = { workspace = true, features = ["derive"] }
@@ -55,6 +56,7 @@ mio = { version = "1", features = ["os-ext"] }
qcheck = { workspace = true }

qcheck-macros = { workspace = true }

radicle = { workspace = true, features = ["test"] }
+ 
radicle-log = { workspace = true, features = ["test"] }

radicle-protocol = { workspace = true, features = ["test"] }

radicle-crypto = { workspace = true, features = ["test", "cyphernet"] }

snapbox = { workspace = true }
modified crates/radicle-node/src/main.rs
@@ -378,7 +378,7 @@ fn initialize_logging(options: &LogOptions) -> Result<(), Box<dyn std::error::Er
                const SYSLOG_IDENTIFIER: &str = "radicle-node";

                logger::<&str, &str, _>(SYSLOG_IDENTIFIER.to_string(), []).map_err(Box::new)?

            }
- 
            Logger::Radicle => Box::new(radicle::logger::Logger::new(level)),
+ 
            Logger::Radicle => Box::new(radicle_log::Logger::new(level)),

        }

    };
modified crates/radicle-node/src/test.rs
@@ -5,5 +5,5 @@ pub mod peer;
pub mod simulator;



pub use radicle::assert_matches;
- 
pub use radicle::logger::test as logger;

pub use radicle::test::*;
+ 
pub use radicle_log::test as logger;
modified crates/radicle-protocol/Cargo.toml
@@ -20,7 +20,7 @@ fastrand = { workspace = true }
log = { workspace = true, features = ["std"] }

nonempty = { workspace = true, features = ["serialize"] }

qcheck = { workspace = true, optional = true }
- 
radicle = { workspace = true, features = ["logger"] }
+ 
radicle = { workspace = true }

radicle-core = { workspace = true }

radicle-fetch = { workspace = true }

radicle-localtime = { workspace = true }
modified crates/radicle-remote-helper/Cargo.toml
@@ -19,4 +19,6 @@ log = { workspace = true }
radicle = { workspace = true }

radicle-cli = { workspace = true }

radicle-crypto = { workspace = true }
- 
thiserror = { workspace = true, default-features = true }
 

\ No newline at end of file
+ 
radicle-log = { workspace = true }
+ 
thiserror = { workspace = true, default-features = true }
+
modified crates/radicle-remote-helper/src/main.rs
@@ -45,8 +45,8 @@ pub const VERSION: Version = Version {
fn main() {

    let mut args = env::args();
- 
    if let Some(lvl) = radicle::logger::env_level() {
- 
        let logger = radicle::logger::StderrLogger::new(lvl);
+ 
    if let Some(lvl) = radicle_log::env_level() {
+ 
        let logger = radicle_log::StderrLogger::new(lvl);

        log::set_boxed_logger(Box::new(logger))

            .expect("no other logger should have been set already");

        log::set_max_level(lvl.to_level_filter());
modified crates/radicle/Cargo.toml
@@ -12,7 +12,6 @@ rust-version.workspace = true
[features]

default = []

test = ["tempfile", "qcheck", "radicle-crypto/test", "radicle-cob/test"]
- 
logger = ["colored", "chrono"]

qcheck = [

  "radicle-core/qcheck",

  "dep:qcheck"
@@ -29,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 }
modified crates/radicle/src/lib.rs
@@ -19,8 +19,6 @@ pub mod explorer;
pub mod git;

pub mod identity;

pub mod io;
- 
#[cfg(feature = "logger")]
- 
pub mod 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) {}
- 
}