kelora 1.5.0

A command-line log analysis tool with embedded Rhai scripting
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

use chrono::{DateTime, Utc};
use rhai::{Array, Dynamic, Engine, Map};

use crate::event::Event;
use crate::rhai_functions::datetime::DateTimeWrapper;

#[derive(Clone)]
pub struct SpanBinding {
    span_id: String,
    span_start: Option<DateTime<Utc>>,
    span_end: Option<DateTime<Utc>>,
    events: Array,
    size: i64,
    metrics: Map,
}

impl SpanBinding {
    pub fn new(
        span_id: String,
        span_start: Option<DateTime<Utc>>,
        span_end: Option<DateTime<Utc>>,
        events: &[Event],
        metrics: Map,
    ) -> Self {
        let event_maps = events
            .iter()
            .map(event_to_map)
            .map(Dynamic::from)
            .collect::<Array>();

        Self {
            span_id,
            span_start,
            span_end,
            events: event_maps,
            metrics,
            size: events.len() as i64,
        }
    }

    pub fn get_id(&mut self) -> String {
        self.span_id.clone()
    }

    pub fn get_start(&mut self) -> Dynamic {
        match self.span_start {
            Some(dt) => Dynamic::from(DateTimeWrapper::from_utc(dt)),
            None => Dynamic::UNIT,
        }
    }

    pub fn get_end(&mut self) -> Dynamic {
        match self.span_end {
            Some(dt) => Dynamic::from(DateTimeWrapper::from_utc(dt)),
            None => Dynamic::UNIT,
        }
    }

    pub fn get_size(&mut self) -> i64 {
        self.size
    }

    pub fn get_events(&mut self) -> Array {
        self.events.clone()
    }

    pub fn get_metrics(&mut self) -> Map {
        self.metrics.clone()
    }
}

pub fn register_functions(engine: &mut Engine) {
    engine.register_type_with_name::<SpanBinding>("Span");
    engine.register_get("id", SpanBinding::get_id);
    engine.register_get("start", SpanBinding::get_start);
    engine.register_get("end", SpanBinding::get_end);
    engine.register_get("size", SpanBinding::get_size);
    engine.register_get("events", SpanBinding::get_events);
    engine.register_get("metrics", SpanBinding::get_metrics);
}

fn event_to_map(event: &Event) -> Map {
    let mut map = Map::new();

    for (k, v) in &event.fields {
        map.insert(k.clone().into(), v.clone());
    }

    map.insert("line".into(), Dynamic::from(event.original_line.clone()));

    if let Some(line_num) = event.line_num {
        map.insert("line_num".into(), Dynamic::from(line_num as i64));
    }

    if let Some(filename) = &event.filename {
        map.insert("filename".into(), Dynamic::from(filename.clone()));
    }

    if let Some(status) = event.span.status {
        map.insert("span_status".into(), Dynamic::from(status.as_str()));
    }

    if let Some(span_id) = &event.span.span_id {
        map.insert("span_id".into(), Dynamic::from(span_id.clone()));
    }

    if let Some(span_start) = event.span.span_start {
        map.insert(
            "span_start".into(),
            Dynamic::from(DateTimeWrapper::from_utc(span_start)),
        );
    }

    if let Some(span_end) = event.span.span_end {
        map.insert(
            "span_end".into(),
            Dynamic::from(DateTimeWrapper::from_utc(span_end)),
        );
    }

    map
}