Slog

.travis.yml

@@ -24,7 +24,7 @@ install:
 # load travis-cargo
 before_script:
   - |
-      cargo install cargo-travis &&
+      (cargo install cargo-travis || true) &&
       export PATH=$HOME/.cargo/bin:$PATH
 
 # the main build

bitcrustd/Cargo.toml

@@ -6,8 +6,8 @@ authors = ["Chris MacNaughton <chris@centaurisolutions.nl>"]
 [dependencies]
 bitcrust-net = {path = "../net"}
 clap = "~2.25"
-simple_logger = "*"
-log = "0.3"
+slog = { version = "1.3.2", features = ["max_level_trace", "release_max_level_info"] }
+slog-term = "1.3.2"
 multiqueue = "~0.3.2"
 ring = "0.12"
 serde_derive = "1.0"

bitcrustd/src/config.rs

@@ -5,9 +5,12 @@ use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use clap::{App, Arg, ArgMatches, SubCommand};
-use log::LogLevel;
+use slog::Level;
 use ring::{digest, rand, hmac};
 use ring::rand::SecureRandom;
+use slog;
+use slog_term;
+use slog::DrainExt;
 use toml;
 
 #[cfg(test)]
@@ -49,18 +52,19 @@ pub struct ConfigFile {
 }
 
 pub struct Config {
-    pub log_level: LogLevel,
+    pub logger: slog::Logger,
+    pub log_level: Level,
     raw_key: [u8; 32],
     signing_key: hmac::SigningKey
 }
 
 impl<'a, 'b> Config {
     pub fn from_args(matches: &ArgMatches) -> Config {
         let log_level = match matches.occurrences_of("debug") {
-            0 => LogLevel::Warn,
-            1 => LogLevel::Info,
-            2 => LogLevel::Debug,
-            3 | _ => LogLevel::Trace,
+            0 => Level::Warning,
+            1 => Level::Info,
+            2 => Level::Debug,
+            3 | _ => Level::Trace,
         };
         let config_file_path: PathBuf = matches.value_of("config").map(|p| PathBuf::from(&p)).unwrap_or_else(|| {
             let mut path = home_dir().expect("Can't figure out where your $HOME is");
@@ -82,6 +86,7 @@ impl<'a, 'b> Config {
         a.copy_from_slice(&config_from_file.key);
 
         Config {
+            logger:  slog::Logger::root(slog_term::streamer().compact().build().fuse(), o!()),
             log_level: log_level,
             raw_key: a,
             signing_key: key,
@@ -148,7 +153,8 @@ impl Clone for Config {
         Config {
             log_level: self.log_level,
             raw_key: self.raw_key,
-            signing_key: hmac::SigningKey::new(&digest::SHA256, &self.raw_key)
+            signing_key: hmac::SigningKey::new(&digest::SHA256, &self.raw_key),
+            logger: self.logger.clone(),
         }
     }
 }

bitcrustd/src/main.rs

@@ -1,9 +1,9 @@
 #[macro_use]
 extern crate clap;
 #[macro_use]
-extern crate log;
+extern crate slog;
+extern crate slog_term;
 extern crate bitcrust_net;
-extern crate simple_logger;
 extern crate multiqueue;
 extern crate ring;
 extern crate rusqlite;
@@ -33,7 +33,7 @@ fn main() {
 
     match matches.subcommand() {
         ("node", Some(node_matches)) => {
-            simple_logger::init_with_level(config.log_level).expect("Couldn't initialize logger");
+            // simple_logger::init_with_level(config.log_level).expect("Couldn't initialize logger");
             node(node_matches, &config);
         }
         ("balance", Some(balance_matches)) => {
@@ -70,7 +70,7 @@ fn stats(matches: &ArgMatches, config: &Config) {
 }
 
 fn connected_peers(_matches: &ArgMatches, config: &Config, host: String) {
-    let connection = BitcoinNetworkConnection::new(host.clone())
+    let connection = BitcoinNetworkConnection::new(host.clone(), &config.logger)
         .expect(&format!("Couldn't connect to a node running on {}", host));
     let _ = connection.try_send(peer::Peer::version());
     loop {
@@ -95,7 +95,7 @@ fn connected_peers(_matches: &ArgMatches, config: &Config, host: String) {
     let auth = AuthenticatedBitcrustMessage::create(config.key());
     match connection.try_send(Message::BitcrustPeerCountRequest(auth)) {
         Ok(_) => {},
-        Err(e) => warn!("Error sending request: {:?}", e),
+        Err(e) => warn!(config.logger, "Error sending request: {:?}", e),
     }
     loop {
         if let Some(msg) = connection.try_recv() {

bitcrustd/src/peer.rs

@@ -8,6 +8,7 @@ use std::str::FromStr;
 use std::time::{UNIX_EPOCH, SystemTime};
 
 use multiqueue::{BroadcastReceiver, BroadcastSender};
+use slog;
 
 use bitcrust_net::{BitcoinNetworkConnection, BitcoinNetworkError, NetAddr, Message, AddrMessage, Services,
                    VersionMessage};
@@ -44,6 +45,7 @@ pub struct Peer {
     closed: bool,
     last_read: Instant,
     thread_speed: Duration,
+    logger: slog::Logger,
 }
 
 impl Debug for Peer {
@@ -79,19 +81,20 @@ impl Peer {
     pub fn new<T: Into<String>>(host: T,
                                 sender: &BroadcastSender<ClientMessage>,
                                 receiver: &BroadcastReceiver<ClientMessage>,
-                                config: &Config)
+                                config: &Config, logger: &slog::Logger)
                                 -> Result<Peer, Error> {
-        Peer::new_with_addrs(host, HashSet::with_capacity(1000), sender, receiver, config)
+        Peer::new_with_addrs(host, HashSet::with_capacity(1000), sender, receiver, config, logger)
     }
 
     pub fn with_stream<T: Into<String>>(host: T,
                                         socket: TcpStream,
                                         sender: &BroadcastSender<ClientMessage>,
                                         receiver: &BroadcastReceiver<ClientMessage>,
-                                        config: &Config) -> Result<Peer, Error> {
+                                        config: &Config, logger: &slog::Logger) -> Result<Peer, Error> {
         let host = host.into();
-        debug!("Initialized incoming peer with host: {}", host);
-        let connection = BitcoinNetworkConnection::with_stream(host.clone(), socket)?;
+        let logger = logger.new(o!("host" => host.clone()));
+        debug!(logger, "Initialized incoming peer with host: {}", host);
+        let connection = BitcoinNetworkConnection::with_stream(host.clone(), socket, &logger)?;
         Ok(Peer {
             config: config.clone(),
             host: host,
@@ -110,17 +113,19 @@ impl Peer {
             last_read: Instant::now(),
             closed: false,
             thread_speed: Duration::from_millis(250),
+            logger: logger,
         })
     }
 
     pub fn new_with_addrs<T: Into<String>>(host: T,
                                            addrs: HashSet<NetAddr>,
                                            sender: &BroadcastSender<ClientMessage>,
                                            receiver: &BroadcastReceiver<ClientMessage>,
-                                           config: &Config)
+                                           config: &Config, logger: &slog::Logger)
                                            -> Result<Peer, Error> {
         let host = host.into();
-        let connection = BitcoinNetworkConnection::new(host.clone())?;
+        let logger = logger.new(o!("host" => host.clone()));
+        let connection = BitcoinNetworkConnection::new(host.clone(), &logger)?;
         Ok(Peer {
             config: config.clone(),
             host: host,
@@ -139,6 +144,7 @@ impl Peer {
             last_read: Instant::now(),
             closed: false,
             thread_speed: Duration::from_millis(250),
+            logger: logger,
         })
     }
 
@@ -152,7 +158,7 @@ impl Peer {
             match message {
                 Message::Version(_) => {}
                 _ => {
-                    debug!("Received {:?} prior to VERSION", message);
+                    debug!(self.logger, "Received {:?} prior to VERSION", message);
                     return;
                 }
             }
@@ -181,7 +187,7 @@ impl Peer {
             }
             Message::FeeFilter(_fee) => {}
             Message::Ping(nonce) => {
-                debug!("[{}] Ping", self.host);
+                debug!(self.logger, "[{}] Ping", self.host);
                 let _ = self.send(Message::Pong(nonce));
             }
             Message::Pong(_nonce) => {}
@@ -215,7 +221,7 @@ impl Peer {
                 // Support for alert messages has been removed from bitcoin core in March 2016.
                 // Read more at https://github.com/bitcoin/bitcoin/pull/7692
                 if name != "alert" {
-                    debug!("{} : Not handling {} yet ({:?})",
+                    debug!(self.logger, "{} : Not handling {} yet ({:?})",
                            self.host,
                            name,
                            to_hex_string(&message))
@@ -227,14 +233,14 @@ impl Peer {
                     let count = self.peers_connected;
                     let _ = self.send(Message::BitcrustPeerCount(count));
                 } else {
-                    warn!("Message: {:?}", msg);
-                    warn!("Invalid authenticated request!");
+                    warn!(self.logger, "Message: {:?}", msg);
+                    warn!(self.logger, "Invalid authenticated request!");
                     self.closed = true;
                 }
             }
             Message::BitcrustPeerCount(_count) => {}
             _ => {
-                debug!("Not handling {:?} yet", message);
+                debug!(self.logger, "Not handling {:?} yet", message);
             }
         };
     }
@@ -265,7 +271,7 @@ impl Peer {
                     };
                     if self.inbound_messages > 0 {
                         if self.bad_messages >= self.inbound_messages * 2 {
-                            warn!("{} sent us {} requests, and {} bad ones",
+                            warn!(self.logger, "{} sent us {} requests, and {} bad ones",
                                   self.host,
                                   self.inbound_messages,
                                   self.bad_messages);