smith-logging 0.1.2

Structured logging infrastructure with NATS integration
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
125
126
127
128
129
130

//! Integration tests for Smith logging infrastructure

use smith_config::{Config, NatsLoggingConfig};
use std::time::Duration;
use tokio::time::sleep;
use tracing::{error, info, warn};

#[tokio::test]
async fn test_console_logging_initialization() {
    // Test basic console logging without NATS
    let result = smith_logging::init_console_logging("debug");
    assert!(result.is_ok());

    // Test logging at different levels
    info!("Test info message");
    warn!("Test warning message");
    error!("Test error message");
}

#[tokio::test]
async fn test_logging_config_loading() {
    // Test that we can load logging config
    let config = Config::development();

    // Verify NATS logging config is present
    assert!(config.logging.nats.enabled);
    assert_eq!(config.logging.nats.buffer_size, 500);
    assert!(!config.logging.nats.target_filters.is_empty());

    let config = Config::production();
    assert!(config.logging.nats.enabled);
    assert_eq!(config.logging.nats.buffer_size, 2000);
    assert!(config.logging.nats.batch_enabled);

    let config = Config::testing();
    assert!(!config.logging.nats.enabled); // Disabled in testing
}

#[tokio::test]
async fn test_nats_logging_config_environments() {
    // Test development config
    let dev_config = NatsLoggingConfig::development();
    assert!(dev_config.enabled);
    assert!(!dev_config.batch_enabled); // Immediate logging for dev
    assert!(dev_config.include_traces); // Traces enabled for dev
    assert_eq!(dev_config.rate_limit, 0); // No rate limiting

    // Test production config
    let prod_config = NatsLoggingConfig::production();
    assert!(prod_config.enabled);
    assert!(prod_config.batch_enabled); // Batching for performance
    assert!(!prod_config.include_traces); // No traces for performance
    assert!(prod_config.rate_limit > 0); // Rate limiting enabled

    // Test testing config
    let test_config = NatsLoggingConfig::testing();
    assert!(!test_config.enabled); // Disabled during tests
}

#[tokio::test]
async fn test_structured_logging_with_fields() {
    // Initialize console logging for testing
    let _ = smith_logging::init_console_logging("info");

    // Test structured logging with fields
    info!(
        user_id = "user123",
        action = "login",
        ip_address = "192.168.1.1",
        session_duration_ms = 1500,
        success = true,
        "User logged in successfully"
    );

    warn!(
        error_count = 3,
        service = "database",
        latency_ms = 2500,
        "High latency detected"
    );

    error!(
        error_code = 500,
        error_type = "connection_timeout",
        retry_attempts = 3,
        "Database connection failed"
    );
}

#[tokio::test]
async fn test_performance_logging() {
    let _ = smith_logging::init_console_logging("debug");

    // Simulate performance logging
    let start = std::time::Instant::now();

    // Simulate some work
    sleep(Duration::from_millis(10)).await;

    let duration = start.elapsed();

    info!(
        performance_category = "api_request",
        duration_ms = duration.as_millis() as u64,
        endpoint = "/api/users",
        status_code = 200,
        "API request completed"
    );
}

#[tokio::test]
async fn test_error_handling_logging() {
    let _ = smith_logging::init_console_logging("error");

    // Test error handling patterns
    let result: Result<(), &str> = Err("Simulated error");

    if let Err(e) = result {
        error!(
            error_message = e,
            error_source = "test_function",
            context = "integration_test",
            "Test error occurred"
        );
    }
}

// Note: Integration tests with actual NATS server would require
// a running NATS server. These tests focus on configuration
// and basic functionality that can be tested without external dependencies.