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
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

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

//! S3 Archive with Database Integration Example
//!
//! Demonstrates integrating S3 archive with database logging.

use inklog::config::DatabaseDriver;
use inklog::{archive::ArchiveServiceBuilder, InklogConfig, LoggerManager};
use sea_orm::Database;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    println!("S3 Archive with Database Integration Example");

    // Create in-memory database for demo
    let database_url = "sqlite::memory:";
    let db_connection = Database::connect(database_url).await?;
    println!("  Database: connected");

    let config = InklogConfig {
        global: inklog::config::GlobalConfig {
            level: "info".to_string(),
            ..Default::default()
        },
        console_sink: Some(inklog::config::ConsoleSinkConfig {
            enabled: true,
            colored: true,
            ..Default::default()
        }),
        database_sink: Some(inklog::config::DatabaseSinkConfig {
            enabled: true,
            driver: DatabaseDriver::SQLite,
            url: database_url.to_string(),
            flush_interval_ms: 5000,
            archive_to_s3: true,
            archive_after_days: 7,
            ..Default::default()
        }),
        s3_archive: Some(inklog::S3ArchiveConfig {
            enabled: true,
            bucket: "my-log-archive-bucket".to_string(),
            region: "us-west-2".to_string(),
            archive_interval_days: 1,
            local_retention_days: 7,
            compression: inklog::archive::CompressionType::Zstd,
            storage_class: inklog::archive::StorageClass::StandardIa,
            prefix: "database_logs/".to_string(),
            max_file_size_mb: 50,
            ..Default::default()
        }),
        ..Default::default()
    };

    let manager = LoggerManager::with_config(config).await?;
    println!("  LoggerManager: initialized");

    // Start archive service
    manager.start_archive_service().await?;
    println!("  Archive service: started");

    // Record sample logs to database
    println!("\nRecording sample logs:");
    for i in 0..10 {
        log::info!("Sample log message #{i}");
    }
    println!("  Sample logs recorded");

    // Wait for logs to flush to database
    tokio::time::sleep(tokio::time::Duration::from_secs(6)).await;

    // Direct ArchiveService with Database
    println!("\nDirect ArchiveService with Database:");
    let archive_config = inklog::S3ArchiveConfig {
        enabled: true,
        bucket: "demo-archive-bucket".to_string(),
        region: "us-east-1".to_string(),
        archive_interval_days: 1,
        local_retention_days: 3,
        compression: inklog::archive::CompressionType::Gzip,
        storage_class: inklog::archive::StorageClass::Glacier,
        prefix: "db_archives/".to_string(),
        max_file_size_mb: 25,
        ..Default::default()
    };

    let archive_service = ArchiveServiceBuilder::new()
        .config(archive_config)
        .database_connection(db_connection)
        .build()
        .await?;

    println!("    Bucket: {}", archive_service.bucket());
    println!("    Region: {}", archive_service.region());

    // Manual archive demonstration
    println!("\nManual archive demonstration:");
    match manager.trigger_archive().await {
        Ok(archive_key) => println!("  Archive: {archive_key}"),
        Err(e) => println!("  Archive skipped (expected): {e}"),
    }

    // List archives
    println!("\nListing archives:");
    match archive_service.list_archives(None, None).await {
        Ok(archives) => println!("  Found {} archived files", archives.len()),
        Err(e) => println!("  Could not list archives (expected without S3): {e}"),
    }

    // Stop archive service
    manager.stop_archive_service().await?;
    println!("\nS3 archive with database example completed");

    Ok(())
}