Provide the standard logging facility implementation.

As the crate is mostly used as a redis module, the logging will most
likely be only useful when printed on the server. As many rustaceans are
familiar and used to using the de-facto standard "log" crate, it makes
sense to provide the logging implementation for this crate to enable the
most-commonly used way of logging messages in Rust.

Author: iddm

Cargo.toml

@@ -104,6 +104,7 @@ serde = { version = "1", features = ["derive"] }
 nix = "0.26"
 cfg-if = "1"
 redis-module-macros-internals = { path = "./redismodule-rs-macros-internals" }
+log = "0.4"
 
 [dev-dependencies]
 anyhow = "1"

examples/load_unload.rs

@@ -1,4 +1,4 @@
-use redis_module::{redis_module, Context, LogLevel, RedisString, Status};
+use redis_module::{logging::RedisLogLevel, redis_module, Context, RedisString, Status};
 
 static mut GLOBAL_STATE: Option<String> = None;
 
@@ -10,7 +10,7 @@ fn init(ctx: &Context, args: &[RedisString]) -> Status {
         (before, after)
     };
     ctx.log(
-        LogLevel::Warning,
+        RedisLogLevel::Warning,
         &format!("Update global state on LOAD. BEFORE: {before:?}, AFTER: {after:?}",),
     );
 
@@ -24,7 +24,7 @@ fn deinit(ctx: &Context) -> Status {
         (before, after)
     };
     ctx.log(
-        LogLevel::Warning,
+        RedisLogLevel::Warning,
         &format!("Update global state on UNLOAD. BEFORE: {before:?}, AFTER: {after:?}"),
     );
 

src/context/call_reply.rs

@@ -548,20 +548,15 @@ impl TryFrom<&str> for VerbatimStringFormat {
             )));
         }
         let mut res = VerbatimStringFormat::default();
-        value
-            .chars()
-            .into_iter()
-            .take(3)
-            .enumerate()
-            .try_for_each(|(i, c)| {
-                if c as u32 >= 127 {
-                    return Err(RedisError::String(
-                        "Verbatim format must contains only ASCI values.".to_owned(),
-                    ));
-                }
-                res.0[i] = c as c_char;
-                Ok(())
-            })?;
+        value.chars().take(3).enumerate().try_for_each(|(i, c)| {
+            if c as u32 >= 127 {
+                return Err(RedisError::String(
+                    "Verbatim format must contains only ASCI values.".to_owned(),
+                ));
+            }
+            res.0[i] = c as c_char;
+            Ok(())
+        })?;
         Ok(res)
     }
 }

src/context/mod.rs

@@ -6,11 +6,12 @@ use std::os::raw::{c_char, c_int, c_long, c_longlong};
 use std::ptr::{self, NonNull};
 use std::sync::atomic::{AtomicPtr, Ordering};
 
+use crate::add_info_section;
 use crate::key::{RedisKey, RedisKeyWritable};
+use crate::logging::RedisLogLevel;
 use crate::raw::{ModuleOptions, Version};
 use crate::redisvalue::RedisValueKey;
 use crate::{add_info_field_long_long, add_info_field_str, raw, utils, Status};
-use crate::{add_info_section, LogLevel};
 use crate::{RedisError, RedisResult, RedisString, RedisValue};
 
 use std::ffi::CStr;
