1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::telemetry::*;
4impl serde::Serialize for BatchEventMessage {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.events.is_empty() {
13 len += 1;
14 }
15 let mut struct_ser = serializer.serialize_struct("telemetry.BatchEventMessage", len)?;
16 if !self.events.is_empty() {
17 struct_ser.serialize_field("events", &self.events)?;
18 }
19 struct_ser.end()
20 }
21}
22impl<'de> serde::Deserialize<'de> for BatchEventMessage {
23 #[allow(deprecated)]
24 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
25 where
26 D: serde::Deserializer<'de>,
27 {
28 const FIELDS: &[&str] = &[
29 "events",
30 ];
31
32 #[allow(clippy::enum_variant_names)]
33 enum GeneratedField {
34 Events,
35 }
36 impl<'de> serde::Deserialize<'de> for GeneratedField {
37 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
38 where
39 D: serde::Deserializer<'de>,
40 {
41 struct GeneratedVisitor;
42
43 impl serde::de::Visitor<'_> for GeneratedVisitor {
44 type Value = GeneratedField;
45
46 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 write!(formatter, "expected one of: {:?}", &FIELDS)
48 }
49
50 #[allow(unused_variables)]
51 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
52 where
53 E: serde::de::Error,
54 {
55 match value {
56 "events" => Ok(GeneratedField::Events),
57 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
58 }
59 }
60 }
61 deserializer.deserialize_identifier(GeneratedVisitor)
62 }
63 }
64 struct GeneratedVisitor;
65 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
66 type Value = BatchEventMessage;
67
68 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69 formatter.write_str("struct telemetry.BatchEventMessage")
70 }
71
72 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchEventMessage, V::Error>
73 where
74 V: serde::de::MapAccess<'de>,
75 {
76 let mut events__ = None;
77 while let Some(k) = map_.next_key()? {
78 match k {
79 GeneratedField::Events => {
80 if events__.is_some() {
81 return Err(serde::de::Error::duplicate_field("events"));
82 }
83 events__ = Some(map_.next_value()?);
84 }
85 }
86 }
87 Ok(BatchEventMessage {
88 events: events__.unwrap_or_default(),
89 })
90 }
91 }
92 deserializer.deserialize_struct("telemetry.BatchEventMessage", FIELDS, GeneratedVisitor)
93 }
94}
95impl serde::Serialize for CompactorReport {
96 #[allow(deprecated)]
97 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
98 where
99 S: serde::Serializer,
100 {
101 use serde::ser::SerializeStruct;
102 let mut len = 0;
103 if self.base.is_some() {
104 len += 1;
105 }
106 let mut struct_ser = serializer.serialize_struct("telemetry.CompactorReport", len)?;
107 if let Some(v) = self.base.as_ref() {
108 struct_ser.serialize_field("base", v)?;
109 }
110 struct_ser.end()
111 }
112}
113impl<'de> serde::Deserialize<'de> for CompactorReport {
114 #[allow(deprecated)]
115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
116 where
117 D: serde::Deserializer<'de>,
118 {
119 const FIELDS: &[&str] = &[
120 "base",
121 ];
122
123 #[allow(clippy::enum_variant_names)]
124 enum GeneratedField {
125 Base,
126 }
127 impl<'de> serde::Deserialize<'de> for GeneratedField {
128 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
129 where
130 D: serde::Deserializer<'de>,
131 {
132 struct GeneratedVisitor;
133
134 impl serde::de::Visitor<'_> for GeneratedVisitor {
135 type Value = GeneratedField;
136
137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138 write!(formatter, "expected one of: {:?}", &FIELDS)
139 }
140
141 #[allow(unused_variables)]
142 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
143 where
144 E: serde::de::Error,
145 {
146 match value {
147 "base" => Ok(GeneratedField::Base),
148 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
149 }
150 }
151 }
152 deserializer.deserialize_identifier(GeneratedVisitor)
153 }
154 }
155 struct GeneratedVisitor;
156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
157 type Value = CompactorReport;
158
159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
160 formatter.write_str("struct telemetry.CompactorReport")
161 }
162
163 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactorReport, V::Error>
164 where
165 V: serde::de::MapAccess<'de>,
166 {
167 let mut base__ = None;
168 while let Some(k) = map_.next_key()? {
169 match k {
170 GeneratedField::Base => {
171 if base__.is_some() {
172 return Err(serde::de::Error::duplicate_field("base"));
173 }
174 base__ = map_.next_value()?;
175 }
176 }
177 }
178 Ok(CompactorReport {
179 base: base__,
180 })
181 }
182 }
183 deserializer.deserialize_struct("telemetry.CompactorReport", FIELDS, GeneratedVisitor)
184 }
185}
186impl serde::Serialize for ComputeReport {
187 #[allow(deprecated)]
188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
189 where
190 S: serde::Serializer,
191 {
192 use serde::ser::SerializeStruct;
193 let mut len = 0;
194 if self.base.is_some() {
195 len += 1;
196 }
197 let mut struct_ser = serializer.serialize_struct("telemetry.ComputeReport", len)?;
198 if let Some(v) = self.base.as_ref() {
199 struct_ser.serialize_field("base", v)?;
200 }
201 struct_ser.end()
202 }
203}
204impl<'de> serde::Deserialize<'de> for ComputeReport {
205 #[allow(deprecated)]
206 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
207 where
208 D: serde::Deserializer<'de>,
209 {
210 const FIELDS: &[&str] = &[
211 "base",
212 ];
213
214 #[allow(clippy::enum_variant_names)]
215 enum GeneratedField {
216 Base,
217 }
218 impl<'de> serde::Deserialize<'de> for GeneratedField {
219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
220 where
221 D: serde::Deserializer<'de>,
222 {
223 struct GeneratedVisitor;
224
225 impl serde::de::Visitor<'_> for GeneratedVisitor {
226 type Value = GeneratedField;
227
228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
229 write!(formatter, "expected one of: {:?}", &FIELDS)
230 }
231
232 #[allow(unused_variables)]
233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
234 where
235 E: serde::de::Error,
236 {
237 match value {
238 "base" => Ok(GeneratedField::Base),
239 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
240 }
241 }
242 }
243 deserializer.deserialize_identifier(GeneratedVisitor)
244 }
245 }
246 struct GeneratedVisitor;
247 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
248 type Value = ComputeReport;
249
250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
251 formatter.write_str("struct telemetry.ComputeReport")
252 }
253
254 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ComputeReport, V::Error>
255 where
256 V: serde::de::MapAccess<'de>,
257 {
258 let mut base__ = None;
259 while let Some(k) = map_.next_key()? {
260 match k {
261 GeneratedField::Base => {
262 if base__.is_some() {
263 return Err(serde::de::Error::duplicate_field("base"));
264 }
265 base__ = map_.next_value()?;
266 }
267 }
268 }
269 Ok(ComputeReport {
270 base: base__,
271 })
272 }
273 }
274 deserializer.deserialize_struct("telemetry.ComputeReport", FIELDS, GeneratedVisitor)
275 }
276}
277impl serde::Serialize for EventMessage {
278 #[allow(deprecated)]
279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
280 where
281 S: serde::Serializer,
282 {
283 use serde::ser::SerializeStruct;
284 let mut len = 0;
285 if !self.tracking_id.is_empty() {
286 len += 1;
287 }
288 if self.event_time_sec != 0 {
289 len += 1;
290 }
291 if self.event_stage != 0 {
292 len += 1;
293 }
294 if !self.event_name.is_empty() {
295 len += 1;
296 }
297 if self.connector_name.is_some() {
298 len += 1;
299 }
300 if self.object.is_some() {
301 len += 1;
302 }
303 if self.catalog_id != 0 {
304 len += 1;
305 }
306 if self.attributes.is_some() {
307 len += 1;
308 }
309 if !self.node.is_empty() {
310 len += 1;
311 }
312 if self.is_test {
313 len += 1;
314 }
315 let mut struct_ser = serializer.serialize_struct("telemetry.EventMessage", len)?;
316 if !self.tracking_id.is_empty() {
317 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
318 }
319 if self.event_time_sec != 0 {
320 #[allow(clippy::needless_borrow)]
321 #[allow(clippy::needless_borrows_for_generic_args)]
322 struct_ser.serialize_field("eventTimeSec", ToString::to_string(&self.event_time_sec).as_str())?;
323 }
324 if self.event_stage != 0 {
325 let v = TelemetryEventStage::try_from(self.event_stage)
326 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.event_stage)))?;
327 struct_ser.serialize_field("eventStage", &v)?;
328 }
329 if !self.event_name.is_empty() {
330 struct_ser.serialize_field("eventName", &self.event_name)?;
331 }
332 if let Some(v) = self.connector_name.as_ref() {
333 struct_ser.serialize_field("connectorName", v)?;
334 }
335 if let Some(v) = self.object.as_ref() {
336 let v = TelemetryDatabaseObject::try_from(*v)
337 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
338 struct_ser.serialize_field("object", &v)?;
339 }
340 if self.catalog_id != 0 {
341 #[allow(clippy::needless_borrow)]
342 #[allow(clippy::needless_borrows_for_generic_args)]
343 struct_ser.serialize_field("catalogId", ToString::to_string(&self.catalog_id).as_str())?;
344 }
345 if let Some(v) = self.attributes.as_ref() {
346 struct_ser.serialize_field("attributes", v)?;
347 }
348 if !self.node.is_empty() {
349 struct_ser.serialize_field("node", &self.node)?;
350 }
351 if self.is_test {
352 struct_ser.serialize_field("isTest", &self.is_test)?;
353 }
354 struct_ser.end()
355 }
356}
357impl<'de> serde::Deserialize<'de> for EventMessage {
358 #[allow(deprecated)]
359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
360 where
361 D: serde::Deserializer<'de>,
362 {
363 const FIELDS: &[&str] = &[
364 "tracking_id",
365 "trackingId",
366 "event_time_sec",
367 "eventTimeSec",
368 "event_stage",
369 "eventStage",
370 "event_name",
371 "eventName",
372 "connector_name",
373 "connectorName",
374 "object",
375 "catalog_id",
376 "catalogId",
377 "attributes",
378 "node",
379 "is_test",
380 "isTest",
381 ];
382
383 #[allow(clippy::enum_variant_names)]
384 enum GeneratedField {
385 TrackingId,
386 EventTimeSec,
387 EventStage,
388 EventName,
389 ConnectorName,
390 Object,
391 CatalogId,
392 Attributes,
393 Node,
394 IsTest,
395 }
396 impl<'de> serde::Deserialize<'de> for GeneratedField {
397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
398 where
399 D: serde::Deserializer<'de>,
400 {
401 struct GeneratedVisitor;
402
403 impl serde::de::Visitor<'_> for GeneratedVisitor {
404 type Value = GeneratedField;
405
406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
407 write!(formatter, "expected one of: {:?}", &FIELDS)
408 }
409
410 #[allow(unused_variables)]
411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
412 where
413 E: serde::de::Error,
414 {
415 match value {
416 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
417 "eventTimeSec" | "event_time_sec" => Ok(GeneratedField::EventTimeSec),
418 "eventStage" | "event_stage" => Ok(GeneratedField::EventStage),
419 "eventName" | "event_name" => Ok(GeneratedField::EventName),
420 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
421 "object" => Ok(GeneratedField::Object),
422 "catalogId" | "catalog_id" => Ok(GeneratedField::CatalogId),
423 "attributes" => Ok(GeneratedField::Attributes),
424 "node" => Ok(GeneratedField::Node),
425 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
427 }
428 }
429 }
430 deserializer.deserialize_identifier(GeneratedVisitor)
431 }
432 }
433 struct GeneratedVisitor;
434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
435 type Value = EventMessage;
436
437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
438 formatter.write_str("struct telemetry.EventMessage")
439 }
440
441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventMessage, V::Error>
442 where
443 V: serde::de::MapAccess<'de>,
444 {
445 let mut tracking_id__ = None;
446 let mut event_time_sec__ = None;
447 let mut event_stage__ = None;
448 let mut event_name__ = None;
449 let mut connector_name__ = None;
450 let mut object__ = None;
451 let mut catalog_id__ = None;
452 let mut attributes__ = None;
453 let mut node__ = None;
454 let mut is_test__ = None;
455 while let Some(k) = map_.next_key()? {
456 match k {
457 GeneratedField::TrackingId => {
458 if tracking_id__.is_some() {
459 return Err(serde::de::Error::duplicate_field("trackingId"));
460 }
461 tracking_id__ = Some(map_.next_value()?);
462 }
463 GeneratedField::EventTimeSec => {
464 if event_time_sec__.is_some() {
465 return Err(serde::de::Error::duplicate_field("eventTimeSec"));
466 }
467 event_time_sec__ =
468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
469 ;
470 }
471 GeneratedField::EventStage => {
472 if event_stage__.is_some() {
473 return Err(serde::de::Error::duplicate_field("eventStage"));
474 }
475 event_stage__ = Some(map_.next_value::<TelemetryEventStage>()? as i32);
476 }
477 GeneratedField::EventName => {
478 if event_name__.is_some() {
479 return Err(serde::de::Error::duplicate_field("eventName"));
480 }
481 event_name__ = Some(map_.next_value()?);
482 }
483 GeneratedField::ConnectorName => {
484 if connector_name__.is_some() {
485 return Err(serde::de::Error::duplicate_field("connectorName"));
486 }
487 connector_name__ = map_.next_value()?;
488 }
489 GeneratedField::Object => {
490 if object__.is_some() {
491 return Err(serde::de::Error::duplicate_field("object"));
492 }
493 object__ = map_.next_value::<::std::option::Option<TelemetryDatabaseObject>>()?.map(|x| x as i32);
494 }
495 GeneratedField::CatalogId => {
496 if catalog_id__.is_some() {
497 return Err(serde::de::Error::duplicate_field("catalogId"));
498 }
499 catalog_id__ =
500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
501 ;
502 }
503 GeneratedField::Attributes => {
504 if attributes__.is_some() {
505 return Err(serde::de::Error::duplicate_field("attributes"));
506 }
507 attributes__ = map_.next_value()?;
508 }
509 GeneratedField::Node => {
510 if node__.is_some() {
511 return Err(serde::de::Error::duplicate_field("node"));
512 }
513 node__ = Some(map_.next_value()?);
514 }
515 GeneratedField::IsTest => {
516 if is_test__.is_some() {
517 return Err(serde::de::Error::duplicate_field("isTest"));
518 }
519 is_test__ = Some(map_.next_value()?);
520 }
521 }
522 }
523 Ok(EventMessage {
524 tracking_id: tracking_id__.unwrap_or_default(),
525 event_time_sec: event_time_sec__.unwrap_or_default(),
526 event_stage: event_stage__.unwrap_or_default(),
527 event_name: event_name__.unwrap_or_default(),
528 connector_name: connector_name__,
529 object: object__,
530 catalog_id: catalog_id__.unwrap_or_default(),
531 attributes: attributes__,
532 node: node__.unwrap_or_default(),
533 is_test: is_test__.unwrap_or_default(),
534 })
535 }
536 }
537 deserializer.deserialize_struct("telemetry.EventMessage", FIELDS, GeneratedVisitor)
538 }
539}
540impl serde::Serialize for FrontendReport {
541 #[allow(deprecated)]
542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
543 where
544 S: serde::Serializer,
545 {
546 use serde::ser::SerializeStruct;
547 let mut len = 0;
548 if self.base.is_some() {
549 len += 1;
550 }
551 let mut struct_ser = serializer.serialize_struct("telemetry.FrontendReport", len)?;
552 if let Some(v) = self.base.as_ref() {
553 struct_ser.serialize_field("base", v)?;
554 }
555 struct_ser.end()
556 }
557}
558impl<'de> serde::Deserialize<'de> for FrontendReport {
559 #[allow(deprecated)]
560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
561 where
562 D: serde::Deserializer<'de>,
563 {
564 const FIELDS: &[&str] = &[
565 "base",
566 ];
567
568 #[allow(clippy::enum_variant_names)]
569 enum GeneratedField {
570 Base,
571 }
572 impl<'de> serde::Deserialize<'de> for GeneratedField {
573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
574 where
575 D: serde::Deserializer<'de>,
576 {
577 struct GeneratedVisitor;
578
579 impl serde::de::Visitor<'_> for GeneratedVisitor {
580 type Value = GeneratedField;
581
582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
583 write!(formatter, "expected one of: {:?}", &FIELDS)
584 }
585
586 #[allow(unused_variables)]
587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
588 where
589 E: serde::de::Error,
590 {
591 match value {
592 "base" => Ok(GeneratedField::Base),
593 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
594 }
595 }
596 }
597 deserializer.deserialize_identifier(GeneratedVisitor)
598 }
599 }
600 struct GeneratedVisitor;
601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602 type Value = FrontendReport;
603
604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605 formatter.write_str("struct telemetry.FrontendReport")
606 }
607
608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FrontendReport, V::Error>
609 where
610 V: serde::de::MapAccess<'de>,
611 {
612 let mut base__ = None;
613 while let Some(k) = map_.next_key()? {
614 match k {
615 GeneratedField::Base => {
616 if base__.is_some() {
617 return Err(serde::de::Error::duplicate_field("base"));
618 }
619 base__ = map_.next_value()?;
620 }
621 }
622 }
623 Ok(FrontendReport {
624 base: base__,
625 })
626 }
627 }
628 deserializer.deserialize_struct("telemetry.FrontendReport", FIELDS, GeneratedVisitor)
629 }
630}
631impl serde::Serialize for MetaBackend {
632 #[allow(deprecated)]
633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
634 where
635 S: serde::Serializer,
636 {
637 let variant = match self {
638 Self::Unspecified => "META_BACKEND_UNSPECIFIED",
639 Self::Memory => "META_BACKEND_MEMORY",
640 Self::Etcd => "META_BACKEND_ETCD",
641 Self::Rdb => "META_BACKEND_RDB",
642 };
643 serializer.serialize_str(variant)
644 }
645}
646impl<'de> serde::Deserialize<'de> for MetaBackend {
647 #[allow(deprecated)]
648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
649 where
650 D: serde::Deserializer<'de>,
651 {
652 const FIELDS: &[&str] = &[
653 "META_BACKEND_UNSPECIFIED",
654 "META_BACKEND_MEMORY",
655 "META_BACKEND_ETCD",
656 "META_BACKEND_RDB",
657 ];
658
659 struct GeneratedVisitor;
660
661 impl serde::de::Visitor<'_> for GeneratedVisitor {
662 type Value = MetaBackend;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 write!(formatter, "expected one of: {:?}", &FIELDS)
666 }
667
668 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
669 where
670 E: serde::de::Error,
671 {
672 i32::try_from(v)
673 .ok()
674 .and_then(|x| x.try_into().ok())
675 .ok_or_else(|| {
676 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
677 })
678 }
679
680 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
681 where
682 E: serde::de::Error,
683 {
684 i32::try_from(v)
685 .ok()
686 .and_then(|x| x.try_into().ok())
687 .ok_or_else(|| {
688 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
689 })
690 }
691
692 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
693 where
694 E: serde::de::Error,
695 {
696 match value {
697 "META_BACKEND_UNSPECIFIED" => Ok(MetaBackend::Unspecified),
698 "META_BACKEND_MEMORY" => Ok(MetaBackend::Memory),
699 "META_BACKEND_ETCD" => Ok(MetaBackend::Etcd),
700 "META_BACKEND_RDB" => Ok(MetaBackend::Rdb),
701 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
702 }
703 }
704 }
705 deserializer.deserialize_any(GeneratedVisitor)
706 }
707}
708impl serde::Serialize for MetaReport {
709 #[allow(deprecated)]
710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
711 where
712 S: serde::Serializer,
713 {
714 use serde::ser::SerializeStruct;
715 let mut len = 0;
716 if self.base.is_some() {
717 len += 1;
718 }
719 if self.meta_backend != 0 {
720 len += 1;
721 }
722 if self.node_count.is_some() {
723 len += 1;
724 }
725 if self.rw_version.is_some() {
726 len += 1;
727 }
728 if self.stream_job_count != 0 {
729 len += 1;
730 }
731 if !self.stream_jobs.is_empty() {
732 len += 1;
733 }
734 if self.cluster_type != 0 {
735 len += 1;
736 }
737 if !self.object_store_media_type.is_empty() {
738 len += 1;
739 }
740 if !self.connector_usage_json_str.is_empty() {
741 len += 1;
742 }
743 if !self.license_info_json_str.is_empty() {
744 len += 1;
745 }
746 let mut struct_ser = serializer.serialize_struct("telemetry.MetaReport", len)?;
747 if let Some(v) = self.base.as_ref() {
748 struct_ser.serialize_field("base", v)?;
749 }
750 if self.meta_backend != 0 {
751 let v = MetaBackend::try_from(self.meta_backend)
752 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.meta_backend)))?;
753 struct_ser.serialize_field("metaBackend", &v)?;
754 }
755 if let Some(v) = self.node_count.as_ref() {
756 struct_ser.serialize_field("nodeCount", v)?;
757 }
758 if let Some(v) = self.rw_version.as_ref() {
759 struct_ser.serialize_field("rwVersion", v)?;
760 }
761 if self.stream_job_count != 0 {
762 struct_ser.serialize_field("streamJobCount", &self.stream_job_count)?;
763 }
764 if !self.stream_jobs.is_empty() {
765 struct_ser.serialize_field("streamJobs", &self.stream_jobs)?;
766 }
767 if self.cluster_type != 0 {
768 let v = TelemetryClusterType::try_from(self.cluster_type)
769 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cluster_type)))?;
770 struct_ser.serialize_field("clusterType", &v)?;
771 }
772 if !self.object_store_media_type.is_empty() {
773 struct_ser.serialize_field("objectStoreMediaType", &self.object_store_media_type)?;
774 }
775 if !self.connector_usage_json_str.is_empty() {
776 struct_ser.serialize_field("connectorUsageJsonStr", &self.connector_usage_json_str)?;
777 }
778 if !self.license_info_json_str.is_empty() {
779 struct_ser.serialize_field("licenseInfoJsonStr", &self.license_info_json_str)?;
780 }
781 struct_ser.end()
782 }
783}
784impl<'de> serde::Deserialize<'de> for MetaReport {
785 #[allow(deprecated)]
786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
787 where
788 D: serde::Deserializer<'de>,
789 {
790 const FIELDS: &[&str] = &[
791 "base",
792 "meta_backend",
793 "metaBackend",
794 "node_count",
795 "nodeCount",
796 "rw_version",
797 "rwVersion",
798 "stream_job_count",
799 "streamJobCount",
800 "stream_jobs",
801 "streamJobs",
802 "cluster_type",
803 "clusterType",
804 "object_store_media_type",
805 "objectStoreMediaType",
806 "connector_usage_json_str",
807 "connectorUsageJsonStr",
808 "license_info_json_str",
809 "licenseInfoJsonStr",
810 ];
811
812 #[allow(clippy::enum_variant_names)]
813 enum GeneratedField {
814 Base,
815 MetaBackend,
816 NodeCount,
817 RwVersion,
818 StreamJobCount,
819 StreamJobs,
820 ClusterType,
821 ObjectStoreMediaType,
822 ConnectorUsageJsonStr,
823 LicenseInfoJsonStr,
824 }
825 impl<'de> serde::Deserialize<'de> for GeneratedField {
826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
827 where
828 D: serde::Deserializer<'de>,
829 {
830 struct GeneratedVisitor;
831
832 impl serde::de::Visitor<'_> for GeneratedVisitor {
833 type Value = GeneratedField;
834
835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
836 write!(formatter, "expected one of: {:?}", &FIELDS)
837 }
838
839 #[allow(unused_variables)]
840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
841 where
842 E: serde::de::Error,
843 {
844 match value {
845 "base" => Ok(GeneratedField::Base),
846 "metaBackend" | "meta_backend" => Ok(GeneratedField::MetaBackend),
847 "nodeCount" | "node_count" => Ok(GeneratedField::NodeCount),
848 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
849 "streamJobCount" | "stream_job_count" => Ok(GeneratedField::StreamJobCount),
850 "streamJobs" | "stream_jobs" => Ok(GeneratedField::StreamJobs),
851 "clusterType" | "cluster_type" => Ok(GeneratedField::ClusterType),
852 "objectStoreMediaType" | "object_store_media_type" => Ok(GeneratedField::ObjectStoreMediaType),
853 "connectorUsageJsonStr" | "connector_usage_json_str" => Ok(GeneratedField::ConnectorUsageJsonStr),
854 "licenseInfoJsonStr" | "license_info_json_str" => Ok(GeneratedField::LicenseInfoJsonStr),
855 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
856 }
857 }
858 }
859 deserializer.deserialize_identifier(GeneratedVisitor)
860 }
861 }
862 struct GeneratedVisitor;
863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
864 type Value = MetaReport;
865
866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 formatter.write_str("struct telemetry.MetaReport")
868 }
869
870 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaReport, V::Error>
871 where
872 V: serde::de::MapAccess<'de>,
873 {
874 let mut base__ = None;
875 let mut meta_backend__ = None;
876 let mut node_count__ = None;
877 let mut rw_version__ = None;
878 let mut stream_job_count__ = None;
879 let mut stream_jobs__ = None;
880 let mut cluster_type__ = None;
881 let mut object_store_media_type__ = None;
882 let mut connector_usage_json_str__ = None;
883 let mut license_info_json_str__ = None;
884 while let Some(k) = map_.next_key()? {
885 match k {
886 GeneratedField::Base => {
887 if base__.is_some() {
888 return Err(serde::de::Error::duplicate_field("base"));
889 }
890 base__ = map_.next_value()?;
891 }
892 GeneratedField::MetaBackend => {
893 if meta_backend__.is_some() {
894 return Err(serde::de::Error::duplicate_field("metaBackend"));
895 }
896 meta_backend__ = Some(map_.next_value::<MetaBackend>()? as i32);
897 }
898 GeneratedField::NodeCount => {
899 if node_count__.is_some() {
900 return Err(serde::de::Error::duplicate_field("nodeCount"));
901 }
902 node_count__ = map_.next_value()?;
903 }
904 GeneratedField::RwVersion => {
905 if rw_version__.is_some() {
906 return Err(serde::de::Error::duplicate_field("rwVersion"));
907 }
908 rw_version__ = map_.next_value()?;
909 }
910 GeneratedField::StreamJobCount => {
911 if stream_job_count__.is_some() {
912 return Err(serde::de::Error::duplicate_field("streamJobCount"));
913 }
914 stream_job_count__ =
915 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
916 ;
917 }
918 GeneratedField::StreamJobs => {
919 if stream_jobs__.is_some() {
920 return Err(serde::de::Error::duplicate_field("streamJobs"));
921 }
922 stream_jobs__ = Some(map_.next_value()?);
923 }
924 GeneratedField::ClusterType => {
925 if cluster_type__.is_some() {
926 return Err(serde::de::Error::duplicate_field("clusterType"));
927 }
928 cluster_type__ = Some(map_.next_value::<TelemetryClusterType>()? as i32);
929 }
930 GeneratedField::ObjectStoreMediaType => {
931 if object_store_media_type__.is_some() {
932 return Err(serde::de::Error::duplicate_field("objectStoreMediaType"));
933 }
934 object_store_media_type__ = Some(map_.next_value()?);
935 }
936 GeneratedField::ConnectorUsageJsonStr => {
937 if connector_usage_json_str__.is_some() {
938 return Err(serde::de::Error::duplicate_field("connectorUsageJsonStr"));
939 }
940 connector_usage_json_str__ = Some(map_.next_value()?);
941 }
942 GeneratedField::LicenseInfoJsonStr => {
943 if license_info_json_str__.is_some() {
944 return Err(serde::de::Error::duplicate_field("licenseInfoJsonStr"));
945 }
946 license_info_json_str__ = Some(map_.next_value()?);
947 }
948 }
949 }
950 Ok(MetaReport {
951 base: base__,
952 meta_backend: meta_backend__.unwrap_or_default(),
953 node_count: node_count__,
954 rw_version: rw_version__,
955 stream_job_count: stream_job_count__.unwrap_or_default(),
956 stream_jobs: stream_jobs__.unwrap_or_default(),
957 cluster_type: cluster_type__.unwrap_or_default(),
958 object_store_media_type: object_store_media_type__.unwrap_or_default(),
959 connector_usage_json_str: connector_usage_json_str__.unwrap_or_default(),
960 license_info_json_str: license_info_json_str__.unwrap_or_default(),
961 })
962 }
963 }
964 deserializer.deserialize_struct("telemetry.MetaReport", FIELDS, GeneratedVisitor)
965 }
966}
967impl serde::Serialize for NodeCount {
968 #[allow(deprecated)]
969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
970 where
971 S: serde::Serializer,
972 {
973 use serde::ser::SerializeStruct;
974 let mut len = 0;
975 if self.meta != 0 {
976 len += 1;
977 }
978 if self.compute != 0 {
979 len += 1;
980 }
981 if self.frontend != 0 {
982 len += 1;
983 }
984 if self.compactor != 0 {
985 len += 1;
986 }
987 let mut struct_ser = serializer.serialize_struct("telemetry.NodeCount", len)?;
988 if self.meta != 0 {
989 struct_ser.serialize_field("meta", &self.meta)?;
990 }
991 if self.compute != 0 {
992 struct_ser.serialize_field("compute", &self.compute)?;
993 }
994 if self.frontend != 0 {
995 struct_ser.serialize_field("frontend", &self.frontend)?;
996 }
997 if self.compactor != 0 {
998 struct_ser.serialize_field("compactor", &self.compactor)?;
999 }
1000 struct_ser.end()
1001 }
1002}
1003impl<'de> serde::Deserialize<'de> for NodeCount {
1004 #[allow(deprecated)]
1005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1006 where
1007 D: serde::Deserializer<'de>,
1008 {
1009 const FIELDS: &[&str] = &[
1010 "meta",
1011 "compute",
1012 "frontend",
1013 "compactor",
1014 ];
1015
1016 #[allow(clippy::enum_variant_names)]
1017 enum GeneratedField {
1018 Meta,
1019 Compute,
1020 Frontend,
1021 Compactor,
1022 }
1023 impl<'de> serde::Deserialize<'de> for GeneratedField {
1024 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1025 where
1026 D: serde::Deserializer<'de>,
1027 {
1028 struct GeneratedVisitor;
1029
1030 impl serde::de::Visitor<'_> for GeneratedVisitor {
1031 type Value = GeneratedField;
1032
1033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1034 write!(formatter, "expected one of: {:?}", &FIELDS)
1035 }
1036
1037 #[allow(unused_variables)]
1038 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1039 where
1040 E: serde::de::Error,
1041 {
1042 match value {
1043 "meta" => Ok(GeneratedField::Meta),
1044 "compute" => Ok(GeneratedField::Compute),
1045 "frontend" => Ok(GeneratedField::Frontend),
1046 "compactor" => Ok(GeneratedField::Compactor),
1047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1048 }
1049 }
1050 }
1051 deserializer.deserialize_identifier(GeneratedVisitor)
1052 }
1053 }
1054 struct GeneratedVisitor;
1055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1056 type Value = NodeCount;
1057
1058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1059 formatter.write_str("struct telemetry.NodeCount")
1060 }
1061
1062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NodeCount, V::Error>
1063 where
1064 V: serde::de::MapAccess<'de>,
1065 {
1066 let mut meta__ = None;
1067 let mut compute__ = None;
1068 let mut frontend__ = None;
1069 let mut compactor__ = None;
1070 while let Some(k) = map_.next_key()? {
1071 match k {
1072 GeneratedField::Meta => {
1073 if meta__.is_some() {
1074 return Err(serde::de::Error::duplicate_field("meta"));
1075 }
1076 meta__ =
1077 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1078 ;
1079 }
1080 GeneratedField::Compute => {
1081 if compute__.is_some() {
1082 return Err(serde::de::Error::duplicate_field("compute"));
1083 }
1084 compute__ =
1085 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1086 ;
1087 }
1088 GeneratedField::Frontend => {
1089 if frontend__.is_some() {
1090 return Err(serde::de::Error::duplicate_field("frontend"));
1091 }
1092 frontend__ =
1093 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1094 ;
1095 }
1096 GeneratedField::Compactor => {
1097 if compactor__.is_some() {
1098 return Err(serde::de::Error::duplicate_field("compactor"));
1099 }
1100 compactor__ =
1101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1102 ;
1103 }
1104 }
1105 }
1106 Ok(NodeCount {
1107 meta: meta__.unwrap_or_default(),
1108 compute: compute__.unwrap_or_default(),
1109 frontend: frontend__.unwrap_or_default(),
1110 compactor: compactor__.unwrap_or_default(),
1111 })
1112 }
1113 }
1114 deserializer.deserialize_struct("telemetry.NodeCount", FIELDS, GeneratedVisitor)
1115 }
1116}
1117impl serde::Serialize for PlanOptimization {
1118 #[allow(deprecated)]
1119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1120 where
1121 S: serde::Serializer,
1122 {
1123 let variant = match self {
1124 Self::TableOptimizationUnspecified => "TABLE_OPTIMIZATION_UNSPECIFIED",
1125 };
1126 serializer.serialize_str(variant)
1127 }
1128}
1129impl<'de> serde::Deserialize<'de> for PlanOptimization {
1130 #[allow(deprecated)]
1131 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1132 where
1133 D: serde::Deserializer<'de>,
1134 {
1135 const FIELDS: &[&str] = &[
1136 "TABLE_OPTIMIZATION_UNSPECIFIED",
1137 ];
1138
1139 struct GeneratedVisitor;
1140
1141 impl serde::de::Visitor<'_> for GeneratedVisitor {
1142 type Value = PlanOptimization;
1143
1144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1145 write!(formatter, "expected one of: {:?}", &FIELDS)
1146 }
1147
1148 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1149 where
1150 E: serde::de::Error,
1151 {
1152 i32::try_from(v)
1153 .ok()
1154 .and_then(|x| x.try_into().ok())
1155 .ok_or_else(|| {
1156 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1157 })
1158 }
1159
1160 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1161 where
1162 E: serde::de::Error,
1163 {
1164 i32::try_from(v)
1165 .ok()
1166 .and_then(|x| x.try_into().ok())
1167 .ok_or_else(|| {
1168 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1169 })
1170 }
1171
1172 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1173 where
1174 E: serde::de::Error,
1175 {
1176 match value {
1177 "TABLE_OPTIMIZATION_UNSPECIFIED" => Ok(PlanOptimization::TableOptimizationUnspecified),
1178 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1179 }
1180 }
1181 }
1182 deserializer.deserialize_any(GeneratedVisitor)
1183 }
1184}
1185impl serde::Serialize for ReportBase {
1186 #[allow(deprecated)]
1187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1188 where
1189 S: serde::Serializer,
1190 {
1191 use serde::ser::SerializeStruct;
1192 let mut len = 0;
1193 if !self.tracking_id.is_empty() {
1194 len += 1;
1195 }
1196 if !self.session_id.is_empty() {
1197 len += 1;
1198 }
1199 if self.system_data.is_some() {
1200 len += 1;
1201 }
1202 if self.up_time != 0 {
1203 len += 1;
1204 }
1205 if self.report_time != 0 {
1206 len += 1;
1207 }
1208 if self.node_type != 0 {
1209 len += 1;
1210 }
1211 if self.is_test {
1212 len += 1;
1213 }
1214 let mut struct_ser = serializer.serialize_struct("telemetry.ReportBase", len)?;
1215 if !self.tracking_id.is_empty() {
1216 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
1217 }
1218 if !self.session_id.is_empty() {
1219 struct_ser.serialize_field("sessionId", &self.session_id)?;
1220 }
1221 if let Some(v) = self.system_data.as_ref() {
1222 struct_ser.serialize_field("systemData", v)?;
1223 }
1224 if self.up_time != 0 {
1225 #[allow(clippy::needless_borrow)]
1226 #[allow(clippy::needless_borrows_for_generic_args)]
1227 struct_ser.serialize_field("upTime", ToString::to_string(&self.up_time).as_str())?;
1228 }
1229 if self.report_time != 0 {
1230 #[allow(clippy::needless_borrow)]
1231 #[allow(clippy::needless_borrows_for_generic_args)]
1232 struct_ser.serialize_field("reportTime", ToString::to_string(&self.report_time).as_str())?;
1233 }
1234 if self.node_type != 0 {
1235 let v = TelemetryNodeType::try_from(self.node_type)
1236 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.node_type)))?;
1237 struct_ser.serialize_field("nodeType", &v)?;
1238 }
1239 if self.is_test {
1240 struct_ser.serialize_field("isTest", &self.is_test)?;
1241 }
1242 struct_ser.end()
1243 }
1244}
1245impl<'de> serde::Deserialize<'de> for ReportBase {
1246 #[allow(deprecated)]
1247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1248 where
1249 D: serde::Deserializer<'de>,
1250 {
1251 const FIELDS: &[&str] = &[
1252 "tracking_id",
1253 "trackingId",
1254 "session_id",
1255 "sessionId",
1256 "system_data",
1257 "systemData",
1258 "up_time",
1259 "upTime",
1260 "report_time",
1261 "reportTime",
1262 "node_type",
1263 "nodeType",
1264 "is_test",
1265 "isTest",
1266 ];
1267
1268 #[allow(clippy::enum_variant_names)]
1269 enum GeneratedField {
1270 TrackingId,
1271 SessionId,
1272 SystemData,
1273 UpTime,
1274 ReportTime,
1275 NodeType,
1276 IsTest,
1277 }
1278 impl<'de> serde::Deserialize<'de> for GeneratedField {
1279 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1280 where
1281 D: serde::Deserializer<'de>,
1282 {
1283 struct GeneratedVisitor;
1284
1285 impl serde::de::Visitor<'_> for GeneratedVisitor {
1286 type Value = GeneratedField;
1287
1288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1289 write!(formatter, "expected one of: {:?}", &FIELDS)
1290 }
1291
1292 #[allow(unused_variables)]
1293 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1294 where
1295 E: serde::de::Error,
1296 {
1297 match value {
1298 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
1299 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
1300 "systemData" | "system_data" => Ok(GeneratedField::SystemData),
1301 "upTime" | "up_time" => Ok(GeneratedField::UpTime),
1302 "reportTime" | "report_time" => Ok(GeneratedField::ReportTime),
1303 "nodeType" | "node_type" => Ok(GeneratedField::NodeType),
1304 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
1305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1306 }
1307 }
1308 }
1309 deserializer.deserialize_identifier(GeneratedVisitor)
1310 }
1311 }
1312 struct GeneratedVisitor;
1313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1314 type Value = ReportBase;
1315
1316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1317 formatter.write_str("struct telemetry.ReportBase")
1318 }
1319
1320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportBase, V::Error>
1321 where
1322 V: serde::de::MapAccess<'de>,
1323 {
1324 let mut tracking_id__ = None;
1325 let mut session_id__ = None;
1326 let mut system_data__ = None;
1327 let mut up_time__ = None;
1328 let mut report_time__ = None;
1329 let mut node_type__ = None;
1330 let mut is_test__ = None;
1331 while let Some(k) = map_.next_key()? {
1332 match k {
1333 GeneratedField::TrackingId => {
1334 if tracking_id__.is_some() {
1335 return Err(serde::de::Error::duplicate_field("trackingId"));
1336 }
1337 tracking_id__ = Some(map_.next_value()?);
1338 }
1339 GeneratedField::SessionId => {
1340 if session_id__.is_some() {
1341 return Err(serde::de::Error::duplicate_field("sessionId"));
1342 }
1343 session_id__ = Some(map_.next_value()?);
1344 }
1345 GeneratedField::SystemData => {
1346 if system_data__.is_some() {
1347 return Err(serde::de::Error::duplicate_field("systemData"));
1348 }
1349 system_data__ = map_.next_value()?;
1350 }
1351 GeneratedField::UpTime => {
1352 if up_time__.is_some() {
1353 return Err(serde::de::Error::duplicate_field("upTime"));
1354 }
1355 up_time__ =
1356 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1357 ;
1358 }
1359 GeneratedField::ReportTime => {
1360 if report_time__.is_some() {
1361 return Err(serde::de::Error::duplicate_field("reportTime"));
1362 }
1363 report_time__ =
1364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1365 ;
1366 }
1367 GeneratedField::NodeType => {
1368 if node_type__.is_some() {
1369 return Err(serde::de::Error::duplicate_field("nodeType"));
1370 }
1371 node_type__ = Some(map_.next_value::<TelemetryNodeType>()? as i32);
1372 }
1373 GeneratedField::IsTest => {
1374 if is_test__.is_some() {
1375 return Err(serde::de::Error::duplicate_field("isTest"));
1376 }
1377 is_test__ = Some(map_.next_value()?);
1378 }
1379 }
1380 }
1381 Ok(ReportBase {
1382 tracking_id: tracking_id__.unwrap_or_default(),
1383 session_id: session_id__.unwrap_or_default(),
1384 system_data: system_data__,
1385 up_time: up_time__.unwrap_or_default(),
1386 report_time: report_time__.unwrap_or_default(),
1387 node_type: node_type__.unwrap_or_default(),
1388 is_test: is_test__.unwrap_or_default(),
1389 })
1390 }
1391 }
1392 deserializer.deserialize_struct("telemetry.ReportBase", FIELDS, GeneratedVisitor)
1393 }
1394}
1395impl serde::Serialize for RwVersion {
1396 #[allow(deprecated)]
1397 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1398 where
1399 S: serde::Serializer,
1400 {
1401 use serde::ser::SerializeStruct;
1402 let mut len = 0;
1403 if !self.rw_version.is_empty() {
1404 len += 1;
1405 }
1406 if !self.git_sha.is_empty() {
1407 len += 1;
1408 }
1409 let mut struct_ser = serializer.serialize_struct("telemetry.RwVersion", len)?;
1410 if !self.rw_version.is_empty() {
1411 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
1412 }
1413 if !self.git_sha.is_empty() {
1414 struct_ser.serialize_field("gitSha", &self.git_sha)?;
1415 }
1416 struct_ser.end()
1417 }
1418}
1419impl<'de> serde::Deserialize<'de> for RwVersion {
1420 #[allow(deprecated)]
1421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1422 where
1423 D: serde::Deserializer<'de>,
1424 {
1425 const FIELDS: &[&str] = &[
1426 "rw_version",
1427 "rwVersion",
1428 "git_sha",
1429 "gitSha",
1430 ];
1431
1432 #[allow(clippy::enum_variant_names)]
1433 enum GeneratedField {
1434 RwVersion,
1435 GitSha,
1436 }
1437 impl<'de> serde::Deserialize<'de> for GeneratedField {
1438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1439 where
1440 D: serde::Deserializer<'de>,
1441 {
1442 struct GeneratedVisitor;
1443
1444 impl serde::de::Visitor<'_> for GeneratedVisitor {
1445 type Value = GeneratedField;
1446
1447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1448 write!(formatter, "expected one of: {:?}", &FIELDS)
1449 }
1450
1451 #[allow(unused_variables)]
1452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1453 where
1454 E: serde::de::Error,
1455 {
1456 match value {
1457 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
1458 "gitSha" | "git_sha" => Ok(GeneratedField::GitSha),
1459 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1460 }
1461 }
1462 }
1463 deserializer.deserialize_identifier(GeneratedVisitor)
1464 }
1465 }
1466 struct GeneratedVisitor;
1467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1468 type Value = RwVersion;
1469
1470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1471 formatter.write_str("struct telemetry.RwVersion")
1472 }
1473
1474 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RwVersion, V::Error>
1475 where
1476 V: serde::de::MapAccess<'de>,
1477 {
1478 let mut rw_version__ = None;
1479 let mut git_sha__ = None;
1480 while let Some(k) = map_.next_key()? {
1481 match k {
1482 GeneratedField::RwVersion => {
1483 if rw_version__.is_some() {
1484 return Err(serde::de::Error::duplicate_field("rwVersion"));
1485 }
1486 rw_version__ = Some(map_.next_value()?);
1487 }
1488 GeneratedField::GitSha => {
1489 if git_sha__.is_some() {
1490 return Err(serde::de::Error::duplicate_field("gitSha"));
1491 }
1492 git_sha__ = Some(map_.next_value()?);
1493 }
1494 }
1495 }
1496 Ok(RwVersion {
1497 rw_version: rw_version__.unwrap_or_default(),
1498 git_sha: git_sha__.unwrap_or_default(),
1499 })
1500 }
1501 }
1502 deserializer.deserialize_struct("telemetry.RwVersion", FIELDS, GeneratedVisitor)
1503 }
1504}
1505impl serde::Serialize for StreamJobDesc {
1506 #[allow(deprecated)]
1507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1508 where
1509 S: serde::Serializer,
1510 {
1511 use serde::ser::SerializeStruct;
1512 let mut len = 0;
1513 if self.table_id != 0 {
1514 len += 1;
1515 }
1516 if self.connector_name.is_some() {
1517 len += 1;
1518 }
1519 if !self.plan_optimizations.is_empty() {
1520 len += 1;
1521 }
1522 let mut struct_ser = serializer.serialize_struct("telemetry.StreamJobDesc", len)?;
1523 if self.table_id != 0 {
1524 struct_ser.serialize_field("tableId", &self.table_id)?;
1525 }
1526 if let Some(v) = self.connector_name.as_ref() {
1527 struct_ser.serialize_field("connectorName", v)?;
1528 }
1529 if !self.plan_optimizations.is_empty() {
1530 let v = self.plan_optimizations.iter().cloned().map(|v| {
1531 PlanOptimization::try_from(v)
1532 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1533 }).collect::<std::result::Result<Vec<_>, _>>()?;
1534 struct_ser.serialize_field("planOptimizations", &v)?;
1535 }
1536 struct_ser.end()
1537 }
1538}
1539impl<'de> serde::Deserialize<'de> for StreamJobDesc {
1540 #[allow(deprecated)]
1541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1542 where
1543 D: serde::Deserializer<'de>,
1544 {
1545 const FIELDS: &[&str] = &[
1546 "table_id",
1547 "tableId",
1548 "connector_name",
1549 "connectorName",
1550 "plan_optimizations",
1551 "planOptimizations",
1552 ];
1553
1554 #[allow(clippy::enum_variant_names)]
1555 enum GeneratedField {
1556 TableId,
1557 ConnectorName,
1558 PlanOptimizations,
1559 }
1560 impl<'de> serde::Deserialize<'de> for GeneratedField {
1561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1562 where
1563 D: serde::Deserializer<'de>,
1564 {
1565 struct GeneratedVisitor;
1566
1567 impl serde::de::Visitor<'_> for GeneratedVisitor {
1568 type Value = GeneratedField;
1569
1570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1571 write!(formatter, "expected one of: {:?}", &FIELDS)
1572 }
1573
1574 #[allow(unused_variables)]
1575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1576 where
1577 E: serde::de::Error,
1578 {
1579 match value {
1580 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1581 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
1582 "planOptimizations" | "plan_optimizations" => Ok(GeneratedField::PlanOptimizations),
1583 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1584 }
1585 }
1586 }
1587 deserializer.deserialize_identifier(GeneratedVisitor)
1588 }
1589 }
1590 struct GeneratedVisitor;
1591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1592 type Value = StreamJobDesc;
1593
1594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1595 formatter.write_str("struct telemetry.StreamJobDesc")
1596 }
1597
1598 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamJobDesc, V::Error>
1599 where
1600 V: serde::de::MapAccess<'de>,
1601 {
1602 let mut table_id__ = None;
1603 let mut connector_name__ = None;
1604 let mut plan_optimizations__ = None;
1605 while let Some(k) = map_.next_key()? {
1606 match k {
1607 GeneratedField::TableId => {
1608 if table_id__.is_some() {
1609 return Err(serde::de::Error::duplicate_field("tableId"));
1610 }
1611 table_id__ =
1612 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1613 ;
1614 }
1615 GeneratedField::ConnectorName => {
1616 if connector_name__.is_some() {
1617 return Err(serde::de::Error::duplicate_field("connectorName"));
1618 }
1619 connector_name__ = map_.next_value()?;
1620 }
1621 GeneratedField::PlanOptimizations => {
1622 if plan_optimizations__.is_some() {
1623 return Err(serde::de::Error::duplicate_field("planOptimizations"));
1624 }
1625 plan_optimizations__ = Some(map_.next_value::<Vec<PlanOptimization>>()?.into_iter().map(|x| x as i32).collect());
1626 }
1627 }
1628 }
1629 Ok(StreamJobDesc {
1630 table_id: table_id__.unwrap_or_default(),
1631 connector_name: connector_name__,
1632 plan_optimizations: plan_optimizations__.unwrap_or_default(),
1633 })
1634 }
1635 }
1636 deserializer.deserialize_struct("telemetry.StreamJobDesc", FIELDS, GeneratedVisitor)
1637 }
1638}
1639impl serde::Serialize for SystemCpu {
1640 #[allow(deprecated)]
1641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1642 where
1643 S: serde::Serializer,
1644 {
1645 use serde::ser::SerializeStruct;
1646 let mut len = 0;
1647 if self.available != 0. {
1648 len += 1;
1649 }
1650 let mut struct_ser = serializer.serialize_struct("telemetry.SystemCpu", len)?;
1651 if self.available != 0. {
1652 struct_ser.serialize_field("available", &self.available)?;
1653 }
1654 struct_ser.end()
1655 }
1656}
1657impl<'de> serde::Deserialize<'de> for SystemCpu {
1658 #[allow(deprecated)]
1659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1660 where
1661 D: serde::Deserializer<'de>,
1662 {
1663 const FIELDS: &[&str] = &[
1664 "available",
1665 ];
1666
1667 #[allow(clippy::enum_variant_names)]
1668 enum GeneratedField {
1669 Available,
1670 }
1671 impl<'de> serde::Deserialize<'de> for GeneratedField {
1672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1673 where
1674 D: serde::Deserializer<'de>,
1675 {
1676 struct GeneratedVisitor;
1677
1678 impl serde::de::Visitor<'_> for GeneratedVisitor {
1679 type Value = GeneratedField;
1680
1681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1682 write!(formatter, "expected one of: {:?}", &FIELDS)
1683 }
1684
1685 #[allow(unused_variables)]
1686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1687 where
1688 E: serde::de::Error,
1689 {
1690 match value {
1691 "available" => Ok(GeneratedField::Available),
1692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1693 }
1694 }
1695 }
1696 deserializer.deserialize_identifier(GeneratedVisitor)
1697 }
1698 }
1699 struct GeneratedVisitor;
1700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1701 type Value = SystemCpu;
1702
1703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1704 formatter.write_str("struct telemetry.SystemCpu")
1705 }
1706
1707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemCpu, V::Error>
1708 where
1709 V: serde::de::MapAccess<'de>,
1710 {
1711 let mut available__ = None;
1712 while let Some(k) = map_.next_key()? {
1713 match k {
1714 GeneratedField::Available => {
1715 if available__.is_some() {
1716 return Err(serde::de::Error::duplicate_field("available"));
1717 }
1718 available__ =
1719 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1720 ;
1721 }
1722 }
1723 }
1724 Ok(SystemCpu {
1725 available: available__.unwrap_or_default(),
1726 })
1727 }
1728 }
1729 deserializer.deserialize_struct("telemetry.SystemCpu", FIELDS, GeneratedVisitor)
1730 }
1731}
1732impl serde::Serialize for SystemData {
1733 #[allow(deprecated)]
1734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1735 where
1736 S: serde::Serializer,
1737 {
1738 use serde::ser::SerializeStruct;
1739 let mut len = 0;
1740 if self.memory.is_some() {
1741 len += 1;
1742 }
1743 if self.os.is_some() {
1744 len += 1;
1745 }
1746 if self.cpu.is_some() {
1747 len += 1;
1748 }
1749 let mut struct_ser = serializer.serialize_struct("telemetry.SystemData", len)?;
1750 if let Some(v) = self.memory.as_ref() {
1751 struct_ser.serialize_field("memory", v)?;
1752 }
1753 if let Some(v) = self.os.as_ref() {
1754 struct_ser.serialize_field("os", v)?;
1755 }
1756 if let Some(v) = self.cpu.as_ref() {
1757 struct_ser.serialize_field("cpu", v)?;
1758 }
1759 struct_ser.end()
1760 }
1761}
1762impl<'de> serde::Deserialize<'de> for SystemData {
1763 #[allow(deprecated)]
1764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1765 where
1766 D: serde::Deserializer<'de>,
1767 {
1768 const FIELDS: &[&str] = &[
1769 "memory",
1770 "os",
1771 "cpu",
1772 ];
1773
1774 #[allow(clippy::enum_variant_names)]
1775 enum GeneratedField {
1776 Memory,
1777 Os,
1778 Cpu,
1779 }
1780 impl<'de> serde::Deserialize<'de> for GeneratedField {
1781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1782 where
1783 D: serde::Deserializer<'de>,
1784 {
1785 struct GeneratedVisitor;
1786
1787 impl serde::de::Visitor<'_> for GeneratedVisitor {
1788 type Value = GeneratedField;
1789
1790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1791 write!(formatter, "expected one of: {:?}", &FIELDS)
1792 }
1793
1794 #[allow(unused_variables)]
1795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1796 where
1797 E: serde::de::Error,
1798 {
1799 match value {
1800 "memory" => Ok(GeneratedField::Memory),
1801 "os" => Ok(GeneratedField::Os),
1802 "cpu" => Ok(GeneratedField::Cpu),
1803 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1804 }
1805 }
1806 }
1807 deserializer.deserialize_identifier(GeneratedVisitor)
1808 }
1809 }
1810 struct GeneratedVisitor;
1811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1812 type Value = SystemData;
1813
1814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1815 formatter.write_str("struct telemetry.SystemData")
1816 }
1817
1818 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemData, V::Error>
1819 where
1820 V: serde::de::MapAccess<'de>,
1821 {
1822 let mut memory__ = None;
1823 let mut os__ = None;
1824 let mut cpu__ = None;
1825 while let Some(k) = map_.next_key()? {
1826 match k {
1827 GeneratedField::Memory => {
1828 if memory__.is_some() {
1829 return Err(serde::de::Error::duplicate_field("memory"));
1830 }
1831 memory__ = map_.next_value()?;
1832 }
1833 GeneratedField::Os => {
1834 if os__.is_some() {
1835 return Err(serde::de::Error::duplicate_field("os"));
1836 }
1837 os__ = map_.next_value()?;
1838 }
1839 GeneratedField::Cpu => {
1840 if cpu__.is_some() {
1841 return Err(serde::de::Error::duplicate_field("cpu"));
1842 }
1843 cpu__ = map_.next_value()?;
1844 }
1845 }
1846 }
1847 Ok(SystemData {
1848 memory: memory__,
1849 os: os__,
1850 cpu: cpu__,
1851 })
1852 }
1853 }
1854 deserializer.deserialize_struct("telemetry.SystemData", FIELDS, GeneratedVisitor)
1855 }
1856}
1857impl serde::Serialize for SystemMemory {
1858 #[allow(deprecated)]
1859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1860 where
1861 S: serde::Serializer,
1862 {
1863 use serde::ser::SerializeStruct;
1864 let mut len = 0;
1865 if self.used != 0 {
1866 len += 1;
1867 }
1868 if self.total != 0 {
1869 len += 1;
1870 }
1871 let mut struct_ser = serializer.serialize_struct("telemetry.SystemMemory", len)?;
1872 if self.used != 0 {
1873 #[allow(clippy::needless_borrow)]
1874 #[allow(clippy::needless_borrows_for_generic_args)]
1875 struct_ser.serialize_field("used", ToString::to_string(&self.used).as_str())?;
1876 }
1877 if self.total != 0 {
1878 #[allow(clippy::needless_borrow)]
1879 #[allow(clippy::needless_borrows_for_generic_args)]
1880 struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?;
1881 }
1882 struct_ser.end()
1883 }
1884}
1885impl<'de> serde::Deserialize<'de> for SystemMemory {
1886 #[allow(deprecated)]
1887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1888 where
1889 D: serde::Deserializer<'de>,
1890 {
1891 const FIELDS: &[&str] = &[
1892 "used",
1893 "total",
1894 ];
1895
1896 #[allow(clippy::enum_variant_names)]
1897 enum GeneratedField {
1898 Used,
1899 Total,
1900 }
1901 impl<'de> serde::Deserialize<'de> for GeneratedField {
1902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1903 where
1904 D: serde::Deserializer<'de>,
1905 {
1906 struct GeneratedVisitor;
1907
1908 impl serde::de::Visitor<'_> for GeneratedVisitor {
1909 type Value = GeneratedField;
1910
1911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1912 write!(formatter, "expected one of: {:?}", &FIELDS)
1913 }
1914
1915 #[allow(unused_variables)]
1916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1917 where
1918 E: serde::de::Error,
1919 {
1920 match value {
1921 "used" => Ok(GeneratedField::Used),
1922 "total" => Ok(GeneratedField::Total),
1923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1924 }
1925 }
1926 }
1927 deserializer.deserialize_identifier(GeneratedVisitor)
1928 }
1929 }
1930 struct GeneratedVisitor;
1931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1932 type Value = SystemMemory;
1933
1934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1935 formatter.write_str("struct telemetry.SystemMemory")
1936 }
1937
1938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemMemory, V::Error>
1939 where
1940 V: serde::de::MapAccess<'de>,
1941 {
1942 let mut used__ = None;
1943 let mut total__ = None;
1944 while let Some(k) = map_.next_key()? {
1945 match k {
1946 GeneratedField::Used => {
1947 if used__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("used"));
1949 }
1950 used__ =
1951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1952 ;
1953 }
1954 GeneratedField::Total => {
1955 if total__.is_some() {
1956 return Err(serde::de::Error::duplicate_field("total"));
1957 }
1958 total__ =
1959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1960 ;
1961 }
1962 }
1963 }
1964 Ok(SystemMemory {
1965 used: used__.unwrap_or_default(),
1966 total: total__.unwrap_or_default(),
1967 })
1968 }
1969 }
1970 deserializer.deserialize_struct("telemetry.SystemMemory", FIELDS, GeneratedVisitor)
1971 }
1972}
1973impl serde::Serialize for SystemOs {
1974 #[allow(deprecated)]
1975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1976 where
1977 S: serde::Serializer,
1978 {
1979 use serde::ser::SerializeStruct;
1980 let mut len = 0;
1981 if !self.name.is_empty() {
1982 len += 1;
1983 }
1984 if !self.version.is_empty() {
1985 len += 1;
1986 }
1987 if !self.kernel_version.is_empty() {
1988 len += 1;
1989 }
1990 let mut struct_ser = serializer.serialize_struct("telemetry.SystemOs", len)?;
1991 if !self.name.is_empty() {
1992 struct_ser.serialize_field("name", &self.name)?;
1993 }
1994 if !self.version.is_empty() {
1995 struct_ser.serialize_field("version", &self.version)?;
1996 }
1997 if !self.kernel_version.is_empty() {
1998 struct_ser.serialize_field("kernelVersion", &self.kernel_version)?;
1999 }
2000 struct_ser.end()
2001 }
2002}
2003impl<'de> serde::Deserialize<'de> for SystemOs {
2004 #[allow(deprecated)]
2005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2006 where
2007 D: serde::Deserializer<'de>,
2008 {
2009 const FIELDS: &[&str] = &[
2010 "name",
2011 "version",
2012 "kernel_version",
2013 "kernelVersion",
2014 ];
2015
2016 #[allow(clippy::enum_variant_names)]
2017 enum GeneratedField {
2018 Name,
2019 Version,
2020 KernelVersion,
2021 }
2022 impl<'de> serde::Deserialize<'de> for GeneratedField {
2023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2024 where
2025 D: serde::Deserializer<'de>,
2026 {
2027 struct GeneratedVisitor;
2028
2029 impl serde::de::Visitor<'_> for GeneratedVisitor {
2030 type Value = GeneratedField;
2031
2032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2033 write!(formatter, "expected one of: {:?}", &FIELDS)
2034 }
2035
2036 #[allow(unused_variables)]
2037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2038 where
2039 E: serde::de::Error,
2040 {
2041 match value {
2042 "name" => Ok(GeneratedField::Name),
2043 "version" => Ok(GeneratedField::Version),
2044 "kernelVersion" | "kernel_version" => Ok(GeneratedField::KernelVersion),
2045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2046 }
2047 }
2048 }
2049 deserializer.deserialize_identifier(GeneratedVisitor)
2050 }
2051 }
2052 struct GeneratedVisitor;
2053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2054 type Value = SystemOs;
2055
2056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2057 formatter.write_str("struct telemetry.SystemOs")
2058 }
2059
2060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemOs, V::Error>
2061 where
2062 V: serde::de::MapAccess<'de>,
2063 {
2064 let mut name__ = None;
2065 let mut version__ = None;
2066 let mut kernel_version__ = None;
2067 while let Some(k) = map_.next_key()? {
2068 match k {
2069 GeneratedField::Name => {
2070 if name__.is_some() {
2071 return Err(serde::de::Error::duplicate_field("name"));
2072 }
2073 name__ = Some(map_.next_value()?);
2074 }
2075 GeneratedField::Version => {
2076 if version__.is_some() {
2077 return Err(serde::de::Error::duplicate_field("version"));
2078 }
2079 version__ = Some(map_.next_value()?);
2080 }
2081 GeneratedField::KernelVersion => {
2082 if kernel_version__.is_some() {
2083 return Err(serde::de::Error::duplicate_field("kernelVersion"));
2084 }
2085 kernel_version__ = Some(map_.next_value()?);
2086 }
2087 }
2088 }
2089 Ok(SystemOs {
2090 name: name__.unwrap_or_default(),
2091 version: version__.unwrap_or_default(),
2092 kernel_version: kernel_version__.unwrap_or_default(),
2093 })
2094 }
2095 }
2096 deserializer.deserialize_struct("telemetry.SystemOs", FIELDS, GeneratedVisitor)
2097 }
2098}
2099impl serde::Serialize for TelemetryClusterType {
2100 #[allow(deprecated)]
2101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2102 where
2103 S: serde::Serializer,
2104 {
2105 let variant = match self {
2106 Self::Unspecified => "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2107 Self::SingleNode => "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2108 Self::DockerCompose => "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2109 Self::Kubernetes => "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2110 Self::CloudHosted => "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2111 };
2112 serializer.serialize_str(variant)
2113 }
2114}
2115impl<'de> serde::Deserialize<'de> for TelemetryClusterType {
2116 #[allow(deprecated)]
2117 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2118 where
2119 D: serde::Deserializer<'de>,
2120 {
2121 const FIELDS: &[&str] = &[
2122 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2123 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2124 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2125 "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2126 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2127 ];
2128
2129 struct GeneratedVisitor;
2130
2131 impl serde::de::Visitor<'_> for GeneratedVisitor {
2132 type Value = TelemetryClusterType;
2133
2134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2135 write!(formatter, "expected one of: {:?}", &FIELDS)
2136 }
2137
2138 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2139 where
2140 E: serde::de::Error,
2141 {
2142 i32::try_from(v)
2143 .ok()
2144 .and_then(|x| x.try_into().ok())
2145 .ok_or_else(|| {
2146 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2147 })
2148 }
2149
2150 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2151 where
2152 E: serde::de::Error,
2153 {
2154 i32::try_from(v)
2155 .ok()
2156 .and_then(|x| x.try_into().ok())
2157 .ok_or_else(|| {
2158 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2159 })
2160 }
2161
2162 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2163 where
2164 E: serde::de::Error,
2165 {
2166 match value {
2167 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED" => Ok(TelemetryClusterType::Unspecified),
2168 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE" => Ok(TelemetryClusterType::SingleNode),
2169 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE" => Ok(TelemetryClusterType::DockerCompose),
2170 "TELEMETRY_CLUSTER_TYPE_KUBERNETES" => Ok(TelemetryClusterType::Kubernetes),
2171 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED" => Ok(TelemetryClusterType::CloudHosted),
2172 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2173 }
2174 }
2175 }
2176 deserializer.deserialize_any(GeneratedVisitor)
2177 }
2178}
2179impl serde::Serialize for TelemetryDatabaseObject {
2180 #[allow(deprecated)]
2181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2182 where
2183 S: serde::Serializer,
2184 {
2185 let variant = match self {
2186 Self::Unspecified => "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2187 Self::Source => "TELEMETRY_DATABASE_OBJECT_SOURCE",
2188 Self::Mv => "TELEMETRY_DATABASE_OBJECT_MV",
2189 Self::Table => "TELEMETRY_DATABASE_OBJECT_TABLE",
2190 Self::Sink => "TELEMETRY_DATABASE_OBJECT_SINK",
2191 Self::Index => "TELEMETRY_DATABASE_OBJECT_INDEX",
2192 };
2193 serializer.serialize_str(variant)
2194 }
2195}
2196impl<'de> serde::Deserialize<'de> for TelemetryDatabaseObject {
2197 #[allow(deprecated)]
2198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2199 where
2200 D: serde::Deserializer<'de>,
2201 {
2202 const FIELDS: &[&str] = &[
2203 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2204 "TELEMETRY_DATABASE_OBJECT_SOURCE",
2205 "TELEMETRY_DATABASE_OBJECT_MV",
2206 "TELEMETRY_DATABASE_OBJECT_TABLE",
2207 "TELEMETRY_DATABASE_OBJECT_SINK",
2208 "TELEMETRY_DATABASE_OBJECT_INDEX",
2209 ];
2210
2211 struct GeneratedVisitor;
2212
2213 impl serde::de::Visitor<'_> for GeneratedVisitor {
2214 type Value = TelemetryDatabaseObject;
2215
2216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2217 write!(formatter, "expected one of: {:?}", &FIELDS)
2218 }
2219
2220 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2221 where
2222 E: serde::de::Error,
2223 {
2224 i32::try_from(v)
2225 .ok()
2226 .and_then(|x| x.try_into().ok())
2227 .ok_or_else(|| {
2228 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2229 })
2230 }
2231
2232 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2233 where
2234 E: serde::de::Error,
2235 {
2236 i32::try_from(v)
2237 .ok()
2238 .and_then(|x| x.try_into().ok())
2239 .ok_or_else(|| {
2240 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2241 })
2242 }
2243
2244 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2245 where
2246 E: serde::de::Error,
2247 {
2248 match value {
2249 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED" => Ok(TelemetryDatabaseObject::Unspecified),
2250 "TELEMETRY_DATABASE_OBJECT_SOURCE" => Ok(TelemetryDatabaseObject::Source),
2251 "TELEMETRY_DATABASE_OBJECT_MV" => Ok(TelemetryDatabaseObject::Mv),
2252 "TELEMETRY_DATABASE_OBJECT_TABLE" => Ok(TelemetryDatabaseObject::Table),
2253 "TELEMETRY_DATABASE_OBJECT_SINK" => Ok(TelemetryDatabaseObject::Sink),
2254 "TELEMETRY_DATABASE_OBJECT_INDEX" => Ok(TelemetryDatabaseObject::Index),
2255 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2256 }
2257 }
2258 }
2259 deserializer.deserialize_any(GeneratedVisitor)
2260 }
2261}
2262impl serde::Serialize for TelemetryEventStage {
2263 #[allow(deprecated)]
2264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2265 where
2266 S: serde::Serializer,
2267 {
2268 let variant = match self {
2269 Self::Unspecified => "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2270 Self::CreateStreamJob => "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2271 Self::UpdateStreamJob => "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2272 Self::DropStreamJob => "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2273 Self::Query => "TELEMETRY_EVENT_STAGE_QUERY",
2274 Self::Recovery => "TELEMETRY_EVENT_STAGE_RECOVERY",
2275 };
2276 serializer.serialize_str(variant)
2277 }
2278}
2279impl<'de> serde::Deserialize<'de> for TelemetryEventStage {
2280 #[allow(deprecated)]
2281 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2282 where
2283 D: serde::Deserializer<'de>,
2284 {
2285 const FIELDS: &[&str] = &[
2286 "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2287 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2288 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2289 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2290 "TELEMETRY_EVENT_STAGE_QUERY",
2291 "TELEMETRY_EVENT_STAGE_RECOVERY",
2292 ];
2293
2294 struct GeneratedVisitor;
2295
2296 impl serde::de::Visitor<'_> for GeneratedVisitor {
2297 type Value = TelemetryEventStage;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 write!(formatter, "expected one of: {:?}", &FIELDS)
2301 }
2302
2303 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2304 where
2305 E: serde::de::Error,
2306 {
2307 i32::try_from(v)
2308 .ok()
2309 .and_then(|x| x.try_into().ok())
2310 .ok_or_else(|| {
2311 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2312 })
2313 }
2314
2315 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2316 where
2317 E: serde::de::Error,
2318 {
2319 i32::try_from(v)
2320 .ok()
2321 .and_then(|x| x.try_into().ok())
2322 .ok_or_else(|| {
2323 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2324 })
2325 }
2326
2327 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2328 where
2329 E: serde::de::Error,
2330 {
2331 match value {
2332 "TELEMETRY_EVENT_STAGE_UNSPECIFIED" => Ok(TelemetryEventStage::Unspecified),
2333 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB" => Ok(TelemetryEventStage::CreateStreamJob),
2334 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB" => Ok(TelemetryEventStage::UpdateStreamJob),
2335 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB" => Ok(TelemetryEventStage::DropStreamJob),
2336 "TELEMETRY_EVENT_STAGE_QUERY" => Ok(TelemetryEventStage::Query),
2337 "TELEMETRY_EVENT_STAGE_RECOVERY" => Ok(TelemetryEventStage::Recovery),
2338 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2339 }
2340 }
2341 }
2342 deserializer.deserialize_any(GeneratedVisitor)
2343 }
2344}
2345impl serde::Serialize for TelemetryNodeType {
2346 #[allow(deprecated)]
2347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2348 where
2349 S: serde::Serializer,
2350 {
2351 let variant = match self {
2352 Self::Unspecified => "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2353 Self::Meta => "TELEMETRY_NODE_TYPE_META",
2354 Self::Compute => "TELEMETRY_NODE_TYPE_COMPUTE",
2355 Self::Frontend => "TELEMETRY_NODE_TYPE_FRONTEND",
2356 Self::Compactor => "TELEMETRY_NODE_TYPE_COMPACTOR",
2357 };
2358 serializer.serialize_str(variant)
2359 }
2360}
2361impl<'de> serde::Deserialize<'de> for TelemetryNodeType {
2362 #[allow(deprecated)]
2363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2364 where
2365 D: serde::Deserializer<'de>,
2366 {
2367 const FIELDS: &[&str] = &[
2368 "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2369 "TELEMETRY_NODE_TYPE_META",
2370 "TELEMETRY_NODE_TYPE_COMPUTE",
2371 "TELEMETRY_NODE_TYPE_FRONTEND",
2372 "TELEMETRY_NODE_TYPE_COMPACTOR",
2373 ];
2374
2375 struct GeneratedVisitor;
2376
2377 impl serde::de::Visitor<'_> for GeneratedVisitor {
2378 type Value = TelemetryNodeType;
2379
2380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2381 write!(formatter, "expected one of: {:?}", &FIELDS)
2382 }
2383
2384 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2385 where
2386 E: serde::de::Error,
2387 {
2388 i32::try_from(v)
2389 .ok()
2390 .and_then(|x| x.try_into().ok())
2391 .ok_or_else(|| {
2392 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2393 })
2394 }
2395
2396 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2397 where
2398 E: serde::de::Error,
2399 {
2400 i32::try_from(v)
2401 .ok()
2402 .and_then(|x| x.try_into().ok())
2403 .ok_or_else(|| {
2404 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2405 })
2406 }
2407
2408 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2409 where
2410 E: serde::de::Error,
2411 {
2412 match value {
2413 "TELEMETRY_NODE_TYPE_UNSPECIFIED" => Ok(TelemetryNodeType::Unspecified),
2414 "TELEMETRY_NODE_TYPE_META" => Ok(TelemetryNodeType::Meta),
2415 "TELEMETRY_NODE_TYPE_COMPUTE" => Ok(TelemetryNodeType::Compute),
2416 "TELEMETRY_NODE_TYPE_FRONTEND" => Ok(TelemetryNodeType::Frontend),
2417 "TELEMETRY_NODE_TYPE_COMPACTOR" => Ok(TelemetryNodeType::Compactor),
2418 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2419 }
2420 }
2421 }
2422 deserializer.deserialize_any(GeneratedVisitor)
2423 }
2424}