origincloud_observability/generated/
origincloud.observability.v1beta1.rs

1// Code generated by origincloud-sdk-generator. DO NOT EDIT.
2// source: origincloud/observability/v1beta1/time_series.proto
3
4/// The request for QueryTimeSeries.
5#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
6pub struct QueryTimeSeriesRequest {
7    /// The project the resource is in, `projects/{project}`.
8    #[prost(string, tag = "1")]
9    pub parent: ::prost::alloc::string::String,
10    /// The resource whose metrics to return, in `parent`: an instance,
11    /// `projects/{project}/zones/{zone}/instances/{instance}`, a volume,
12    /// `projects/{project}/zones/{zone}/volumes/{volume}`, or a network
13    /// interface,
14    /// `projects/{project}/zones/{zone}/networkInterfaces/{network_interface}`.
15    #[prost(string, tag = "2")]
16    pub resource: ::prost::alloc::string::String,
17    /// The metrics to return, such as `oc_compute_instance_cpu_seconds_total`,
18    /// at least one. A metric of another kind of resource returns a series
19    /// without points.
20    #[prost(string, repeated, tag = "3")]
21    pub metrics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
22    /// The start of the window: the first point is at it.
23    #[prost(message, optional, tag = "4")]
24    pub start_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
25    /// The end of the window, not before `start_time`.
26    #[prost(message, optional, tag = "5")]
27    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
28    /// The length of each period, in whole seconds, at least one: the points
29    /// are this far apart, and each covers the period that ends at it. A
30    /// value is collected every 30 seconds and a point needs two inside its
31    /// period, so a period under 60 seconds often has none.
32    #[prost(message, optional, tag = "6")]
33    pub period: ::core::option::Option<::origincloud_core::protobuf::Duration>,
34    /// How each point is computed.
35    #[prost(enumeration = "query_time_series_request::Statistic", tag = "7")]
36    pub statistic: i32,
37}
38/// Nested message and enum types in `QueryTimeSeriesRequest`.
39pub mod query_time_series_request {
40    /// How each point is computed from the counter over its period.
41    #[derive(
42        Clone,
43        Copy,
44        Debug,
45        PartialEq,
46        Eq,
47        Hash,
48        PartialOrd,
49        Ord,
50        ::prost::Enumeration
51    )]
52    #[repr(i32)]
53    pub enum Statistic {
54        /// Not set.
55        Unspecified = 0,
56        /// The average per-second increase over the period, such as bytes per
57        /// second.
58        Rate = 1,
59        /// The total increase over the period, such as bytes transferred in it.
60        Increase = 2,
61    }
62    impl Statistic {
63        /// String value of the enum field names used in the ProtoBuf definition.
64        ///
65        /// The values are not transformed in any way and thus are considered stable
66        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
67        pub fn as_str_name(&self) -> &'static str {
68            match self {
69                Self::Unspecified => "STATISTIC_UNSPECIFIED",
70                Self::Rate => "RATE",
71                Self::Increase => "INCREASE",
72            }
73        }
74        /// Creates an enum from field names used in the ProtoBuf definition.
75        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
76            match value {
77                "STATISTIC_UNSPECIFIED" => Some(Self::Unspecified),
78                "RATE" => Some(Self::Rate),
79                "INCREASE" => Some(Self::Increase),
80                _ => None,
81            }
82        }
83    }
84}
85/// The response for QueryTimeSeries.
86#[derive(Clone, PartialEq, ::prost::Message)]
87pub struct QueryTimeSeriesResponse {
88    /// One series per metric asked, in the order asked.
89    #[prost(message, repeated, tag = "1")]
90    pub time_series: ::prost::alloc::vec::Vec<TimeSeries>,
91}
92/// A metric of one resource over the window: its points, in time order.
93#[derive(Clone, PartialEq, ::prost::Message)]
94pub struct TimeSeries {
95    /// The metric, as asked.
96    #[prost(string, tag = "1")]
97    pub metric: ::prost::alloc::string::String,
98    /// The resource, as asked.
99    #[prost(string, tag = "2")]
100    pub resource: ::prost::alloc::string::String,
101    /// The unit of the counter, such as `seconds` or `bytes`: a `query_time_series_request::Statistic::Rate` of a
102    /// `bytes` counter is bytes per second.
103    #[prost(string, tag = "3")]
104    pub unit: ::prost::alloc::string::String,
105    /// The points, one per period that has values, in time order. Empty when
106    /// the platform has no values for the resource and metric in the window,
107    /// such as for a stopped instance or a window older than 90 days.
108    #[prost(message, repeated, tag = "4")]
109    pub points: ::prost::alloc::vec::Vec<Point>,
110}
111/// The statistic over one period.
112#[derive(Clone, Copy, PartialEq, ::prost::Message)]
113pub struct Point {
114    /// The end of the period.
115    #[prost(message, optional, tag = "1")]
116    pub end_time: ::core::option::Option<::origincloud_core::protobuf::Timestamp>,
117    /// The statistic's value, in the series' `unit`, per second for `query_time_series_request::Statistic::Rate`.
118    #[prost(double, tag = "2")]
119    pub value: f64,
120}
121impl serde::Serialize for Point {
122    #[allow(deprecated)]
123    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
124    where
125        S: serde::Serializer,
126    {
127        use serde::ser::SerializeStruct;
128        let mut len = 0;
129        if self.end_time.is_some() {
130            len += 1;
131        }
132        if self.value != 0. {
133            len += 1;
134        }
135        let mut struct_ser = serializer
136            .serialize_struct("origincloud.observability.v1beta1.Point", len)?;
137        if let Some(v) = self.end_time.as_ref() {
138            struct_ser.serialize_field("endTime", v)?;
139        }
140        if self.value != 0. {
141            struct_ser.serialize_field("value", &self.value)?;
142        }
143        struct_ser.end()
144    }
145}
146impl<'de> serde::Deserialize<'de> for Point {
147    #[allow(deprecated)]
148    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
149    where
150        D: serde::Deserializer<'de>,
151    {
152        const FIELDS: &[&str] = &["end_time", "endTime", "value"];
153        #[allow(clippy::enum_variant_names)]
154        enum GeneratedField {
155            EndTime,
156            Value,
157            __SkipField__,
158        }
159        impl<'de> serde::Deserialize<'de> for GeneratedField {
160            fn deserialize<D>(
161                deserializer: D,
162            ) -> std::result::Result<GeneratedField, D::Error>
163            where
164                D: serde::Deserializer<'de>,
165            {
166                struct GeneratedVisitor;
167                impl serde::de::Visitor<'_> for GeneratedVisitor {
168                    type Value = GeneratedField;
169                    fn expecting(
170                        &self,
171                        formatter: &mut std::fmt::Formatter<'_>,
172                    ) -> std::fmt::Result {
173                        write!(formatter, "expected one of: {:?}", & FIELDS)
174                    }
175                    #[allow(unused_variables)]
176                    fn visit_str<E>(
177                        self,
178                        value: &str,
179                    ) -> std::result::Result<GeneratedField, E>
180                    where
181                        E: serde::de::Error,
182                    {
183                        match value {
184                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
185                            "value" => Ok(GeneratedField::Value),
186                            _ => Ok(GeneratedField::__SkipField__),
187                        }
188                    }
189                }
190                deserializer.deserialize_identifier(GeneratedVisitor)
191            }
192        }
193        struct GeneratedVisitor;
194        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
195            type Value = Point;
196            fn expecting(
197                &self,
198                formatter: &mut std::fmt::Formatter<'_>,
199            ) -> std::fmt::Result {
200                formatter.write_str("struct origincloud.observability.v1beta1.Point")
201            }
202            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Point, V::Error>
203            where
204                V: serde::de::MapAccess<'de>,
205            {
206                let mut end_time__ = None;
207                let mut value__ = None;
208                while let Some(k) = map_.next_key()? {
209                    match k {
210                        GeneratedField::EndTime => {
211                            if end_time__.is_some() {
212                                return Err(serde::de::Error::duplicate_field("endTime"));
213                            }
214                            end_time__ = map_.next_value()?;
215                        }
216                        GeneratedField::Value => {
217                            if value__.is_some() {
218                                return Err(serde::de::Error::duplicate_field("value"));
219                            }
220                            value__ = Some(
221                                map_
222                                    .next_value::<::pbjson::private::NumberDeserialize<_>>()?
223                                    .0,
224                            );
225                        }
226                        GeneratedField::__SkipField__ => {
227                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
228                        }
229                    }
230                }
231                Ok(Point {
232                    end_time: end_time__,
233                    value: value__.unwrap_or_default(),
234                })
235            }
236        }
237        deserializer
238            .deserialize_struct(
239                "origincloud.observability.v1beta1.Point",
240                FIELDS,
241                GeneratedVisitor,
242            )
243    }
244}
245impl serde::Serialize for QueryTimeSeriesRequest {
246    #[allow(deprecated)]
247    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
248    where
249        S: serde::Serializer,
250    {
251        use serde::ser::SerializeStruct;
252        let mut len = 0;
253        if !self.parent.is_empty() {
254            len += 1;
255        }
256        if !self.resource.is_empty() {
257            len += 1;
258        }
259        if !self.metrics.is_empty() {
260            len += 1;
261        }
262        if self.start_time.is_some() {
263            len += 1;
264        }
265        if self.end_time.is_some() {
266            len += 1;
267        }
268        if self.period.is_some() {
269            len += 1;
270        }
271        if self.statistic != 0 {
272            len += 1;
273        }
274        let mut struct_ser = serializer
275            .serialize_struct(
276                "origincloud.observability.v1beta1.QueryTimeSeriesRequest",
277                len,
278            )?;
279        if !self.parent.is_empty() {
280            struct_ser.serialize_field("parent", &self.parent)?;
281        }
282        if !self.resource.is_empty() {
283            struct_ser.serialize_field("resource", &self.resource)?;
284        }
285        if !self.metrics.is_empty() {
286            struct_ser.serialize_field("metrics", &self.metrics)?;
287        }
288        if let Some(v) = self.start_time.as_ref() {
289            struct_ser.serialize_field("startTime", v)?;
290        }
291        if let Some(v) = self.end_time.as_ref() {
292            struct_ser.serialize_field("endTime", v)?;
293        }
294        if let Some(v) = self.period.as_ref() {
295            struct_ser.serialize_field("period", v)?;
296        }
297        if self.statistic != 0 {
298            let v = query_time_series_request::Statistic::try_from(self.statistic)
299                .map_err(|_| serde::ser::Error::custom(
300                    format!("Invalid variant {}", self.statistic),
301                ))?;
302            struct_ser.serialize_field("statistic", &v)?;
303        }
304        struct_ser.end()
305    }
306}
307impl<'de> serde::Deserialize<'de> for QueryTimeSeriesRequest {
308    #[allow(deprecated)]
309    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
310    where
311        D: serde::Deserializer<'de>,
312    {
313        const FIELDS: &[&str] = &[
314            "parent",
315            "resource",
316            "metrics",
317            "start_time",
318            "startTime",
319            "end_time",
320            "endTime",
321            "period",
322            "statistic",
323        ];
324        #[allow(clippy::enum_variant_names)]
325        enum GeneratedField {
326            Parent,
327            Resource,
328            Metrics,
329            StartTime,
330            EndTime,
331            Period,
332            Statistic,
333            __SkipField__,
334        }
335        impl<'de> serde::Deserialize<'de> for GeneratedField {
336            fn deserialize<D>(
337                deserializer: D,
338            ) -> std::result::Result<GeneratedField, D::Error>
339            where
340                D: serde::Deserializer<'de>,
341            {
342                struct GeneratedVisitor;
343                impl serde::de::Visitor<'_> for GeneratedVisitor {
344                    type Value = GeneratedField;
345                    fn expecting(
346                        &self,
347                        formatter: &mut std::fmt::Formatter<'_>,
348                    ) -> std::fmt::Result {
349                        write!(formatter, "expected one of: {:?}", & FIELDS)
350                    }
351                    #[allow(unused_variables)]
352                    fn visit_str<E>(
353                        self,
354                        value: &str,
355                    ) -> std::result::Result<GeneratedField, E>
356                    where
357                        E: serde::de::Error,
358                    {
359                        match value {
360                            "parent" => Ok(GeneratedField::Parent),
361                            "resource" => Ok(GeneratedField::Resource),
362                            "metrics" => Ok(GeneratedField::Metrics),
363                            "startTime" | "start_time" => Ok(GeneratedField::StartTime),
364                            "endTime" | "end_time" => Ok(GeneratedField::EndTime),
365                            "period" => Ok(GeneratedField::Period),
366                            "statistic" => Ok(GeneratedField::Statistic),
367                            _ => Ok(GeneratedField::__SkipField__),
368                        }
369                    }
370                }
371                deserializer.deserialize_identifier(GeneratedVisitor)
372            }
373        }
374        struct GeneratedVisitor;
375        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
376            type Value = QueryTimeSeriesRequest;
377            fn expecting(
378                &self,
379                formatter: &mut std::fmt::Formatter<'_>,
380            ) -> std::fmt::Result {
381                formatter
382                    .write_str(
383                        "struct origincloud.observability.v1beta1.QueryTimeSeriesRequest",
384                    )
385            }
386            fn visit_map<V>(
387                self,
388                mut map_: V,
389            ) -> std::result::Result<QueryTimeSeriesRequest, V::Error>
390            where
391                V: serde::de::MapAccess<'de>,
392            {
393                let mut parent__ = None;
394                let mut resource__ = None;
395                let mut metrics__ = None;
396                let mut start_time__ = None;
397                let mut end_time__ = None;
398                let mut period__ = None;
399                let mut statistic__ = None;
400                while let Some(k) = map_.next_key()? {
401                    match k {
402                        GeneratedField::Parent => {
403                            if parent__.is_some() {
404                                return Err(serde::de::Error::duplicate_field("parent"));
405                            }
406                            parent__ = Some(map_.next_value()?);
407                        }
408                        GeneratedField::Resource => {
409                            if resource__.is_some() {
410                                return Err(serde::de::Error::duplicate_field("resource"));
411                            }
412                            resource__ = Some(map_.next_value()?);
413                        }
414                        GeneratedField::Metrics => {
415                            if metrics__.is_some() {
416                                return Err(serde::de::Error::duplicate_field("metrics"));
417                            }
418                            metrics__ = Some(map_.next_value()?);
419                        }
420                        GeneratedField::StartTime => {
421                            if start_time__.is_some() {
422                                return Err(serde::de::Error::duplicate_field("startTime"));
423                            }
424                            start_time__ = map_.next_value()?;
425                        }
426                        GeneratedField::EndTime => {
427                            if end_time__.is_some() {
428                                return Err(serde::de::Error::duplicate_field("endTime"));
429                            }
430                            end_time__ = map_.next_value()?;
431                        }
432                        GeneratedField::Period => {
433                            if period__.is_some() {
434                                return Err(serde::de::Error::duplicate_field("period"));
435                            }
436                            period__ = map_.next_value()?;
437                        }
438                        GeneratedField::Statistic => {
439                            if statistic__.is_some() {
440                                return Err(serde::de::Error::duplicate_field("statistic"));
441                            }
442                            statistic__ = Some(
443                                map_.next_value::<query_time_series_request::Statistic>()?
444                                    as i32,
445                            );
446                        }
447                        GeneratedField::__SkipField__ => {
448                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
449                        }
450                    }
451                }
452                Ok(QueryTimeSeriesRequest {
453                    parent: parent__.unwrap_or_default(),
454                    resource: resource__.unwrap_or_default(),
455                    metrics: metrics__.unwrap_or_default(),
456                    start_time: start_time__,
457                    end_time: end_time__,
458                    period: period__,
459                    statistic: statistic__.unwrap_or_default(),
460                })
461            }
462        }
463        deserializer
464            .deserialize_struct(
465                "origincloud.observability.v1beta1.QueryTimeSeriesRequest",
466                FIELDS,
467                GeneratedVisitor,
468            )
469    }
470}
471impl serde::Serialize for query_time_series_request::Statistic {
472    #[allow(deprecated)]
473    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
474    where
475        S: serde::Serializer,
476    {
477        let variant = match self {
478            Self::Unspecified => "STATISTIC_UNSPECIFIED",
479            Self::Rate => "RATE",
480            Self::Increase => "INCREASE",
481        };
482        serializer.serialize_str(variant)
483    }
484}
485impl<'de> serde::Deserialize<'de> for query_time_series_request::Statistic {
486    #[allow(deprecated)]
487    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
488    where
489        D: serde::Deserializer<'de>,
490    {
491        const FIELDS: &[&str] = &["STATISTIC_UNSPECIFIED", "RATE", "INCREASE"];
492        struct GeneratedVisitor;
493        impl serde::de::Visitor<'_> for GeneratedVisitor {
494            type Value = query_time_series_request::Statistic;
495            fn expecting(
496                &self,
497                formatter: &mut std::fmt::Formatter<'_>,
498            ) -> std::fmt::Result {
499                write!(formatter, "expected one of: {:?}", & FIELDS)
500            }
501            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
502            where
503                E: serde::de::Error,
504            {
505                i32::try_from(v)
506                    .ok()
507                    .and_then(|x| {
508                        x
509                            .try_into()
510                            .ok()
511                            .or_else(|| Some(
512                                query_time_series_request::Statistic::default(),
513                            ))
514                    })
515                    .ok_or_else(|| {
516                        serde::de::Error::invalid_value(
517                            serde::de::Unexpected::Signed(v),
518                            &self,
519                        )
520                    })
521            }
522            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
523            where
524                E: serde::de::Error,
525            {
526                i32::try_from(v)
527                    .ok()
528                    .and_then(|x| {
529                        x
530                            .try_into()
531                            .ok()
532                            .or_else(|| Some(
533                                query_time_series_request::Statistic::default(),
534                            ))
535                    })
536                    .ok_or_else(|| {
537                        serde::de::Error::invalid_value(
538                            serde::de::Unexpected::Unsigned(v),
539                            &self,
540                        )
541                    })
542            }
543            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
544            where
545                E: serde::de::Error,
546            {
547                match value {
548                    "STATISTIC_UNSPECIFIED" => {
549                        Ok(query_time_series_request::Statistic::Unspecified)
550                    }
551                    "RATE" => Ok(query_time_series_request::Statistic::Rate),
552                    "INCREASE" => Ok(query_time_series_request::Statistic::Increase),
553                    _ => Ok(query_time_series_request::Statistic::default()),
554                }
555            }
556        }
557        deserializer.deserialize_any(GeneratedVisitor)
558    }
559}
560impl serde::Serialize for QueryTimeSeriesResponse {
561    #[allow(deprecated)]
562    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
563    where
564        S: serde::Serializer,
565    {
566        use serde::ser::SerializeStruct;
567        let mut len = 0;
568        if !self.time_series.is_empty() {
569            len += 1;
570        }
571        let mut struct_ser = serializer
572            .serialize_struct(
573                "origincloud.observability.v1beta1.QueryTimeSeriesResponse",
574                len,
575            )?;
576        if !self.time_series.is_empty() {
577            struct_ser.serialize_field("timeSeries", &self.time_series)?;
578        }
579        struct_ser.end()
580    }
581}
582impl<'de> serde::Deserialize<'de> for QueryTimeSeriesResponse {
583    #[allow(deprecated)]
584    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
585    where
586        D: serde::Deserializer<'de>,
587    {
588        const FIELDS: &[&str] = &["time_series", "timeSeries"];
589        #[allow(clippy::enum_variant_names)]
590        enum GeneratedField {
591            TimeSeries,
592            __SkipField__,
593        }
594        impl<'de> serde::Deserialize<'de> for GeneratedField {
595            fn deserialize<D>(
596                deserializer: D,
597            ) -> std::result::Result<GeneratedField, D::Error>
598            where
599                D: serde::Deserializer<'de>,
600            {
601                struct GeneratedVisitor;
602                impl serde::de::Visitor<'_> for GeneratedVisitor {
603                    type Value = GeneratedField;
604                    fn expecting(
605                        &self,
606                        formatter: &mut std::fmt::Formatter<'_>,
607                    ) -> std::fmt::Result {
608                        write!(formatter, "expected one of: {:?}", & FIELDS)
609                    }
610                    #[allow(unused_variables)]
611                    fn visit_str<E>(
612                        self,
613                        value: &str,
614                    ) -> std::result::Result<GeneratedField, E>
615                    where
616                        E: serde::de::Error,
617                    {
618                        match value {
619                            "timeSeries" | "time_series" => {
620                                Ok(GeneratedField::TimeSeries)
621                            }
622                            _ => Ok(GeneratedField::__SkipField__),
623                        }
624                    }
625                }
626                deserializer.deserialize_identifier(GeneratedVisitor)
627            }
628        }
629        struct GeneratedVisitor;
630        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
631            type Value = QueryTimeSeriesResponse;
632            fn expecting(
633                &self,
634                formatter: &mut std::fmt::Formatter<'_>,
635            ) -> std::fmt::Result {
636                formatter
637                    .write_str(
638                        "struct origincloud.observability.v1beta1.QueryTimeSeriesResponse",
639                    )
640            }
641            fn visit_map<V>(
642                self,
643                mut map_: V,
644            ) -> std::result::Result<QueryTimeSeriesResponse, V::Error>
645            where
646                V: serde::de::MapAccess<'de>,
647            {
648                let mut time_series__ = None;
649                while let Some(k) = map_.next_key()? {
650                    match k {
651                        GeneratedField::TimeSeries => {
652                            if time_series__.is_some() {
653                                return Err(serde::de::Error::duplicate_field("timeSeries"));
654                            }
655                            time_series__ = Some(map_.next_value()?);
656                        }
657                        GeneratedField::__SkipField__ => {
658                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
659                        }
660                    }
661                }
662                Ok(QueryTimeSeriesResponse {
663                    time_series: time_series__.unwrap_or_default(),
664                })
665            }
666        }
667        deserializer
668            .deserialize_struct(
669                "origincloud.observability.v1beta1.QueryTimeSeriesResponse",
670                FIELDS,
671                GeneratedVisitor,
672            )
673    }
674}
675impl serde::Serialize for TimeSeries {
676    #[allow(deprecated)]
677    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
678    where
679        S: serde::Serializer,
680    {
681        use serde::ser::SerializeStruct;
682        let mut len = 0;
683        if !self.metric.is_empty() {
684            len += 1;
685        }
686        if !self.resource.is_empty() {
687            len += 1;
688        }
689        if !self.unit.is_empty() {
690            len += 1;
691        }
692        if !self.points.is_empty() {
693            len += 1;
694        }
695        let mut struct_ser = serializer
696            .serialize_struct("origincloud.observability.v1beta1.TimeSeries", len)?;
697        if !self.metric.is_empty() {
698            struct_ser.serialize_field("metric", &self.metric)?;
699        }
700        if !self.resource.is_empty() {
701            struct_ser.serialize_field("resource", &self.resource)?;
702        }
703        if !self.unit.is_empty() {
704            struct_ser.serialize_field("unit", &self.unit)?;
705        }
706        if !self.points.is_empty() {
707            struct_ser.serialize_field("points", &self.points)?;
708        }
709        struct_ser.end()
710    }
711}
712impl<'de> serde::Deserialize<'de> for TimeSeries {
713    #[allow(deprecated)]
714    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
715    where
716        D: serde::Deserializer<'de>,
717    {
718        const FIELDS: &[&str] = &["metric", "resource", "unit", "points"];
719        #[allow(clippy::enum_variant_names)]
720        enum GeneratedField {
721            Metric,
722            Resource,
723            Unit,
724            Points,
725            __SkipField__,
726        }
727        impl<'de> serde::Deserialize<'de> for GeneratedField {
728            fn deserialize<D>(
729                deserializer: D,
730            ) -> std::result::Result<GeneratedField, D::Error>
731            where
732                D: serde::Deserializer<'de>,
733            {
734                struct GeneratedVisitor;
735                impl serde::de::Visitor<'_> for GeneratedVisitor {
736                    type Value = GeneratedField;
737                    fn expecting(
738                        &self,
739                        formatter: &mut std::fmt::Formatter<'_>,
740                    ) -> std::fmt::Result {
741                        write!(formatter, "expected one of: {:?}", & FIELDS)
742                    }
743                    #[allow(unused_variables)]
744                    fn visit_str<E>(
745                        self,
746                        value: &str,
747                    ) -> std::result::Result<GeneratedField, E>
748                    where
749                        E: serde::de::Error,
750                    {
751                        match value {
752                            "metric" => Ok(GeneratedField::Metric),
753                            "resource" => Ok(GeneratedField::Resource),
754                            "unit" => Ok(GeneratedField::Unit),
755                            "points" => Ok(GeneratedField::Points),
756                            _ => Ok(GeneratedField::__SkipField__),
757                        }
758                    }
759                }
760                deserializer.deserialize_identifier(GeneratedVisitor)
761            }
762        }
763        struct GeneratedVisitor;
764        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
765            type Value = TimeSeries;
766            fn expecting(
767                &self,
768                formatter: &mut std::fmt::Formatter<'_>,
769            ) -> std::fmt::Result {
770                formatter
771                    .write_str("struct origincloud.observability.v1beta1.TimeSeries")
772            }
773            fn visit_map<V>(
774                self,
775                mut map_: V,
776            ) -> std::result::Result<TimeSeries, V::Error>
777            where
778                V: serde::de::MapAccess<'de>,
779            {
780                let mut metric__ = None;
781                let mut resource__ = None;
782                let mut unit__ = None;
783                let mut points__ = None;
784                while let Some(k) = map_.next_key()? {
785                    match k {
786                        GeneratedField::Metric => {
787                            if metric__.is_some() {
788                                return Err(serde::de::Error::duplicate_field("metric"));
789                            }
790                            metric__ = Some(map_.next_value()?);
791                        }
792                        GeneratedField::Resource => {
793                            if resource__.is_some() {
794                                return Err(serde::de::Error::duplicate_field("resource"));
795                            }
796                            resource__ = Some(map_.next_value()?);
797                        }
798                        GeneratedField::Unit => {
799                            if unit__.is_some() {
800                                return Err(serde::de::Error::duplicate_field("unit"));
801                            }
802                            unit__ = Some(map_.next_value()?);
803                        }
804                        GeneratedField::Points => {
805                            if points__.is_some() {
806                                return Err(serde::de::Error::duplicate_field("points"));
807                            }
808                            points__ = Some(map_.next_value()?);
809                        }
810                        GeneratedField::__SkipField__ => {
811                            let _ = map_.next_value::<serde::de::IgnoredAny>()?;
812                        }
813                    }
814                }
815                Ok(TimeSeries {
816                    metric: metric__.unwrap_or_default(),
817                    resource: resource__.unwrap_or_default(),
818                    unit: unit__.unwrap_or_default(),
819                    points: points__.unwrap_or_default(),
820                })
821            }
822        }
823        deserializer
824            .deserialize_struct(
825                "origincloud.observability.v1beta1.TimeSeries",
826                FIELDS,
827                GeneratedVisitor,
828            )
829    }
830}
831/// Calls `MetricService`.
832///
833/// The metrics the platform collects for a project's compute instances,
834/// volumes and network interfaces: CPU time, network traffic, and volume
835/// reads and writes. Every metric is a counter, a running total that grows
836/// while the instance runs. A query never returns the raw total: for each
837/// period of the window it asks for, it returns the counter's average
838/// per-second increase over the period (`query_time_series_request::Statistic::Rate`) or its total increase
839/// (`query_time_series_request::Statistic::Increase`). The platform collects a value for each counter every 30
840/// seconds while the instance runs, and keeps the values for 90 days. A
841/// volume or a network interface is measured through the instance it is
842/// attached to, so it has values only while attached to a running instance.
843#[derive(Clone, Debug)]
844pub struct MetricClient {
845    service: ::origincloud_core::Service,
846}
847impl MetricClient {
848    /// Returns a client of `MetricService` that sends its calls through `client`.
849    pub fn new(client: &::origincloud_core::Client) -> Self {
850        Self {
851            service: client.service("observability", true),
852        }
853    }
854    /// The endpoint the client sends its calls to, which also serves the operations its methods answer with.
855    pub fn service(&self) -> &::origincloud_core::Service {
856        &self.service
857    }
858    /// Returns a resource's time series for the metrics asked, one per
859    /// metric, in the order asked. Needs `observability.metric.get` on the
860    /// resource.
861    ///
862    /// A query is limited in what it costs. Its points, the window's length
863    /// divided by `period`, plus one, for each of its metrics, are at most
864    /// 11,000 in all, and an organization may run 60 queries a minute and 4 at
865    /// a time. A query over any of these limits is refused with
866    /// `FAILED_PRECONDITION`, the same message for all three: one within the
867    /// points limit succeeds when sent again a few seconds later.
868    ///
869    /// Each query answered is billed as one request, however many series or
870    /// points it returns; a refused one isn't.
871    pub async fn query_time_series(
872        &self,
873        request: QueryTimeSeriesRequest,
874    ) -> ::core::result::Result<QueryTimeSeriesResponse, ::origincloud_core::Error> {
875        let p0 = ::origincloud_core::path_value(
876            "parent",
877            &request.parent,
878            "projects/*",
879        )?;
880        let query = ::origincloud_core::query(&request, &["parent"])?;
881        let call = ::origincloud_core::Request::new(
882                ::origincloud_core::Method::GET,
883                format!("/v1beta1/{p0}/timeSeries:query"),
884            )
885            .with_query(query)
886            .idempotent();
887        self.service.call(call).await
888    }
889}
origincloud_observability/generated/origincloud.observability.v1beta1.rs

origincloud_observability/generated/
origincloud.observability.v1beta1.rs
