Add log feature

Author: dhardy

.travis.yml

@@ -28,7 +28,7 @@ matrix:
 script:
   - cargo test
   - cargo test --tests --no-default-features
-  - cargo test --features serde-1
+  - cargo test --features serde-1,log
   - cargo test --tests --no-default-features --features=serde-1
   - cargo test --manifest-path rand-derive/Cargo.toml
 

Cargo.toml

@@ -32,6 +32,8 @@ libc = { version = "0.2", optional = true }
 winapi = { version = "0.3", features = ["minwindef", "ntsecapi", "profileapi", "winnt"], optional = true }
 
 [dependencies]
+log = { version = "0.4", optional = true }
+
 serde = {version="1",optional=true}
 serde_derive = {version="1", optional=true}
 

README.md

@@ -33,8 +33,7 @@ changes since the `0.3` series, but nevertheless contains some significant
 new code, including a new "external" entropy source (`JitterRng`) and `no_std`
 support.
 
-Version `0.5` is in development and contains significant performance
-improvements for the ISAAC random number generators.
+Version `0.5` is in development and will contain significant breaking changes.
 
 ## Examples
 
@@ -68,21 +67,22 @@ println!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())
 By default, `rand` is built with all stable features available. The following
 optional features are available:
 
+-   `alloc` can be used instead of `std` to provide `Vec` and `Box`
 -   `i128_support` enables support for generating `u128` and `i128` values
+-   `log` enables some logging via the `log` crate
 -   `nightly` enables all unstable features (`i128_support`)
+-   `serde-1` enables serialisation for some types, via Serde version 1
 -   `std` enabled by default; by setting "default-features = false" `no_std`
     mode is activated; this removes features depending on `std` functionality:
-
-        -   `OsRng` is entirely unavailable
-        -   `JitterRng` code is still present, but a nanosecond timer must be
-            provided via `JitterRng::new_with_timer`
-        -   Since no external entropy is available, it is not possible to create
-            generators with fresh seeds (user must provide entropy)
-        -   `thread_rng`, `weak_rng` and `random` are all disabled
-        -   exponential, normal and gamma type distributions are unavailable
-            since `exp` and `log` functions are not provided in `core`
-        -   any code requiring `Vec` or `Box`
--   `alloc` can be used instead of `std` to provide `Vec` and `Box`
+    -   `OsRng` is entirely unavailable
+    -   `JitterRng` code is still present, but a nanosecond timer must be
+        provided via `JitterRng::new_with_timer`
+    -   Since no external entropy is available, it is not possible to create
+        generators with fresh seeds (user must provide entropy)
+    -   `thread_rng`, `weak_rng` and `random` are all disabled
+    -   exponential, normal and gamma type distributions are unavailable
+        since `exp` and `log` functions are not provided in `core`
+    -   any code requiring `Vec` or `Box`
 
 ## Testing
 

src/lib.rs

@@ -249,10 +249,16 @@
 
 #[cfg(feature="std")] extern crate std as core;
 #[cfg(all(feature = "alloc", not(feature="std")))] extern crate alloc;
+
 #[cfg(test)] #[cfg(feature="serde-1")] extern crate bincode;
 #[cfg(feature="serde-1")] extern crate serde;
 #[cfg(feature="serde-1")] #[macro_use] extern crate serde_derive;
 
+#[cfg(feature = "log")] #[macro_use] extern crate log;
+#[cfg(not(feature = "log"))] macro_rules! trace { ($($x:tt)*) => () }
+#[cfg(all(feature="std", not(feature = "log")))] macro_rules! warn { ($($x:tt)*) => () }
+
+
 use core::{marker, mem};
 #[cfg(feature="std")] use std::cell::RefCell;
 #[cfg(feature="std")] use std::rc::Rc;
@@ -846,9 +852,11 @@ impl<R: SeedableRng> NewRng for R {
             T::from_rng(&mut r)
         }
 
+        trace!("Seeding new RNG");
         new_os().or_else(|e1| {
+            warn!("OsRng failed [falling back to JitterRng]: {:?}", e1);
             new_jitter().map_err(|_e2| {
-                // TODO: log
+                warn!("JitterRng failed: {:?}", _e2);
                 // TODO: can we somehow return both error sources?
                 Error::with_cause(
                     ErrorKind::Unavailable,

src/os.rs

@@ -69,23 +69,35 @@ impl Rng for OsRng {
         const MAX_WAIT: u32 = (10 * 1000) / WAIT_DUR_MS;    // max 10s
         const TRANSIENT_STEP: u32 = MAX_WAIT / 8;
         let mut err_count = 0;
+        let mut log_err = 0;    // log when err_count >= log_err
 
         loop {
             if let Err(e) = self.try_fill_bytes(dest) {
-                // TODO: add logging to explain why we wait and the full cause
+                if log_err == 0 {
+                    warn!("OsRng failed: {:?}", e);
+                }
+                
                 if e.kind().should_retry() {
                     if err_count > MAX_WAIT {
                         panic!("Too many RNG errors or timeout; last error: {}", e.msg());
                     }
 
                     if e.kind().should_wait() {
+                        err_count += 1;
+                        if err_count >= log_err {
+                            log_err += TRANSIENT_STEP;
+                            warn!("OsRng: waiting and retrying ...");
+                        }
                         #[cfg(feature="std")]{
                             let dur = ::std::time::Duration::from_millis(WAIT_DUR_MS as u64);
                             ::std::thread::sleep(dur);
                         }
-                        err_count += 1;
                     } else {
                         err_count += TRANSIENT_STEP;
+                        if err_count >= log_err {
+                            log_err += TRANSIENT_STEP;
+                            warn!("OsRng: retrying ...");
+                        }
                     }
 
                     continue;

src/reseeding.rs

@@ -47,6 +47,7 @@ impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr> {
     /// generated exceed the threshold.
     pub fn reseed_if_necessary(&mut self) {
         if self.bytes_generated >= self.generation_threshold {
+            trace!("Reseeding RNG");
             self.reseeder.reseed(&mut self.rng).unwrap();
             self.bytes_generated = 0;
         }