blinq_common/

logging.rs

#[cfg(feature = "logging")]
use tracing_subscriber::{fmt, prelude::*, EnvFilter, Layer};

#[cfg(feature = "logging")]
use crate::config::CommonConfig;

/// Logging format options
#[derive(Debug, Clone)]
pub enum LogFormat {
    /// Human-readable format for development
    Pretty,
    /// Compact format for production
    Compact,
    /// JSON format for structured logging
    Json,
    /// Full format with all details
    Full,
}

/// Logging output destination
#[derive(Debug, Clone)]
pub enum LogOutput {
    /// Output to stdout
    Stdout,
    /// Output to stderr
    Stderr,
    /// Output to a file (path)
    File(String),
}

/// Request ID generation strategy
#[derive(Debug, Clone)]
pub enum RequestIdStrategy {
    /// Generate UUID v4
    Uuid,
    /// Generate short alphanumeric ID (8 chars)
    Short,
    /// Generate timestamp-based ID
    Timestamp,
    /// Custom prefix + UUID
    PrefixedUuid(String),
}

/// Advanced logging configuration
#[derive(Debug, Clone)]
pub struct LoggingConfig {
    pub level: String,
    pub format: LogFormat,
    pub output: LogOutput,
    pub show_target: bool,
    pub show_thread_ids: bool,
    pub show_file_line: bool,
    pub show_timestamps: bool,
    pub service_name: Option<String>,
    pub auto_request_id: bool,
    pub request_id_strategy: RequestIdStrategy,
    pub request_id_field: String,
}

impl Default for LoggingConfig {
    fn default() -> Self {
        Self {
            level: "info".to_string(),
            format: LogFormat::Pretty,
            output: LogOutput::Stdout,
            show_target: true,
            show_thread_ids: false,
            show_file_line: false,
            show_timestamps: true,
            service_name: None,
            auto_request_id: false,
            request_id_strategy: RequestIdStrategy::Uuid,
            request_id_field: "request_id".to_string(),
        }
    }
}

impl LoggingConfig {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_level(mut self, level: impl Into<String>) -> Self {
        self.level = level.into();
        self
    }

    pub fn with_format(mut self, format: LogFormat) -> Self {
        self.format = format;
        self
    }

    pub fn with_output(mut self, output: LogOutput) -> Self {
        self.output = output;
        self
    }

    pub fn with_service_name(mut self, name: impl Into<String>) -> Self {
        self.service_name = Some(name.into());
        self
    }

    pub fn show_target(mut self, show: bool) -> Self {
        self.show_target = show;
        self
    }

    pub fn show_thread_ids(mut self, show: bool) -> Self {
        self.show_thread_ids = show;
        self
    }

    pub fn show_file_line(mut self, show: bool) -> Self {
        self.show_file_line = show;
        self
    }

    pub fn show_timestamps(mut self, show: bool) -> Self {
        self.show_timestamps = show;
        self
    }

    /// Enable automatic request ID injection
    pub fn with_auto_request_id(mut self, enabled: bool) -> Self {
        self.auto_request_id = enabled;
        self
    }

    /// Set request ID generation strategy
    pub fn with_request_id_strategy(mut self, strategy: RequestIdStrategy) -> Self {
        self.request_id_strategy = strategy;
        self
    }

    /// Set custom field name for request ID (default: "request_id")
    pub fn with_request_id_field(mut self, field_name: impl Into<String>) -> Self {
        self.request_id_field = field_name.into();
        self
    }
}

/// Generate a request ID based on the strategy
#[cfg(feature = "logging")]
pub fn generate_request_id(strategy: &RequestIdStrategy) -> String {
    match strategy {
        RequestIdStrategy::Uuid => {
            // Simple UUID-like generation without external deps
            use std::time::{SystemTime, UNIX_EPOCH};
            let timestamp = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_nanos();
            let random = (timestamp % 1000000) as u32;
            format!(
                "{:08x}-{:04x}-{:04x}",
                timestamp as u32,
                random,
                random >> 16
            )
        }
        RequestIdStrategy::Short => {
            use std::time::{SystemTime, UNIX_EPOCH};
            let timestamp = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_nanos();
            format!("{:08x}", (timestamp % 0xffffffff) as u32)
        }
        RequestIdStrategy::Timestamp => {
            use std::time::{SystemTime, UNIX_EPOCH};
            let timestamp = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_millis();
            format!("req_{}", timestamp)
        }
        RequestIdStrategy::PrefixedUuid(prefix) => {
            let uuid_part = generate_request_id(&RequestIdStrategy::Uuid);
            format!("{}_{}", prefix, uuid_part)
        }
    }
}

/// Create a request span with automatic request ID injection
#[cfg(feature = "logging")]
pub fn create_request_span(strategy: &RequestIdStrategy) -> (String, tracing::Span) {
    let request_id = generate_request_id(strategy);
    let span = tracing::info_span!("request", request_id = %request_id);
    (request_id, span)
}

/// Create a request span with custom request ID
#[cfg(feature = "logging")]
pub fn create_request_span_with_id(request_id: &str) -> tracing::Span {
    tracing::info_span!("request", request_id = %request_id)
}

/// Macro to create a request span with automatic ID generation
#[cfg(feature = "logging")]
#[macro_export]
macro_rules! request_span {
    () => {{
        let (request_id, span) =
            $crate::logging::create_request_span(&$crate::logging::RequestIdStrategy::Uuid);
        span
    }};
    ($strategy:expr) => {{
        let (request_id, span) = $crate::logging::create_request_span(&$strategy);
        span
    }};
}

