grlog 0.1.0

A high-performance async logging library based on gorust GMP runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use std::fs::OpenOptions;
use std::io::{self, Write};
use std::path::PathBuf;

/// 日志写入器 trait
pub trait LogWriter: Send + Sync {
    fn write(&self, msg: &str);
    fn flush(&self);
}

/// 标准输出写入器
pub struct StdoutWriter;

impl LogWriter for StdoutWriter {
    fn write(&self, msg: &str) {
        let _ = io::stdout().lock().write_all(msg.as_bytes());
    }
    fn flush(&self) {
        let _ = io::stdout().flush();
    }
}

/// 标准错误写入器
pub struct StderrWriter;

impl LogWriter for StderrWriter {
    fn write(&self, msg: &str) {
        let _ = io::stderr().lock().write_all(msg.as_bytes());
    }
    fn flush(&self) {
        let _ = io::stderr().flush();
    }
}

/// 文件写入器
pub struct FileWriter {
    file: std::sync::Mutex<std::io::BufWriter<std::fs::File>>,
}

impl FileWriter {
    pub fn new(path: &PathBuf) -> io::Result<Self> {
        if let Some(parent) = path.parent() {
            let _ = std::fs::create_dir_all(parent);
        }
        let file = OpenOptions::new()
            .create(true)
            .append(true)
            .open(path)?;
        Ok(Self {
            file: std::sync::Mutex::new(std::io::BufWriter::new(file)),
        })
    }
}

impl LogWriter for FileWriter {
    fn write(&self, msg: &str) {
        if let Ok(mut f) = self.file.try_lock() {
            let _ = f.write_all(msg.as_bytes());
        }
    }
    fn flush(&self) {
        if let Ok(mut f) = self.file.try_lock() {
            let _ = f.flush();
        }
    }
}

/// 根据 Target 创建对应的 LogWriter
pub fn create_writer(target: &crate::Target) -> Box<dyn LogWriter> {
    match target {
        crate::Target::Stdout => Box::new(StdoutWriter),
        crate::Target::Stderr => Box::new(StderrWriter),
        crate::Target::File(path) => {
            Box::new(FileWriter::new(path).expect("Failed to open log file"))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_stdout_writer() {
        let writer = StdoutWriter;
        writer.write("test message\n");
        writer.flush();
    }

    #[test]
    fn test_stderr_writer() {
        let writer = StderrWriter;
        writer.write("test message\n");
        writer.flush();
    }

    #[test]
    fn test_file_writer() {
        let temp_dir = std::env::temp_dir();
        let log_path = temp_dir.join("grlog_test.log");
        
        let writer = FileWriter::new(&log_path).expect("Failed to create file writer");
        writer.write("test message\n");
        writer.flush();
        
        // 验证文件存在
        assert!(log_path.exists());
        
        // 清理测试文件
        let _ = std::fs::remove_file(&log_path);
    }

    #[test]
    fn test_create_writer() {
        let stdout_target = crate::Target::Stdout;
        let stderr_target = crate::Target::Stderr;
        
        let stdout_writer = create_writer(&stdout_target);
        let stderr_writer = create_writer(&stderr_target);
        
        stdout_writer.write("test\n");
        stderr_writer.write("test\n");
    }
}