jlf 0.3.1

CLI for converting JSON logs to human-readable format
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

use std::hint::black_box;

use criterion::{criterion_group, criterion_main, Criterion};
use jlf::{parse_json, Json};
use serde::Deserialize;
use serde_json::Value;

const INPUTS: &[&str] = &[
    r#"{"timestamp":"2024-02-06T23:52:48.349676Z","level":"INFO","message":"This is a info log","target":"my_service::my_module::my_api","filename":"my-service/src/my_module.rs","line_number":77,"spans":[{"name":"my_service"},{"name":"my_func"},{"name":"my_api1"},{"name":"something"}]}"#,
    r#"{"timestamp":"2024-02-07T23:52:48.349676Z","level":"DEBUG","message":"This is a debug log","target":"my_service::my_module::my_api2","filename":"my-service/src/my_module.rs","line_number":78,"spans":[{"name":"my_service"},{"name":"my_func"},{"name":"my_api2"},{"name":"something"},{"name":"some other value"}]}"#,
    r#"{"timestamp":"2024-02-07T23:52:48.349676Z","level":"ERROR","message":"This is an error log","target":"my_service::my_module::my_api3","filename":"my-service/src/my_module.rs","line_number":78,"spans":[{"name":"my_service"}]}"#,
];

fn custom_parse<'a>(value: &mut Json<'a>, inputs: &'a [&'a str]) {
    for input in inputs {
        value.parse_replace(input).unwrap();
        // assert!(value
        //     .get("timestamp")
        //     .as_value()
        //     .unwrap()
        //     .starts_with("\"2024"));
        // assert!(value
        //     .get("spans")
        //     .get_i(0)
        //     .get("name")
        //     .as_value()
        //     .unwrap()
        //     .starts_with("\"my_service\""));
    }
}

fn serde_value_parse(value: &mut Value, inputs: &[&str]) {
    for input in inputs {
        *value = serde_json::from_str(input).unwrap();
        // assert!(value
        //     .get("timestamp")
        //     .unwrap()
        //     .as_str()
        //     .unwrap()
        //     .starts_with("2024"));
        // assert!(value
        //     .get("spans")
        //     .unwrap()
        //     .get(0)
        //     .unwrap()
        //     .get("name")
        //     .unwrap()
        //     .as_str()
        //     .unwrap()
        //     .starts_with("my_service"));
    }
}

#[allow(dead_code)]
#[derive(Deserialize)]
pub struct Log<'a> {
    timestamp: &'a str,
    level: &'a str,
    message: &'a str,
    target: &'a str,
    filename: &'a str,
    line_number: u32,
    spans: Vec<Span<'a>>,
}

#[allow(dead_code)]
#[derive(Deserialize)]
struct Span<'a> {
    name: &'a str,
}

fn serde_structured_parse<'a>(value: &mut Log<'a>, inputs: &[&'a str]) {
    for input in inputs {
        *value = serde_json::from_str(input).unwrap();
        // assert!(value.timestamp.starts_with("2024"));
        // assert!(value
        //     .spans
        //     .get(0)
        //     .unwrap()
        //     .get("name")
        //     .unwrap()
        //     .as_str()
        //     .unwrap()
        //     .starts_with("my_service"));
    }
}

fn custom_parse_bench(c: &mut Criterion) {
    let mut value = parse_json(INPUTS[0]).unwrap();

    c.bench_function("custom parse", |b| {
        b.iter(|| custom_parse(black_box(&mut value), black_box(INPUTS)))
    });
}

fn serde_value_parse_bench(c: &mut Criterion) {
    let mut value = Value::Null;

    c.bench_function("serde value parse", |b| {
        b.iter(|| serde_value_parse(black_box(&mut value), black_box(INPUTS)))
    });
}

#[allow(dead_code)]
fn serde_json_from_str_in_place<'a, T: serde::de::Deserialize<'a>>(
    s: &'a str,
    value: &mut T,
) -> serde_json::Result<()> {
    let read = serde_json::de::StrRead::new(s);
    let mut de = serde_json::Deserializer::new(read);

    T::deserialize_in_place(&mut de, value).and_then(|_| de.end())
}

fn serde_structured_parse_bench(c: &mut Criterion) {
    let mut value = serde_json::from_str(INPUTS[0]).unwrap();

    c.bench_function("serde structured parse", |b| {
        b.iter(|| serde_structured_parse(black_box(&mut value), black_box(INPUTS)))
    });
}

criterion_group!(
    benches,
    custom_parse_bench,
    serde_value_parse_bench,
    serde_structured_parse_bench
);
criterion_main!(benches);