fix: logs should go to stdout not stderr (#153)

Cargo.toml

@@ -19,7 +19,6 @@ serde = { version = "1.0.126", features = ["derive"], optional = true  }
 serde_json = { version = "1.0.64", optional = true }
 log = { version = "0.4.17", optional = true }
 tabled = { version = "0.9.0", optional = true}
-colog = { version = "1.1.0", optional = true }
 eq-float = "0.1.0"
 thiserror = "1.0.38"
 hex = "0.4.3"
@@ -31,6 +30,10 @@ ethers = "1.0.2"
 ethers-solc = "1.0.2"
 tokio = { version = "1.22.0", features = ["macros"] }
 regex = "1"
+chrono = { version = "0.4.23", optional = true}
+colored = { version = "2.0.0", optional = true}
+env_logger = { version = "0.10.0", optional = true}
+colored_json =  { version = "3.0.1", optional = true}
 
 [dev-dependencies]
 criterion = {version = "0.3",  features = ["html_reports"]}
@@ -69,4 +72,4 @@ default = ["ezkl"]
 render = ["halo2_proofs/dev-graph", "plotters"]
 tensorflow = ["dep:tensorflow"]
 onnx = ["dep:tract-onnx"]
-ezkl = ["onnx", "serde", "serde_json", "log", "colog", "tabled"]
+ezkl = ["onnx", "serde", "serde_json", "log", "chrono", "colored", "env_logger", "tabled", "colored_json"]

benches/affine.rs

@@ -70,7 +70,6 @@ impl<F: FieldExt + TensorType> Circuit<F> for MyCircuit<F> {
 }
 
 fn runaffine(c: &mut Criterion) {
-    colog::init();
     let mut group = c.benchmark_group("affine");
     for &len in [4, 8, 16, 32, 64].iter() {
         unsafe {

benches/cnvrl.rs

@@ -105,7 +105,6 @@ where
 }
 
 fn runcnvrl(c: &mut Criterion) {
-    colog::init();
     let mut group = c.benchmark_group("cnvrl");
 
     for size in [1, 2, 4].iter() {

benches/range.rs

@@ -57,7 +57,6 @@ impl<F: FieldExt + TensorType> Circuit<F> for MyCircuit<F> {
 }
 
 fn runrange(c: &mut Criterion) {
-    colog::init();
     let mut group = c.benchmark_group("range");
     for &len in [4, 8, 16, 32, 64, 128].iter() {
         unsafe {

benches/relu.rs

@@ -51,7 +51,6 @@ impl<F: FieldExt + TensorType> Circuit<F> for NLCircuit<F> {
 }
 
 fn runrelu(c: &mut Criterion) {
-    colog::init();
     let mut group = c.benchmark_group("relu");
 
     let mut rng = rand::thread_rng();

src/bin/ezkl.rs

@@ -1,15 +1,84 @@
+use chrono::Local;
+use colored::*;
+use colored_json::prelude::*;
+use env_logger::Builder;
 use ezkl::commands::Cli;
 use ezkl::execute::run;
-use log::{error, info};
+use log::{error, info, Level, LevelFilter, Record};
 use rand::seq::SliceRandom;
+use std::env;
 use std::error::Error;
+use std::fmt::Formatter;
+use std::io::Write;
+
+#[allow(dead_code)]
+pub fn level_color(level: &log::Level, msg: &str) -> String {
+    match level {
+        Level::Error => msg.red(),
+        Level::Warn => msg.yellow(),
+        Level::Info => msg.green(),
+        Level::Debug => msg.green(),
+        Level::Trace => msg.magenta(),
+    }
+    .bold()
+    .to_string()
+}
+
+fn level_token(level: &Level) -> &str {
+    match *level {
+        Level::Error => "E",
+        Level::Warn => "W",
+        Level::Info => "*",
+        Level::Debug => "D",
+        Level::Trace => "T",
+    }
+}
+
+fn prefix_token(level: &Level) -> String {
+    format!(
+        "{}{}{}",
+        "[".blue().bold(),
+        level_color(level, level_token(level)),
+        "]".blue().bold()
+    )
+}
+
+pub fn format(buf: &mut Formatter, record: &Record<'_>) -> Result<(), std::fmt::Error> {
+    let sep = format!("\n{} ", " | ".white().bold());
+    writeln!(
+        buf,
+        "{} {}",
+        prefix_token(&record.level()),
+        format!("{}", record.args()).replace("\n", &sep),
+    )
+}
+
+pub fn init_logger() {
+    let mut builder = Builder::new();
+    builder.format(|buf, record| {
+        writeln!(
+            buf,
+            "{} [{}, {}] - {}",
+            prefix_token(&record.level()),
+            Local::now().format("%Y-%m-%dT%H:%M:%S"),
+            record.metadata().target(),
+            format!("{}", record.args()).replace("\n", &format!("\n{} ", " | ".white().bold())),
+        )
+    });
+    builder.target(env_logger::Target::Stdout);
+    builder.filter(None, LevelFilter::Info);
+    if env::var("RUST_LOG").is_ok() {
+        builder.parse_filters(&env::var("RUST_LOG").unwrap());
+    }
+    builder.init();
+}
 
 #[tokio::main]
 pub async fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::create().unwrap();
-    colog::init();
+    init_logger();
     banner();
-    info!("{}", &args.as_json()?);
+    info!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
     let res = run(args).await;
     match &res {
         Ok(_) => info!("succeeded"),
@@ -32,6 +101,7 @@ fn banner() {
         "{}",
         format!(
             "
+
         ███████╗███████╗██╗  ██╗██╗
         ██╔════╝╚══███╔╝██║ ██╔╝██║
         █████╗    ███╔╝ █████╔╝ ██║
@@ -42,6 +112,7 @@ fn banner() {
         -----------------------------------------------------------
         Easy Zero Knowledge {}.
         -----------------------------------------------------------
+        
         ",
             ell.choose(&mut rand::thread_rng()).unwrap()
         )

src/eth.rs

@@ -141,12 +141,10 @@ fn derive_key(mnemonic: &str, path: &str, index: u32) -> Result<U256, Bytes> {
         .build()
         .map_err(|err| err.to_string().encode())?;
 
-    info!("Wallet key we use: {:#?}", wallet);
+    info!("wallet address: {:#?}", wallet.address());
 
     let private_key = U256::from_big_endian(wallet.signer().to_bytes().as_slice());
 
-    info!("Private key we use: {:#?}", private_key);
-
     Ok(private_key)
 }