/// Macro to create a named request span with automatic ID generation
#[cfg(feature = "logging")]
#[macro_export]
macro_rules! named_request_span {
    ($name:literal) => {{
        let request_id = $crate::logging::generate_request_id(&$crate::logging::RequestIdStrategy::Uuid);
        tracing::info_span!($name, request_id = %request_id)
    }};
    ($name:literal, $strategy:expr) => {{
        let request_id = $crate::logging::generate_request_id(&$strategy);
        tracing::info_span!($name, request_id = %request_id)
    }};
}

/// Macro to create a request span with custom ID
#[cfg(feature = "logging")]
#[macro_export]
macro_rules! request_span_with_id {
    ($id:expr) => {
        $crate::logging::create_request_span_with_id($id)
    };
}

/// Initialize global tracing subscriber for logging with env filter.
///
/// Reads RUST_LOG from env, defaults to "info" if not set.
#[cfg(feature = "logging")]
pub fn init() {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
    fmt().with_env_filter(filter).init();
}

/// Initialize logging with custom configuration
#[cfg(feature = "logging")]
pub fn init_with_config(config: &CommonConfig) {
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(&config.log_level));

    fmt()
        .with_env_filter(filter)
        .with_target(false)
        .with_thread_ids(true)
        .with_file(true)
        .with_line_number(true)
        .init();
}

/// Initialize structured logging with service name
#[cfg(feature = "logging")]
pub fn init_structured(service_name: &str) {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));

    fmt()
        .with_env_filter(filter)
        .with_target(false)
        .with_thread_ids(true)
        .init();

    tracing::info!(service = service_name, "Logging initialized");
}

/// Initialize logging with advanced configuration
#[cfg(feature = "logging")]
pub fn init_advanced(config: LoggingConfig) {
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(&config.level));

    let fmt_layer = match config.format {
        LogFormat::Pretty => fmt::layer()
            .pretty()
            .with_target(config.show_target)
            .with_thread_ids(config.show_thread_ids)
            .with_file(config.show_file_line)
            .with_line_number(config.show_file_line)
            .with_ansi(true)
            .boxed(),

        LogFormat::Compact => fmt::layer()
            .compact()
            .with_target(config.show_target)
            .with_thread_ids(config.show_thread_ids)
            .with_file(config.show_file_line)
            .with_line_number(config.show_file_line)
            .boxed(),

        LogFormat::Json => fmt::layer()
            .json()
            .with_target(config.show_target)
            .with_thread_ids(config.show_thread_ids)
            .with_file(config.show_file_line)
            .with_line_number(config.show_file_line)
            .boxed(),

        LogFormat::Full => fmt::layer()
            .with_target(config.show_target)
            .with_thread_ids(config.show_thread_ids)
            .with_file(config.show_file_line)
            .with_line_number(config.show_file_line)
            .with_ansi(true)
            .boxed(),
    };

    tracing_subscriber::registry()
        .with(filter)
        .with(fmt_layer)
        .init();

    if let Some(service_name) = config.service_name {
        tracing::info!(
            service = service_name,
            format = ?config.format,
            level = config.level,
            auto_request_id = config.auto_request_id,
            request_id_strategy = ?config.request_id_strategy,
            "Advanced logging initialized"
        );
    }
}

/// Initialize JSON logging for production environments
#[cfg(feature = "logging")]
pub fn init_json_production(service_name: &str, level: Option<&str>) {
    let log_level = level.unwrap_or("info");
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(log_level));

    fmt()
        .json()
        .with_env_filter(filter)
        .with_target(false)
        .with_thread_ids(true)
        .with_file(false)
        .with_line_number(false)
        .with_current_span(true)
        .with_span_list(false)
        .init();

    tracing::info!(
        service = service_name,
        environment = "production",
        log_level = log_level,
        "Production JSON logging initialized"
    );
}

/// Initialize development logging with pretty formatting
#[cfg(feature = "logging")]
pub fn init_development(service_name: &str) {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("debug"));

    fmt()
        .pretty()
        .with_env_filter(filter)
        .with_target(true)
        .with_thread_ids(true)
        .with_file(true)
        .with_line_number(true)
        .with_ansi(true)
        .init();

    tracing::info!(
        service = service_name,
        environment = "development",
        "Development logging initialized with pretty formatting"
    );
}

/// Initialize minimal logging for testing
#[cfg(feature = "logging")]
pub fn init_test() {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn"));

    fmt()
        .compact()
        .with_env_filter(filter)
        .with_target(false)
        .with_thread_ids(false)
        .with_file(false)
        .with_line_number(false)
        .with_ansi(false)
        .init();
}

/// Create a logging configuration from CommonConfig
#[cfg(feature = "logging")]
pub fn from_common_config(config: &CommonConfig) -> LoggingConfig {
    let format = match config.custom.get("log_format").map(|s| s.as_str()) {
        Some("json") => LogFormat::Json,
        Some("compact") => LogFormat::Compact,
        Some("full") => LogFormat::Full,
        _ => LogFormat::Pretty,
    };

    let output = match config.custom.get("log_output").map(|s| s.as_str()) {
        Some("stderr") => LogOutput::Stderr,
        Some(path) if path.starts_with("/") || path.contains(".log") => {
            LogOutput::File(path.to_string())
        }
        _ => LogOutput::Stdout,
    };

    LoggingConfig::new()
        .with_level(&config.log_level)
        .with_format(format)
        .with_output(output)
        .with_service_name(&config.service_name)
        .show_target(
            config
                .custom
                .get("log_show_target")
                .map(|s| s == "true")
                .unwrap_or(true),
        )
        .show_thread_ids(
            config
                .custom
                .get("log_show_threads")
                .map(|s| s == "true")
                .unwrap_or(false),
        )
        .show_file_line(
            config
                .custom
                .get("log_show_location")
                .map(|s| s == "true")
                .unwrap_or(false),
        )
}