jfrs 0.2.5

Java Flight Recorder reader for Rust
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

//! Predefine JFR types for ease of parsing
//!
//! Related JMC code: [TypesImpl.java](https://github.com/openjdk/jmc/blob/8.2.0-ga/core/org.openjdk.jmc.flightrecorder.writer/src/main/java/org/openjdk/jmc/flightrecorder/writer/TypesImpl.java)
//! TODO: should refer TypeManager instead?

pub mod builtin {
    use serde::Deserialize;

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct JdkThread<'a> {
        // In JFR, strings are encoded as 5 types: utf8, char-array, constant-pool, empty, null
        // To allow null, string field must be always Option.
        // Also, currently all str are supposed to be borrowed from deserializer so must be &str (not String)
        pub os_name: Option<&'a str>,
        pub os_thread_id: i64,
        #[serde(default)]
        pub java_name: Option<&'a str>,
        #[serde(default)]
        pub java_thread_id: i64,
        #[serde(borrow)]
        pub group: Option<ThreadGroup<'a>>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct ThreadGroup<'a> {
        #[serde(borrow, default)]
        pub parent: Option<Box<ThreadGroup<'a>>>,
        pub name: Option<&'a str>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct StackTrace<'a> {
        #[serde(default)]
        pub truncated: bool,
        #[serde(borrow, default)]
        pub frames: Vec<Option<StackFrame<'a>>>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct StackFrame<'a> {
        #[serde(borrow)]
        pub method: Option<JdkMethod<'a>>,
        #[serde(default)]
        pub line_number: i32,
        #[serde(default)]
        pub bytecode_index: i32,
        #[serde(rename = "type", borrow)]
        pub frame_type: Option<FrameType<'a>>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct FrameType<'a> {
        pub description: Option<&'a str>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct JdkMethod<'a> {
        #[serde(rename = "type", borrow)]
        pub class: Option<Class<'a>>,
        #[serde(borrow)]
        pub name: Option<Symbol<'a>>,
        #[serde(borrow)]
        pub descriptor: Option<Symbol<'a>>,
        #[serde(default)]
        pub modifiers: i32,
        #[serde(default)]
        pub hidden: bool,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct Symbol<'a> {
        pub string: Option<&'a str>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct Class<'a> {
        #[serde(borrow, default)]
        pub class_loader: Option<ClassLoader<'a>>,
        #[serde(borrow)]
        pub name: Option<Symbol<'a>>,
        #[serde(borrow, default)]
        pub package: Option<Package<'a>>,
        #[serde(default)]
        pub modifiers: i32,
        #[serde(default)]
        pub hidden: bool,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct Package<'a> {
        #[serde(borrow)]
        pub name: Option<Symbol<'a>>,
        #[serde(borrow)]
        pub module: Option<Module<'a>>,
        #[serde(default)]
        pub exported: bool,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct Module<'a> {
        #[serde(borrow)]
        pub name: Option<Symbol<'a>>,
        #[serde(borrow)]
        pub version: Option<Symbol<'a>>,
        #[serde(borrow)]
        pub location: Symbol<'a>,
        #[serde(borrow, default)]
        pub class_loader: Option<ClassLoader<'a>>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct ClassLoader<'a> {
        #[serde(rename = "type", borrow, default)]
        pub class: Option<Box<Class<'a>>>,
        #[serde(borrow)]
        pub name: Option<Symbol<'a>>,
    }

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct ThreadState<'a> {
        pub name: Option<&'a str>,
    }
}

pub mod jdk {
    use super::builtin::*;
    use serde::Deserialize;

    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct ExecutionSample<'a> {
        #[serde(borrow)]
        pub sampled_thread: Option<JdkThread<'a>>,
        #[serde(borrow)]
        pub stack_trace: Option<StackTrace<'a>>,
        #[serde(borrow)]
        pub state: Option<ThreadState<'a>>,
    }
}