Add API for context-less logging (#106)

- It is sometimes useful to log messages to the Redis logs from code that does not take a context
  object. The Redis modules API allows for this by specifying a NULL context, but the Rust wrapper
  previously prevented taking advantage of this ability.
- Added a log_* method for each supported log level to the context object.
- Used `strum` to make translating the LogLevel enum to a string more efficient. This now uses
  static strings generated at compile-time, rather than allocating and formatting them dynamically
  at runtime on each log call.
- Replaced outdated `#[macro_use] statements with `use`. Leaving the 
  `#[macro_use] extern crate redis_module` as-it-is in the examples code, since it makes more
   sense to pull in all macros from the redis_module crate rather than trying to pick-and-choose.

Author: slavak

Cargo.toml

@@ -46,6 +46,7 @@ bitflags = "1.2"
 libc = "0.2"
 enum-primitive-derive = "^0.1"
 num-traits = "^0.2"
+strum_macros = "0.19"
 #failure = "0.1"
 
 [build-dependencies]

src/context/mod.rs

@@ -34,15 +34,25 @@ impl Context {
     }
 
     pub fn log(&self, level: LogLevel, message: &str) {
-        let level = CString::new(format!("{:?}", level).to_lowercase()).unwrap();
-        let fmt = CString::new(message).unwrap();
-        unsafe { raw::RedisModule_Log.unwrap()(self.ctx, level.as_ptr(), fmt.as_ptr()) }
+        crate::logging::log_internal(self.ctx, level, message);
     }
 
     pub fn log_debug(&self, message: &str) {
+        self.log(LogLevel::Debug, message);
+    }
+
+    pub fn log_notice(&self, message: &str) {
         self.log(LogLevel::Notice, message);
     }
 
+    pub fn log_verbose(&self, message: &str) {
+        self.log(LogLevel::Verbose, message);
+    }
+
+    pub fn log_warning(&self, message: &str) {
+        self.log(LogLevel::Warning, message);
+    }
+
     pub fn auto_memory(&self) {
         unsafe {
             raw::RedisModule_AutoMemory.unwrap()(self.ctx);

src/lib.rs

@@ -2,11 +2,8 @@
 
 use std::os::raw::c_char;
 use std::str::Utf8Error;
+use strum_macros::AsRefStr;
 
-#[macro_use]
-extern crate bitflags;
-#[macro_use]
-extern crate enum_primitive_derive;
 extern crate num_traits;
 
 use libc::size_t;
@@ -20,10 +17,10 @@ mod redismodule;
 pub mod redisraw;
 pub mod redisvalue;
 
-#[macro_use]
-mod macros;
 mod context;
 mod key;
+pub mod logging;
+mod macros;
 
 #[cfg(feature = "experimental-api")]
 pub use crate::context::thread_safe::ThreadSafeContext;
@@ -39,7 +36,8 @@ pub use crate::redismodule::*;
 static ALLOC: crate::alloc::RedisAlloc = crate::alloc::RedisAlloc;
 
 /// `LogLevel` is a level of logging to be specified with a Redis log directive.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, AsRefStr)]
+#[strum(serialize_all = "snake_case")]
 pub enum LogLevel {
     Debug,
     Notice,

src/logging.rs

@@ -0,0 +1,40 @@
+use crate::LogLevel;
+use crate::raw;
+use std::ffi::CString;
+use std::ptr;
+
+pub(crate) fn log_internal(ctx: *mut raw::RedisModuleCtx, level: LogLevel, message: &str) {
+    if cfg!(feature = "test") {
+        return;
+    }
+    let level = CString::new(level.as_ref()).unwrap();
+    let fmt = CString::new(message).unwrap();
+    unsafe { raw::RedisModule_Log.unwrap()(ctx, level.as_ptr(), fmt.as_ptr()) }
+}
+
+/// Log a message to the Redis log with the given log level, without
+/// requiring a context. This prevents Redis from including the module
+/// name in the logged message.
+pub fn log(level: LogLevel, message: &str) {
+    log_internal(ptr::null_mut(), level, message);
+}
+
+/// Log a message to the Redis log with DEBUG log level.
+pub fn log_debug(message: &str) {
+    log(LogLevel::Debug, message);
+}
+
+/// Log a message to the Redis log with NOTICE log level.
+pub fn log_notice(message: &str) {
+    log(LogLevel::Debug, message);
+}
+
+/// Log a message to the Redis log with VERBOSE log level.
+pub fn log_verbose(message: &str) {
+    log(LogLevel::Debug, message);
+}
+
+/// Log a message to the Redis log with WARNING log level.
+pub fn log_warning(message: &str) {
+    log(LogLevel::Debug, message);
+}

src/raw.rs

@@ -8,6 +8,8 @@ extern crate enum_primitive_derive;
 extern crate libc;
 extern crate num_traits;
 
+use bitflags::bitflags;
+use enum_primitive_derive::Primitive;
 use libc::size_t;
 use num_traits::FromPrimitive;
 use std::ffi::CString;