lessence 0.3.0

Extract the essence of your logs — compress repetitive lines while preserving all unique information
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// Essence Mode Module
// Constitutional timestamp removal/tokenization for temporal independence

pub mod processor;

/// Essence mode processor trait for constitutional compliance
pub trait EssenceModeProcessor {
    /// Create new essence processor with constitutional configuration
    fn new(enabled: bool) -> Self;

    /// Process line with timestamp tokenization if enabled
    fn process_line(&self, line: &str) -> String;

    /// Enable or disable essence mode
    fn set_enabled(&mut self, enabled: bool);

    /// Check if essence mode is currently enabled
    fn is_enabled(&self) -> bool;

    /// Get count of timestamps processed
    fn get_timestamps_replaced(&self) -> u64;

    /// Get supported timestamp formats count
    fn get_supported_formats_count(&self) -> usize;

    /// Validate constitutional compliance
    fn validate_constitutional_compliance(&self) -> EssenceModeValidation;
}

/// Validation result for essence mode constitutional compliance
#[derive(Debug, Clone)]
pub struct EssenceModeValidation {
    pub is_non_default: bool,        // Must be disabled by default
    pub supports_all_formats: bool,  // Must support ALL timestamp formats
    pub preserves_structure: bool,   // Must preserve log structure
    pub achieves_independence: bool, // Must achieve temporal independence
}

impl EssenceModeValidation {
    /// Check if essence mode meets all constitutional requirements
    pub fn meets_constitutional_requirements(&self) -> bool {
        self.is_non_default
            && self.supports_all_formats
            && self.preserves_structure
            && self.achieves_independence
    }
}

/// Tokenization strategy for timestamp replacement
#[derive(Debug, Clone)]
pub enum TokenizationStrategy {
    ReplaceWithToken(String), // "<TIMESTAMP>"
    RemoveCompletely,
    NormalizeFormat(String),
}

impl Default for TokenizationStrategy {
    fn default() -> Self {
        TokenizationStrategy::ReplaceWithToken("<TIMESTAMP>".to_string())
    }
}

/// Timestamp format detection result
#[derive(Debug, Clone)]
pub struct TimestampMatch {
    pub original: String,
    pub format_type: TimestampFormat,
    pub start_pos: usize,
    pub end_pos: usize,
}

/// Supported timestamp formats for constitutional compliance
#[derive(Debug, Clone, Hash, Eq, PartialEq)]
pub enum TimestampFormat {
    // ISO 8601 variants
    ISO8601Full, // 2025-09-28T10:15:00Z
    ISO8601NoZ,  // 2025-09-28T10:15:00
    ISO8601Date, // 2025-09-28
    ISO8601Time, // 10:15:00

    // RFC 3339 variants
    RFC3339,    // 2025-09-28T10:15:00.123Z
    RFC3339NoZ, // 2025-09-28T10:15:00.123

    // Syslog formats
    SyslogBSD,     // Sep 28 10:15:00
    SyslogRFC5424, // 2025-09-28T10:15:00.123456Z

    // Apache/Nginx formats
    ApacheCommon, // [28/Sep/2025:10:15:00 +0000]
    ApacheError,  // [Sun Sep 28 10:15:00.123456 2025]
    NginxAccess,  // 28/Sep/2025:10:15:00 +0000

    // Application-specific formats
    JavaSimpleDate,   // Sep 28, 2025 10:15:00 AM
    KubernetesLog,    // 2025-09-28T10:15:00.123456789Z
    ElasticsearchLog, // 2025-09-28 10:15:00,123
    DockerLog,        // 2025-09-28T10:15:00.123456789Z

    // Unix timestamps
    UnixTimestamp,   // 1727515000
    UnixTimestampMs, // 1727515000123
    UnixTimestampNs, // 1727515000123456789

    // Database formats
    MySQLTimestamp,      // 2025-09-28 10:15:00
    PostgreSQLTimestamp, // 2025-09-28 10:15:00.123456

    // Windows formats
    WindowsEvent, // 9/28/2025 10:15:00 AM
    WindowsIIS,   // 2025-09-28 10:15:00

    // Custom application formats
    GitCommit, // Sep 28 10:15:00 2025
    Aws,       // 2025-09-28T10:15:00.000Z
    Gcp,       // 2025-09-28T10:15:00.123456Z
    Azure,     // 2025-09-28T10:15:00.1234567Z

    // Relative time formats
    RelativeTime, // "2 hours ago", "yesterday"
    Duration,     // "1h2m3s", "5 minutes"

    // Other common formats
    CFormat, // Sep 28 10:15:00
    RFC822,  // Sun, 28 Sep 2025 10:15:00 GMT
    RFC850,  // Sunday, 28-Sep-25 10:15:00 GMT
    Ansic,   // Sun Sep 28 10:15:00 2025
}

/// Essence mode error types
#[derive(Debug, Clone)]
pub enum EssenceModeError {
    InvalidConfiguration(String),
    PatternCompilationError(String),
    ProcessingError(String),
    ConstitutionalViolation(String),
}

impl std::fmt::Display for EssenceModeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EssenceModeError::InvalidConfiguration(msg) => {
                write!(f, "Invalid essence mode configuration: {msg}")
            }
            EssenceModeError::PatternCompilationError(msg) => {
                write!(f, "Pattern compilation error: {msg}")
            }
            EssenceModeError::ProcessingError(msg) => {
                write!(f, "Processing error: {msg}")
            }
            EssenceModeError::ConstitutionalViolation(msg) => {
                write!(f, "Constitutional violation in essence mode: {msg}")
            }
        }
    }
}

impl std::error::Error for EssenceModeError {}