rust_observer 0.2.2

use crate::logging::{LogExporter, LogMessage};
use crate::metrics::{Metrics, MetricsExporter};
use crate::tracing::{TraceContext, TraceExporter};

pub enum StdoutFormat {
    Extended,
    Minimal,
}

pub struct StdoutExporter {
    format: StdoutFormat,
}

impl StdoutExporter {
    pub fn new(format: StdoutFormat) -> Self {
        StdoutExporter { format }
    }
}

impl LogExporter for StdoutExporter {
    fn export(&self, log: &LogMessage<'_>) {
        match self.format {
            StdoutFormat::Extended => {
                match crate::logging::prepare_stdout_message(log) {
                    Ok(formatted_log) => println!("{}", formatted_log),
                    Err(e) => eprintln!("Error formatting log message: {}", e),
                }
            }
            StdoutFormat::Minimal => {
                println!("[{}] {} - {}", log.level.as_str(), log.target, log.message);
            }
        }
    }
}

impl TraceExporter for StdoutExporter {
    fn export(&self, trace: &TraceContext) {
        match self.format {
            StdoutFormat::Extended => {
                let formatted_trace = crate::tracing::format_trace(trace);
                println!("{}", formatted_trace);
            }
            StdoutFormat::Minimal => {
                println!(
                    "[TRACE] {} - {} ({})",
                    trace.operation_name, trace.span_id, trace.span_status.lock().unwrap().as_str()
                );
            }
        }
    }
}

impl MetricsExporter for StdoutExporter {
    fn export(&self, metrics: &Metrics) {
        match self.format {
            StdoutFormat::Extended => {
                crate::metrics::print_metrics(metrics);
            }
            StdoutFormat::Minimal => {
                println!(
                    "[METRICS] {}.{} - CPU: {:.2}%, Memory: {}/{} MB",
                    metrics.app_name,
                    metrics.service_name,
                    metrics.system_metrics.as_ref().map_or(0.0, |m| m.cpu_usage),
                    metrics.system_metrics.as_ref().map_or(0, |m| m.memory_used / 1_000_000),
                    metrics.system_metrics.as_ref().map_or(0, |m| m.memory_total / 1_000_000),
                );
            }
        }
    }
}