log crate only enabled on debug builds

Author: elast0ny

Cargo.toml

@@ -22,9 +22,7 @@ categories = [
 exclude = ["ci/*", ".github/*"]
 
 [features]
-default = []
-# Logging feature enables debug logs through the log crate
-logging = ["log"]
+default = ["log/release_max_level_off"]
 
 [dependencies]
 cfg-if = "1.0"
@@ -50,4 +48,3 @@ winapi = { version = "0.3", features = [
 raw_sync = "0.1"
 clap = "2.33"
 env_logger = "0"
-log = "0"

examples/basic.rs

@@ -1,12 +1,10 @@
 use std::thread;
 
 use clap::{App, Arg};
-use env_logger::Env;
-use log::*;
 use shared_memory::*;
 
 fn main() {
-    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
+    env_logger::init();
 
     // Get number of thread argument
     let matches = App::new("Basic Example")
@@ -24,7 +22,7 @@ fn main() {
         .parse()
         .expect("Invalid number passed for num_threads");
     if num_threads < 1 {
-        error!("Invalid number of threads");
+        eprintln!("Invalid number of threads");
         return;
     }
 
@@ -52,7 +50,7 @@ fn increment_value(shmem_flink: &str, thread_num: usize) {
         Ok(m) => m,
         Err(ShmemError::LinkExists) => ShmemConf::new().flink(shmem_flink).open().unwrap(),
         Err(e) => {
-            info!(
+            eprintln!(
                 "Unable to create or open shmem flink {} : {}",
                 shmem_flink, e
             );
@@ -69,7 +67,7 @@ fn increment_value(shmem_flink: &str, thread_num: usize) {
             // Increment shared value by one
             *raw_ptr += 1;
 
-            info!(
+            println!(
                 "[thread:{}] {}",
                 thread_num,
                 std::ptr::read_volatile(raw_ptr)

examples/event.rs

@@ -1,11 +1,10 @@
-use log::*;
 use raw_sync::{events::*, Timeout};
 use shared_memory::*;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     env_logger::init();
     // Attempt to create a mapping or open if it already exists
-    info!("Getting the shared memory mapping");
+    println!("Getting the shared memory mapping");
     let shmem = match ShmemConf::new().size(4096).flink("event_mapping").create() {
         Ok(m) => m,
         Err(ShmemError::LinkExists) => ShmemConf::new().flink("event_mapping").open()?,
@@ -14,24 +13,24 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     if shmem.is_owner() {
         //Create an event in the shared memory
-        info!("Creating event in shared memory");
+        println!("Creating event in shared memory");
         let (evt, used_bytes) = unsafe { Event::new(shmem.as_ptr(), true)? };
-        info!("\tUsed {} bytes", used_bytes);
+        println!("\tUsed {} bytes", used_bytes);
 
-        info!("Launch another instance of this example to signal the event !");
+        println!("Launch another instance of this example to signal the event !");
         evt.wait(Timeout::Infinite)?;
-        info!("\tGot signal !");
+        println!("\tGot signal !");
     } else {
         // Open existing event
-        info!("Openning event from shared memory");
+        println!("Openning event from shared memory");
         let (evt, used_bytes) = unsafe { Event::from_existing(shmem.as_ptr())? };
-        info!("\tEvent uses {} bytes", used_bytes);
+        println!("\tEvent uses {} bytes", used_bytes);
 
-        info!("Signaling event !");
+        println!("Signaling event !");
         evt.set(EventState::Signaled)?;
-        info!("\tSignaled !");
+        println!("\tSignaled !");
     }
 
-    info!("Done !");
+    println!("Done !");
     Ok(())
 }

examples/mutex.rs

@@ -2,7 +2,6 @@ use std::sync::atomic::{AtomicU8, Ordering};
 use std::thread;
 
 use clap::{App, Arg};
-use log::*;
 use raw_sync::locks::*;
 use shared_memory::*;
 
@@ -24,7 +23,7 @@ fn main() {
         .parse()
         .expect("Invalid number passed for num_threads");
     if num_threads < 1 {
-        info!("num_threads should be 2 or more");
+        eprintln!("num_threads should be 2 or more");
         return;
     }
     let mut threads = Vec::with_capacity(num_threads);
@@ -50,7 +49,7 @@ fn increment_value(shmem_flink: &str, thread_num: usize) {
         Ok(m) => m,
         Err(ShmemError::LinkExists) => ShmemConf::new().flink(shmem_flink).open().unwrap(),
         Err(e) => {
-            info!(
+            eprintln!(
                 "Unable to create or open shmem flink {} : {}",
                 shmem_flink, e
             );
@@ -102,12 +101,12 @@ fn increment_value(shmem_flink: &str, thread_num: usize) {
             // Cast mutex data to &mut u8
             let val: &mut u8 = unsafe { &mut **guard };
             if *val > 5 {
-                info!("[thread#{}] done !", thread_num);
+                println!("[thread#{}] done !", thread_num);
                 return;
             }
 
             // Print contents and increment value
-            info!("[thread#{}] Val : {}", thread_num, *val);
+            println!("[thread#{}] Val : {}", thread_num, *val);
             *val += 1;
 
             // Hold lock for a second

src/lib.rs

@@ -2,33 +2,14 @@
 //!
 //! For help on how to get started, take a look at the [examples](https://github.com/elast0ny/shared_memory-rs/tree/master/examples) !
 
-// Allow dependents to disable logging through the "logging" feature
-cfg_if::cfg_if! {
-    if #[cfg(feature = "logging")] {
-        pub(crate) use log;
-    } else {
-        #[allow(unused_macros)]
-        #[macro_use]
-        pub (crate) mod log {
-            macro_rules! trace (($($tt:tt)*) => {{}});
-            macro_rules! debug (($($tt:tt)*) => {{}});
-            macro_rules! info (($($tt:tt)*) => {{}});
-            macro_rules! warn  (($($tt:tt)*) => {{}});
-            macro_rules! error (($($tt:tt)*) => {{}});
-        }
-    }
-}
-
-#[allow(unused_imports)]
-use crate::log::*;
-
 use std::fs::{File, OpenOptions};
 use std::io::{ErrorKind, Read, Write};
 
 use std::fs::remove_file;
 use std::path::{Path, PathBuf};
 
-use ::cfg_if::*;
+use cfg_if::cfg_if;
+use log::*;
 
 mod error;
 pub use error::*;

src/unix.rs

@@ -1,15 +1,14 @@
-use ::nix::fcntl::OFlag;
-use ::nix::sys::mman::{mmap, munmap, shm_open, shm_unlink, MapFlags, ProtFlags};
-use ::nix::sys::stat::{fstat, Mode};
-use ::nix::unistd::{close, ftruncate};
-
-#[allow(unused_imports)]
-use crate::log::*;
-use crate::ShmemError;
-
 use std::os::unix::io::RawFd;
 use std::ptr::null_mut;
 
+use log::*;
+use nix::fcntl::OFlag;
+use nix::sys::mman::{mmap, munmap, shm_open, shm_unlink, MapFlags, ProtFlags};
+use nix::sys::stat::{fstat, Mode};
+use nix::unistd::{close, ftruncate};
+
+use crate::ShmemError;
+
 pub struct MapData {
     //On linux, you must shm_unlink() the object created for the mapping. It wont disappear automatically.
     owner: bool,