inklog 0.1.11

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
69
70
71
72
73
74
75
76
77
78
79

// Copyright (c) 2026 Kirky.X
// SPDX-License-Identifier: MIT
// 复杂特性组合测试

#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
#[cfg(test)]
mod complex_features_test {
    use inklog::{DatabaseSinkConfig, FileSinkConfig, InklogConfig, LoggerManager};
    use inklog::archive::CompressionType;
    use inklog::config::DatabaseDriver;
    use serial_test::serial;
    use std::env;
    use tempfile::TempDir;
    use inklog::tokio::time::sleep;
    use std::time::Duration;

    #[tokio::test]
    #[serial]
    async fn test_encrypted_compressed_s3_database() {
        let temp_dir = TempDir::new().unwrap();
        let log_path = temp_dir.path().join("complex_test.log.enc");
        let db_path = temp_dir.path().join("complex_test.db");
        
        // 设置加密密钥
        let encryption_key = "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI=";
        env::set_var("INKLOG_ENCRYPTION_KEY", encryption_key);
        
        let config = InklogConfig {
            file_sink: Some(FileSinkConfig {
                enabled: true,
                path: log_path.clone(),
                max_size: "50MB".into(),
                compress: false,
                encrypt: true,
                encryption_key_env: Some("INKLOG_ENCRYPTION_KEY".into()),
                ..Default::default()
            }),
            database_sink: Some(DatabaseSinkConfig {
                enabled: true,
                driver: DatabaseDriver::SQLite,
                url: format!("sqlite://{}", db_path.display()),
                pool_size: 3,
                batch_size: 50,
                flush_interval_ms: 1000,
                table_name: "logs".to_string(),
                ..Default::default()
            }),
            #[cfg(feature = "aws")]
            s3_archive: Some(inklog::S3ArchiveConfig {
                enabled: true,
                bucket: "test-bucket".to_string(),
                region: "us-east-1".to_string(),
                compression: CompressionType::Zstd,
                ..Default::default()
            }),
            ..Default::default()
        };

        let logger = LoggerManager::with_config(config).await.unwrap();
        
        // 写入加密数据
        for i in 0..500 {
            log::info!(target: "complex_test", "Encrypted message {}", i);
        }
        
        sleep(Duration::from_secs(2)).await;
        
        // 验证数据
        assert!(log_path.exists());
        assert!(db_path.exists());
        
        // 验证健康状态
        let health = logger.get_health_status();
        assert!(health.sinks.contains_key("file"));
        assert!(health.sinks.contains_key("database"));
        
        env::remove_var("INKLOG_ENCRYPTION_KEY");
    }
}