@@ -135,25 +136,25 @@ impl Default for DetachedContext {
 }
 
 impl DetachedContext {
-    pub fn log(&self, level: LogLevel, message: &str) {
+    pub fn log(&self, level: RedisLogLevel, message: &str) {
         let c = self.ctx.load(Ordering::Relaxed);
         crate::logging::log_internal(c, level, message);
     }
 
     pub fn log_debug(&self, message: &str) {
-        self.log(LogLevel::Debug, message);
+        self.log(RedisLogLevel::Debug, message);
     }
 
     pub fn log_notice(&self, message: &str) {
-        self.log(LogLevel::Notice, message);
+        self.log(RedisLogLevel::Notice, message);
     }
 
     pub fn log_verbose(&self, message: &str) {
-        self.log(LogLevel::Verbose, message);
+        self.log(RedisLogLevel::Verbose, message);
     }
 
     pub fn log_warning(&self, message: &str) {
-        self.log(LogLevel::Warning, message);
+        self.log(RedisLogLevel::Warning, message);
     }
 
     pub fn set_context(&self, ctx: &Context) -> Result<(), RedisError> {
@@ -266,24 +267,24 @@ impl Context {
         }
     }
 
-    pub fn log(&self, level: LogLevel, message: &str) {
+    pub fn log(&self, level: RedisLogLevel, message: &str) {
         crate::logging::log_internal(self.ctx, level, message);
     }
 
     pub fn log_debug(&self, message: &str) {
-        self.log(LogLevel::Debug, message);
+        self.log(RedisLogLevel::Debug, message);
     }
 
     pub fn log_notice(&self, message: &str) {
-        self.log(LogLevel::Notice, message);
+        self.log(RedisLogLevel::Notice, message);
     }
 
     pub fn log_verbose(&self, message: &str) {
-        self.log(LogLevel::Verbose, message);
+        self.log(RedisLogLevel::Verbose, message);
     }
 
     pub fn log_warning(&self, message: &str) {
-        self.log(LogLevel::Warning, message);
+        self.log(RedisLogLevel::Warning, message);
     }
 
     /// # Panics

src/lib.rs

@@ -1,7 +1,4 @@
-//#![allow(dead_code)]
-
 pub use crate::context::InfoContext;
-use strum_macros::AsRefStr;
 extern crate num_traits;
 
 pub mod alloc;
@@ -44,16 +41,6 @@ pub use crate::raw::*;
 pub use crate::redismodule::*;
 use backtrace::Backtrace;
 
-/// `LogLevel` is a level of logging to be specified with a Redis log directive.
-#[derive(Clone, Copy, Debug, AsRefStr)]
-#[strum(serialize_all = "snake_case")]
-pub enum LogLevel {
-    Debug,
-    Notice,
-    Verbose,
-    Warning,
-}
-
 pub fn base_info_func(
     ctx: &InfoContext,
     for_crash_report: bool,

src/logging.rs

@@ -1,53 +1,143 @@
 use crate::raw;
-use crate::LogLevel;
 use std::ffi::CString;
 use std::ptr;
+use strum_macros::AsRefStr;
 
-pub(crate) fn log_internal(ctx: *mut raw::RedisModuleCtx, level: LogLevel, message: &str) {
+const NOT_INITIALISED_MESSAGE: &str = "Redis module hasn't been initialised.";
+
+/// [RedisLogLevel] is a level of logging which can be used when
+/// logging with Redis. See [raw::RedisModule_Log] and the official
+/// redis [reference](https://redis.io/docs/reference/modules/modules-api-ref/).
+#[derive(Clone, Copy, Debug, AsRefStr)]
+#[strum(serialize_all = "snake_case")]
+pub enum RedisLogLevel {
+    Debug,
+    Notice,
+    Verbose,
+    Warning,
+}
+
+pub(crate) fn log_internal(ctx: *mut raw::RedisModuleCtx, level: RedisLogLevel, message: &str) {
     if cfg!(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()) }
+    unsafe {
+        raw::RedisModule_Log.expect(NOT_INITIALISED_MESSAGE)(ctx, level.as_ptr(), fmt.as_ptr())
+    }
 }
 
 /// This function should be used when a callback is returning a critical error
 /// to the caller since cannot load or save the data for some critical reason.
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-pub fn log_io_error(io: *mut raw::RedisModuleIO, level: LogLevel, message: &str) {
+pub fn log_io_error(io: *mut raw::RedisModuleIO, level: RedisLogLevel, message: &str) {
     if cfg!(test) {
         return;
     }
     let level = CString::new(level.as_ref()).unwrap();
     let fmt = CString::new(message).unwrap();
-    unsafe { raw::RedisModule_LogIOError.unwrap()(io, level.as_ptr(), fmt.as_ptr()) }
+    unsafe {
+        raw::RedisModule_LogIOError.expect(NOT_INITIALISED_MESSAGE)(
+            io,
+            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);
+pub fn log<T: AsRef<str>>(level: RedisLogLevel, message: T) {
+    log_internal(ptr::null_mut(), level, message.as_ref());
 }
 
-/// 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 Redis at the [RedisLogLevel::Debug] level.
+pub fn log_debug<T: AsRef<str>>(message: T) {
+    log(RedisLogLevel::Debug, message.as_ref());
 }
 
-/// Log a message to the Redis log with NOTICE log level.
-pub fn log_notice(message: &str) {
-    log(LogLevel::Notice, message);
+/// Log a message to Redis at the [RedisLogLevel::Notice] level.
+pub fn log_notice<T: AsRef<str>>(message: T) {
+    log(RedisLogLevel::Notice, message.as_ref());
 }
 
-/// Log a message to the Redis log with VERBOSE log level.
-pub fn log_verbose(message: &str) {
-    log(LogLevel::Verbose, message);
+/// Log a message to Redis at the [RedisLogLevel::Verbose] level.
+pub fn log_verbose<T: AsRef<str>>(message: T) {
+    log(RedisLogLevel::Verbose, message.as_ref());
 }
 
-/// Log a message to the Redis log with WARNING log level.
-pub fn log_warning(message: &str) {
-    log(LogLevel::Warning, message);
+/// Log a message to Redis at the [RedisLogLevel::Warning] level.
+pub fn log_warning<T: AsRef<str>>(message: T) {
+    log(RedisLogLevel::Warning, message.as_ref());
+}
+
+/// The [log] crate implementation of logging.
+pub mod standard_log_implementation {
+    use super::*;
+    use log::{Level, Metadata, Record, SetLoggerError};
+
+    static LOGGER: RedisGlobalLogger = RedisGlobalLogger;
+
+    /// The struct which has an implementation of the [log] crate's
+    /// logging interface.
+    ///
+    /// # Note
+    ///
+    /// Redis does not support logging at the [log::Level::Error] level,
+    /// so logging at this level will be converted to logging at the
+    /// [log::Level::Warn] level under the hood.
+    struct RedisGlobalLogger;
+
+    /// Sets this logger as a global logger. Use this method to set
+    /// up the logger. If this method is never called, the default
+    /// logger is used which redirects the logging to the standard
+    /// input/output streams.
+    ///
+    /// # Example
+    ///
+    /// This function may be called on a module startup, within the
+    /// module initialisation function (specified in the
+    /// [crate::redis_module] as the `init` argument, which will be used
+    /// for the module initialisation and will be passed to the
+    /// [raw::Export_RedisModule_Init] function when loading the
+    /// module).
+    #[allow(dead_code)]
+    pub fn setup() -> Result<(), SetLoggerError> {
+        log::set_logger(&LOGGER).map(|()| log::set_max_level(log::LevelFilter::Trace))
+    }
+
+    impl log::Log for RedisGlobalLogger {
+        fn enabled(&self, _: &Metadata) -> bool {
+            true
+        }
+
+        fn log(&self, record: &Record) {
+            if !self.enabled(record.metadata()) {
+                return;
+            }
+
+            let message = format!(
+                "'{}' {}:{}: {}",
+                record.module_path().unwrap_or_default(),
+                record.file().unwrap_or("Unknown"),
+                record.line().unwrap_or(0),
+                record.args()
+            );
+
+            match record.level() {
+                Level::Debug => log_debug(message),
+                Level::Error | Level::Warn => log_warning(message),
+                Level::Info => log_notice(message),
+                Level::Trace => log_verbose(message),
+            }
+        }
+
+        fn flush(&self) {
+            // The flushing isn't required for the Redis logging.
+        }
+    }
 }
+pub use standard_log_implementation::*;