use std::sync::atomic::{AtomicBool, Ordering};
static LOG_SENSITIVE_DATA: AtomicBool = AtomicBool::new(false);
pub fn log_sensitive_data() -> bool {
LOG_SENSITIVE_DATA.load(Ordering::Relaxed)
}
pub fn set_log_sensitive_data(enable: bool) {
LOG_SENSITIVE_DATA.store(enable, Ordering::Relaxed);
}
#[derive(Clone)]
pub struct SensitiveLogger {
target: &'static str,
}
impl SensitiveLogger {
pub const fn new(target: &'static str) -> Self {
Self { target }
}
pub fn trace(&self, message: &str) {
log::trace!(target: self.target, "{}", message);
}
pub fn verbose(&self, message: &str) {
log::trace!(target: self.target, "{}", message);
}
pub fn debug(&self, message: &str) {
log::debug!(target: self.target, "{}", message);
}
pub fn info(&self, message: &str) {
log::info!(target: self.target, "{}", message);
}
pub fn warning(&self, message: &str) {
log::warn!(target: self.target, "{}", message);
}
pub fn error(&self, message: &str) {
log::error!(target: self.target, "{}", message);
}
pub fn sd_trace(&self, message: &str) {
if log_sensitive_data() {
log::trace!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_verbose(&self, message: &str) {
if log_sensitive_data() {
log::trace!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_debug(&self, message: &str) {
if log_sensitive_data() {
log::debug!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_info(&self, message: &str) {
if log_sensitive_data() {
log::info!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_warning(&self, message: &str) {
if log_sensitive_data() {
log::warn!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_error(&self, message: &str) {
if log_sensitive_data() {
log::error!(target: self.target, "[SD] {}", message);
}
}
pub fn sd_shout(&self, message: &str) {
if log_sensitive_data() {
log::error!(target: self.target, "[SD] {}", message);
}
}
}
#[macro_export]
macro_rules! sd_trace {
($($arg:tt)*) => {
if $crate::extension::logging::log_sensitive_data() {
log::trace!($($arg)*);
}
};
}
#[macro_export]
macro_rules! sd_debug {
($($arg:tt)*) => {
if $crate::extension::logging::log_sensitive_data() {
log::debug!($($arg)*);
}
};
}
#[macro_export]
macro_rules! sd_info {
($($arg:tt)*) => {
if $crate::extension::logging::log_sensitive_data() {
log::info!($($arg)*);
}
};
}
#[macro_export]
macro_rules! sd_warn {
($($arg:tt)*) => {
if $crate::extension::logging::log_sensitive_data() {
log::warn!($($arg)*);
}
};
}
#[macro_export]
macro_rules! sd_error {
($($arg:tt)*) => {
if $crate::extension::logging::log_sensitive_data() {
log::error!($($arg)*);
}
};
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
static FLAG_LOCK: Mutex<()> = Mutex::new(());
#[test]
fn default_sensitive_logging_is_disabled() {
let _guard = FLAG_LOCK.lock().unwrap_or_else(|e| e.into_inner());
set_log_sensitive_data(false);
assert!(!log_sensitive_data());
}
#[test]
fn set_log_sensitive_data_toggles_flag() {
let _guard = FLAG_LOCK.lock().unwrap_or_else(|e| e.into_inner());
set_log_sensitive_data(false);
assert!(!log_sensitive_data());
set_log_sensitive_data(true);
assert!(log_sensitive_data());
set_log_sensitive_data(false);
assert!(!log_sensitive_data());
}
#[test]
fn sensitive_logger_construction() {
let logger = SensitiveLogger::new("test_module");
assert_eq!(logger.target, "test_module");
}
#[test]
fn sensitive_logger_clone() {
let logger = SensitiveLogger::new("test_module");
let cloned = logger.clone();
assert_eq!(cloned.target, "test_module");
}
#[test]
fn normal_log_calls_do_not_panic() {
let logger = SensitiveLogger::new("test");
logger.trace("trace msg");
logger.verbose("verbose msg");
logger.debug("debug msg");
logger.info("info msg");
logger.warning("warning msg");
logger.error("error msg");
}
#[test]
fn sensitive_log_calls_do_not_panic_when_disabled() {
let _guard = FLAG_LOCK.lock().unwrap_or_else(|e| e.into_inner());
set_log_sensitive_data(false);
let logger = SensitiveLogger::new("test");
logger.sd_trace("secret trace");
logger.sd_verbose("secret verbose");
logger.sd_debug("secret debug");
logger.sd_info("secret info");
logger.sd_warning("secret warning");
logger.sd_error("secret error");
logger.sd_shout("secret shout");
}
#[test]
fn sensitive_log_calls_do_not_panic_when_enabled() {
let _guard = FLAG_LOCK.lock().unwrap_or_else(|e| e.into_inner());
set_log_sensitive_data(true);
let logger = SensitiveLogger::new("test");
logger.sd_trace("secret trace");
logger.sd_debug("secret debug");
set_log_sensitive_data(false);
}
}