viewpoint_cdp/protocol/tracing/
mod.rs1use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10#[derive(Default)]
11pub enum TransferMode {
12 #[default]
14 ReportEvents,
15 ReturnAsStream,
17}
18
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
22#[serde(rename_all = "lowercase")]
23#[derive(Default)]
24pub enum StreamFormat {
25 #[default]
27 Json,
28 Proto,
30}
31
32
33#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
35#[serde(rename_all = "lowercase")]
36#[derive(Default)]
37pub enum StreamCompression {
38 #[default]
40 None,
41 Gzip,
43}
44
45
46#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
48#[serde(rename_all = "lowercase")]
49#[derive(Default)]
50pub enum TracingBackend {
51 #[default]
53 Auto,
54 Chrome,
56 System,
58}
59
60
61#[derive(Debug, Clone, Serialize, Default)]
67#[serde(rename_all = "camelCase")]
68pub struct StartParams {
69 #[serde(skip_serializing_if = "Option::is_none")]
71 pub categories: Option<String>,
72 #[serde(skip_serializing_if = "Option::is_none")]
74 pub options: Option<String>,
75 #[serde(skip_serializing_if = "Option::is_none")]
77 pub buffer_usage_reporting_interval: Option<f64>,
78 #[serde(skip_serializing_if = "Option::is_none")]
80 pub transfer_mode: Option<TransferMode>,
81 #[serde(skip_serializing_if = "Option::is_none")]
83 pub stream_format: Option<StreamFormat>,
84 #[serde(skip_serializing_if = "Option::is_none")]
86 pub stream_compression: Option<StreamCompression>,
87 #[serde(skip_serializing_if = "Option::is_none")]
89 pub trace_config: Option<TraceConfig>,
90 #[serde(skip_serializing_if = "Option::is_none")]
92 pub perfetto_config: Option<String>,
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub tracing_backend: Option<TracingBackend>,
96}
97
98impl StartParams {
99 pub fn new() -> Self {
101 Self::default()
102 }
103
104 #[must_use]
106 pub fn categories(mut self, categories: impl Into<String>) -> Self {
107 self.categories = Some(categories.into());
108 self
109 }
110
111 #[must_use]
113 pub fn transfer_mode(mut self, mode: TransferMode) -> Self {
114 self.transfer_mode = Some(mode);
115 self
116 }
117
118 #[must_use]
120 pub fn stream_format(mut self, format: StreamFormat) -> Self {
121 self.stream_format = Some(format);
122 self
123 }
124
125 #[must_use]
127 pub fn trace_config(mut self, config: TraceConfig) -> Self {
128 self.trace_config = Some(config);
129 self
130 }
131}
132
133#[derive(Debug, Clone, Serialize, Default)]
135#[serde(rename_all = "camelCase")]
136pub struct TraceConfig {
137 #[serde(skip_serializing_if = "Option::is_none")]
139 pub record_mode: Option<String>,
140 #[serde(skip_serializing_if = "Option::is_none")]
142 pub trace_buffer_size_in_kb: Option<i32>,
143 #[serde(skip_serializing_if = "Option::is_none")]
145 pub enable_sampling: Option<bool>,
146 #[serde(skip_serializing_if = "Option::is_none")]
148 pub enable_systrace: Option<bool>,
149 #[serde(skip_serializing_if = "Option::is_none")]
151 pub enable_argument_filter: Option<bool>,
152 #[serde(skip_serializing_if = "Option::is_none")]
154 pub included_categories: Option<Vec<String>>,
155 #[serde(skip_serializing_if = "Option::is_none")]
157 pub excluded_categories: Option<Vec<String>>,
158 #[serde(skip_serializing_if = "Option::is_none")]
160 pub synthetic_delays: Option<Vec<String>>,
161 #[serde(skip_serializing_if = "Option::is_none")]
163 pub memory_dump_config: Option<serde_json::Value>,
164}
165
166impl TraceConfig {
167 pub fn new() -> Self {
169 Self::default()
170 }
171
172 #[must_use]
174 pub fn included_categories(mut self, categories: Vec<String>) -> Self {
175 self.included_categories = Some(categories);
176 self
177 }
178
179 #[must_use]
181 pub fn include_category(mut self, category: impl Into<String>) -> Self {
182 let categories = self.included_categories.get_or_insert_with(Vec::new);
183 categories.push(category.into());
184 self
185 }
186
187 #[must_use]
189 pub fn excluded_categories(mut self, categories: Vec<String>) -> Self {
190 self.excluded_categories = Some(categories);
191 self
192 }
193
194 #[must_use]
196 pub fn record_mode(mut self, mode: impl Into<String>) -> Self {
197 self.record_mode = Some(mode.into());
198 self
199 }
200}
201
202#[derive(Debug, Clone, Serialize, Default)]
208pub struct EndParams {}
209
210#[derive(Debug, Clone, Deserialize)]
212#[serde(rename_all = "camelCase")]
213pub struct EndResult {
214 pub stream: Option<String>,
216 pub stream_compression: Option<StreamCompression>,
218}
219
220#[derive(Debug, Clone, Serialize, Default)]
226pub struct GetCategoriesParams {}
227
228#[derive(Debug, Clone, Deserialize)]
230pub struct GetCategoriesResult {
231 pub categories: Vec<String>,
233}
234
235#[derive(Debug, Clone, Serialize)]
241#[serde(rename_all = "camelCase")]
242pub struct RecordClockSyncMarkerParams {
243 pub sync_id: String,
245}
246
247#[derive(Debug, Clone, Serialize, Default)]
253#[serde(rename_all = "camelCase")]
254pub struct RequestMemoryDumpParams {
255 #[serde(skip_serializing_if = "Option::is_none")]
257 pub deterministic: Option<bool>,
258 #[serde(skip_serializing_if = "Option::is_none")]
260 pub level_of_detail: Option<String>,
261}
262
263#[derive(Debug, Clone, Deserialize)]
265#[serde(rename_all = "camelCase")]
266pub struct RequestMemoryDumpResult {
267 pub dump_guid: String,
269 pub success: bool,
271}
272
273#[derive(Debug, Clone, Deserialize)]
281pub struct DataCollectedEvent {
282 pub value: Vec<serde_json::Value>,
284}
285
286#[derive(Debug, Clone, Deserialize)]
290#[serde(rename_all = "camelCase")]
291pub struct TracingCompleteEvent {
292 pub stream: Option<String>,
294 pub stream_compression: Option<StreamCompression>,
296 pub stream_format: Option<StreamFormat>,
298}
299
300#[derive(Debug, Clone, Deserialize)]
304#[serde(rename_all = "camelCase")]
305pub struct BufferUsageEvent {
306 pub percent_full: Option<f64>,
308 pub event_count: Option<f64>,
310 pub value: Option<f64>,
312}