tailtales 0.2.3

Flexible log viewer for logfmt and other formats with LUA scripting, filtering, filtering expressions, and real-time pipe following.
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

extern crate lazy_static;
use rand::prelude::*;
use std::{collections::HashMap, sync::Mutex};

use lazy_static::lazy_static;
use regex::Regex;

pub struct RegexCache {
    pub cache: Mutex<HashMap<String, Option<Regex>>>,
    pub capacity: usize,
}

lazy_static! {
    pub static ref REGEX_CACHE: RegexCache = RegexCache::new(100);
}

impl RegexCache {
    pub fn new(capacity: usize) -> Self {
        RegexCache {
            cache: Mutex::new(HashMap::new()),
            capacity,
        }
    }

    // pub fn get_regex(&self, pattern: &str) -> Option<Regex> {
    //     let mut cache = self.cache.lock().unwrap();
    //     if let Some(re) = cache.get(pattern) {
    //         return re.clone();
    //     }
    //     let re = Regex::new(pattern).ok();
    //     cache.insert(pattern.to_string(), re.clone());
    //     re
    // }

    pub fn matches(&self, pattern: &str, text: &str) -> bool {
        self.gc();
        let mut cache = self.cache.lock().unwrap();
        if let Some(re) = cache.get(pattern) {
            if let Some(re) = re {
                return re.is_match(text);
            }
            return false;
        }
        let re = Regex::new(pattern).ok();
        cache.insert(pattern.to_string(), re.clone());
        if let Some(re) = re {
            return re.is_match(text);
        } else {
            return false;
        }
    }

    pub fn gc(&self) {
        let mut cache = self.cache.lock().unwrap();
        let mut rng = thread_rng();
        while cache.len() > self.capacity {
            // random remove one
            let keys: Vec<String> = cache.keys().cloned().collect();
            let random_index = rng.gen_range(0..keys.len());

            cache.remove(&keys[random_index]);
        }
    }
}

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

    #[test]
    fn test_regex_cache() {
        let cache = RegexCache::new(10);
        // let re = cache.get_regex(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}");
        // assert_eq!(
        //     re.unwrap().as_str(),
        //     r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}"
        // );

        assert!(cache.matches(
            r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}",
            "2021-07-01 12:34:56"
        ));
    }
}