devrig 0.30.3

Local development orchestrator
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
159
160
161
162
163
164

use regex::Regex;

use crate::ui::logs::{LogLevel, LogLine};

/// Predicate chain for filtering log lines.
pub struct LogFilter {
    pub services: Vec<String>,
    pub min_level: Option<LogLevel>,
    pub include: Option<Regex>,
    pub exclude: Option<Regex>,
    pub stderr_only: bool,
}

impl LogFilter {
    pub fn new() -> Self {
        Self {
            services: Vec::new(),
            min_level: None,
            include: None,
            exclude: None,
            stderr_only: false,
        }
    }

    /// Returns true if the log line matches all filter predicates.
    pub fn matches(&self, line: &LogLine) -> bool {
        // Service filter
        if !self.services.is_empty() && !self.services.contains(&line.service) {
            return false;
        }

        // Level filter
        if let Some(min) = &self.min_level {
            if let Some(level) = &line.level {
                if level < min {
                    return false;
                }
            }
        }

        // Include pattern
        if let Some(ref re) = self.include {
            if !re.is_match(&line.text) {
                return false;
            }
        }

        // Exclude pattern
        if let Some(ref re) = self.exclude {
            if re.is_match(&line.text) {
                return false;
            }
        }

        // Stderr only
        if self.stderr_only && !line.is_stderr {
            return false;
        }

        true
    }
}

impl Default for LogFilter {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;

    fn make_line(service: &str, text: &str, level: Option<LogLevel>) -> LogLine {
        LogLine {
            timestamp: Utc::now(),
            service: service.to_string(),
            text: text.to_string(),
            is_stderr: false,
            level,
        }
    }

    #[test]
    fn empty_filter_matches_all() {
        let filter = LogFilter::new();
        assert!(filter.matches(&make_line("api", "hello", None)));
        assert!(filter.matches(&make_line("web", "world", Some(LogLevel::Error))));
    }

    #[test]
    fn service_filter() {
        let filter = LogFilter {
            services: vec!["api".to_string()],
            ..LogFilter::new()
        };
        assert!(filter.matches(&make_line("api", "hello", None)));
        assert!(!filter.matches(&make_line("web", "hello", None)));
    }

    #[test]
    fn level_filter() {
        let filter = LogFilter {
            min_level: Some(LogLevel::Warn),
            ..LogFilter::new()
        };
        assert!(filter.matches(&make_line("api", "error msg", Some(LogLevel::Error))));
        assert!(filter.matches(&make_line("api", "warn msg", Some(LogLevel::Warn))));
        assert!(!filter.matches(&make_line("api", "info msg", Some(LogLevel::Info))));
        // Lines without a level should pass
        assert!(filter.matches(&make_line("api", "plain msg", None)));
    }

    #[test]
    fn regex_include() {
        let filter = LogFilter {
            include: Some(Regex::new("startup").unwrap()),
            ..LogFilter::new()
        };
        assert!(filter.matches(&make_line("api", "startup complete", None)));
        assert!(!filter.matches(&make_line("api", "processing request", None)));
    }

    #[test]
    fn regex_exclude() {
        let filter = LogFilter {
            exclude: Some(Regex::new("health").unwrap()),
            ..LogFilter::new()
        };
        assert!(filter.matches(&make_line("api", "request handled", None)));
        assert!(!filter.matches(&make_line("api", "health check ok", None)));
    }

    #[test]
    fn combined_filters() {
        let filter = LogFilter {
            services: vec!["api".to_string()],
            min_level: Some(LogLevel::Warn),
            include: Some(Regex::new("database").unwrap()),
            ..LogFilter::new()
        };
        // Matches: correct service, high enough level, contains "database"
        assert!(filter.matches(&make_line("api", "database error", Some(LogLevel::Error))));
        // Wrong service
        assert!(!filter.matches(&make_line("web", "database error", Some(LogLevel::Error))));
        // Level too low
        assert!(!filter.matches(&make_line("api", "database info", Some(LogLevel::Info))));
        // Doesn't match pattern
        assert!(!filter.matches(&make_line("api", "cache error", Some(LogLevel::Error))));
    }

    #[test]
    fn stderr_only_filter() {
        let filter = LogFilter {
            stderr_only: true,
            ..LogFilter::new()
        };
        let mut line = make_line("api", "error output", None);
        assert!(!filter.matches(&line));
        line.is_stderr = true;
        assert!(filter.matches(&line));
    }
}