Bump log dependency to version 0.4. NFC.

This doesn't affect downstream code because log 0.3.9 is a facade
crate implemented in terms of log 0.4, and so log 0.3 and log 0.4
APIs can be used together.

Cargo.toml

@@ -17,12 +17,12 @@ autoexamples = false
 [dependencies]
 managed = { version = "0.7", default-features = false, features = ["map"] }
 byteorder = { version = "1.0", default-features = false }
-log = { version = "0.3", default-features = false, optional = true }
+log = { version = "0.4", default-features = false, optional = true }
 libc = { version = "0.2.18", optional = true }
 bitflags = { version = "1.0", default-features = false }
 
 [dev-dependencies]
-env_logger = "0.4"
+env_logger = "0.5"
 getopts = "0.2"
 rand = "0.3"
 url = "1.0"

examples/utils.rs

@@ -3,15 +3,15 @@
 use std::cell::RefCell;
 use std::str::{self, FromStr};
 use std::rc::Rc;
-use std::io;
+use std::io::{self, Write};
 use std::fs::File;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::env;
 use std::process;
 #[cfg(feature = "log")]
-use log::{LogLevel, LogLevelFilter, LogRecord};
+use log::{Level, LevelFilter};
 #[cfg(feature = "log")]
-use env_logger::LogBuilder;
+use env_logger::Builder;
 use getopts::{Options, Matches};
 
 use smoltcp::phy::{Device, EthernetTracer, FaultInjector};
@@ -24,27 +24,26 @@ use smoltcp::time::{Duration, Instant};
 #[cfg(feature = "log")]
 pub fn setup_logging_with_clock<F>(filter: &str, since_startup: F)
         where F: Fn() -> Instant + Send + Sync + 'static {
-    LogBuilder::new()
-        .format(move |record: &LogRecord| {
+    Builder::new()
+        .format(move |buf, record| {
             let elapsed = since_startup();
             let timestamp = format!("[{}]", elapsed);
             if record.target().starts_with("smoltcp::") {
-                format!("\x1b[0m{} ({}): {}\x1b[0m", timestamp,
-                        record.target().replace("smoltcp::", ""), record.args())
-            } else if record.level() == LogLevel::Trace {
+                writeln!(buf, "\x1b[0m{} ({}): {}\x1b[0m", timestamp,
+                         record.target().replace("smoltcp::", ""), record.args())
+            } else if record.level() == Level::Trace {
                 let message = format!("{}", record.args());
-                format!("\x1b[37m{} {}\x1b[0m", timestamp,
-                        message.replace("\n", "\n             "))
+                writeln!(buf, "\x1b[37m{} {}\x1b[0m", timestamp,
+                         message.replace("\n", "\n             "))
             } else {
-                format!("\x1b[32m{} ({}): {}\x1b[0m", timestamp,
-                        record.target(), record.args())
+                writeln!(buf, "\x1b[32m{} ({}): {}\x1b[0m", timestamp,
+                         record.target(), record.args())
             }
         })
-        .filter(None, LogLevelFilter::Trace)
+        .filter(None, LevelFilter::Trace)
         .parse(filter)
         .parse(&env::var("RUST_LOG").unwrap_or("".to_owned()))
-        .init()
-        .unwrap();
+        .init();
 }
 
 #[cfg(feature = "log")]

src/socket/tcp.rs

@@ -1816,24 +1816,25 @@ mod test {
     #[cfg(feature = "log")]
     fn init_logger() {
         extern crate log;
-        use std::boxed::Box;
 
-        struct Logger(());
+        struct Logger;
+        static LOGGER: Logger = Logger;
 
         impl log::Log for Logger {
-            fn enabled(&self, _metadata: &log::LogMetadata) -> bool {
+            fn enabled(&self, _metadata: &log::Metadata) -> bool {
                 true
             }
 
-            fn log(&self, record: &log::LogRecord) {
+            fn log(&self, record: &log::Record) {
                 println!("{}", record.args());
             }
+
+            fn flush(&self) {
+            }
         }
 
-        let _ = log::set_logger(|max_level| {
-            max_level.set(log::LogLevelFilter::Trace);
-            Box::new(Logger(()))
-        });
+        log::set_logger(&LOGGER).unwrap();
+        log::set_max_level(log::LevelFilter::Trace);
 
         println!("");
     }