inklog 0.1.0

Enterprise-grade Rust logging infrastructure
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

// Copyright (c) 2026 Kirky.X
//
// Licensed under the MIT License
// See LICENSE file in the project root for full license information.

use inklog::log_record::LogRecord;
use inklog::sink::console::ConsoleSink;
use inklog::sink::LogSink;
use inklog::template::LogTemplate;
use inklog::{ConsoleSinkConfig, FileSinkConfig, InklogConfig, LoggerManager};
use tempfile::TempDir;
use tracing::Level;

#[test]
fn test_config_validation() {
    let config = InklogConfig::default();
    assert!(config.validate().is_ok());

    let mut invalid_config = InklogConfig::default();
    invalid_config.performance.channel_capacity = 0;
    assert!(invalid_config.validate().is_err());
}

#[test]
fn test_builder() {
    let _logger = LoggerManager::builder()
        .level("debug")
        .console(false)
        .channel_capacity(100)
        .build();
}

#[test]
fn test_console_sink_format() {
    let config = ConsoleSinkConfig {
        colored: false,
        ..Default::default()
    };
    let template = LogTemplate::default();
    let mut sink = ConsoleSink::new(config, template);
    let record = LogRecord::new(Level::INFO, "test_target".into(), "test_message".into());
    assert!(sink.write(&record).is_ok());
}

#[test]
fn test_file_sink_rotation() {
    let temp_dir = TempDir::new().expect("Failed to create temp directory");
    let log_path = temp_dir.path().join("app.log");

    let config = FileSinkConfig {
        enabled: true,
        path: log_path.clone(),
        max_size: "100B".into(), // Small size to trigger rotation
        ..Default::default()
    };

    let mut sink = inklog::sink::file::FileSink::new(config).expect("Failed to create FileSink");

    // Write enough data to trigger rotation
    for i in 0..10 {
        let record = LogRecord::new(Level::INFO, "test".into(), format!("msg {}", i));
        sink.write(&record).expect("Failed to write log record");
    }

    // Check if files created
    let entries = std::fs::read_dir(temp_dir.path()).expect("Failed to read temp directory");
    assert!(entries.count() >= 1);
}