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#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
21#[serde(rename_all = "lowercase")]
22#[derive(Default)]
23pub enum StreamFormat {
24 #[default]
26 Json,
27 Proto,
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
33#[serde(rename_all = "lowercase")]
34#[derive(Default)]
35pub enum StreamCompression {
36 #[default]
38 None,
39 Gzip,
41}
42
43#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
45#[serde(rename_all = "lowercase")]
46#[derive(Default)]
47pub enum TracingBackend {
48 #[default]
50 Auto,
51 Chrome,
53 System,
55}
56
57#[derive(Debug, Clone, Serialize, Default)]
63#[serde(rename_all = "camelCase")]
64pub struct StartParams {
65 #[serde(skip_serializing_if = "Option::is_none")]
67 pub categories: Option<String>,
68 #[serde(skip_serializing_if = "Option::is_none")]
70 pub options: Option<String>,
71 #[serde(skip_serializing_if = "Option::is_none")]
73 pub buffer_usage_reporting_interval: Option<f64>,
74 #[serde(skip_serializing_if = "Option::is_none")]
76 pub transfer_mode: Option<TransferMode>,
77 #[serde(skip_serializing_if = "Option::is_none")]
79 pub stream_format: Option<StreamFormat>,
80 #[serde(skip_serializing_if = "Option::is_none")]
82 pub stream_compression: Option<StreamCompression>,
83 #[serde(skip_serializing_if = "Option::is_none")]
85 pub trace_config: Option<TraceConfig>,
86 #[serde(skip_serializing_if = "Option::is_none")]
88 pub perfetto_config: Option<String>,
89 #[serde(skip_serializing_if = "Option::is_none")]
91 pub tracing_backend: Option<TracingBackend>,
92}
93
94impl StartParams {
95 pub fn new() -> Self {
97 Self::default()
98 }
99
100 #[must_use]
102 pub fn categories(mut self, categories: impl Into<String>) -> Self {
103 self.categories = Some(categories.into());
104 self
105 }
106
107 #[must_use]
109 pub fn transfer_mode(mut self, mode: TransferMode) -> Self {
110 self.transfer_mode = Some(mode);
111 self
112 }
113
114 #[must_use]
116 pub fn stream_format(mut self, format: StreamFormat) -> Self {
117 self.stream_format = Some(format);
118 self
119 }
120
121 #[must_use]
123 pub fn trace_config(mut self, config: TraceConfig) -> Self {
124 self.trace_config = Some(config);
125 self
126 }
127}
128
129#[derive(Debug, Clone, Serialize, Default)]
131#[serde(rename_all = "camelCase")]
132pub struct TraceConfig {
133 #[serde(skip_serializing_if = "Option::is_none")]
135 pub record_mode: Option<String>,
136 #[serde(skip_serializing_if = "Option::is_none")]
138 pub trace_buffer_size_in_kb: Option<i32>,
139 #[serde(skip_serializing_if = "Option::is_none")]
141 pub enable_sampling: Option<bool>,
142 #[serde(skip_serializing_if = "Option::is_none")]
144 pub enable_systrace: Option<bool>,
145 #[serde(skip_serializing_if = "Option::is_none")]
147 pub enable_argument_filter: Option<bool>,
148 #[serde(skip_serializing_if = "Option::is_none")]
150 pub included_categories: Option<Vec<String>>,
151 #[serde(skip_serializing_if = "Option::is_none")]
153 pub excluded_categories: Option<Vec<String>>,
154 #[serde(skip_serializing_if = "Option::is_none")]
156 pub synthetic_delays: Option<Vec<String>>,
157 #[serde(skip_serializing_if = "Option::is_none")]
159 pub memory_dump_config: Option<serde_json::Value>,
160}
161
162impl TraceConfig {
163 pub fn new() -> Self {
165 Self::default()
166 }
167
168 #[must_use]
170 pub fn included_categories(mut self, categories: Vec<String>) -> Self {
171 self.included_categories = Some(categories);
172 self
173 }
174
175 #[must_use]
177 pub fn include_category(mut self, category: impl Into<String>) -> Self {
178 let categories = self.included_categories.get_or_insert_with(Vec::new);
179 categories.push(category.into());
180 self
181 }
182
183 #[must_use]
185 pub fn excluded_categories(mut self, categories: Vec<String>) -> Self {
186 self.excluded_categories = Some(categories);
187 self
188 }
189
190 #[must_use]
192 pub fn record_mode(mut self, mode: impl Into<String>) -> Self {
193 self.record_mode = Some(mode.into());
194 self
195 }
196}
197
198#[derive(Debug, Clone, Serialize, Default)]
204pub struct EndParams {}
205
206#[derive(Debug, Clone, Deserialize)]
208#[serde(rename_all = "camelCase")]
209pub struct EndResult {
210 pub stream: Option<String>,
212 pub stream_compression: Option<StreamCompression>,
214}
215
216#[derive(Debug, Clone, Serialize, Default)]
222pub struct GetCategoriesParams {}
223
224#[derive(Debug, Clone, Deserialize)]
226pub struct GetCategoriesResult {
227 pub categories: Vec<String>,
229}
230
231#[derive(Debug, Clone, Serialize)]
237#[serde(rename_all = "camelCase")]
238pub struct RecordClockSyncMarkerParams {
239 pub sync_id: String,
241}
242
243#[derive(Debug, Clone, Serialize, Default)]
249#[serde(rename_all = "camelCase")]
250pub struct RequestMemoryDumpParams {
251 #[serde(skip_serializing_if = "Option::is_none")]
253 pub deterministic: Option<bool>,
254 #[serde(skip_serializing_if = "Option::is_none")]
256 pub level_of_detail: Option<String>,
257}
258
259#[derive(Debug, Clone, Deserialize)]
261#[serde(rename_all = "camelCase")]
262pub struct RequestMemoryDumpResult {
263 pub dump_guid: String,
265 pub success: bool,
267}
268
269#[derive(Debug, Clone, Deserialize)]
277pub struct DataCollectedEvent {
278 pub value: Vec<serde_json::Value>,
280}
281
282#[derive(Debug, Clone, Deserialize)]
286#[serde(rename_all = "camelCase")]
287pub struct TracingCompleteEvent {
288 pub stream: Option<String>,
290 pub stream_compression: Option<StreamCompression>,
292 pub stream_format: Option<StreamFormat>,
294}
295
296#[derive(Debug, Clone, Deserialize)]
300#[serde(rename_all = "camelCase")]
301pub struct BufferUsageEvent {
302 pub percent_full: Option<f64>,
304 pub event_count: Option<f64>,
306 pub value: Option<f64>,
308}