1#[derive(serde::Serialize, serde::Deserialize)]
3#[serde(rename_all = "snake_case")]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct DashboardFolder {
6 #[prost(message, optional, tag = "1")]
8 pub id: ::core::option::Option<::prost::alloc::string::String>,
9 #[prost(message, optional, tag = "2")]
11 pub name: ::core::option::Option<::prost::alloc::string::String>,
12 #[prost(message, optional, tag = "3")]
13 pub parent_id: ::core::option::Option<::prost::alloc::string::String>,
14}
15#[derive(serde::Serialize, serde::Deserialize)]
16#[serde(rename_all = "snake_case")]
17#[derive(Clone, PartialEq, ::prost::Message)]
18pub struct ObservationField {
19 #[prost(message, repeated, tag = "1")]
20 pub keypath: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
21 #[prost(enumeration = "DatasetScope", tag = "2")]
22 pub scope: i32,
23}
24#[derive(serde::Serialize, serde::Deserialize)]
25#[serde(rename_all = "snake_case")]
26#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
27#[repr(i32)]
28pub enum DatasetScope {
29 Unspecified = 0,
30 UserData = 1,
31 Label = 2,
32 Metadata = 3,
33}
34impl DatasetScope {
35 pub fn as_str_name(&self) -> &'static str {
40 match self {
41 Self::Unspecified => "DATASET_SCOPE_UNSPECIFIED",
42 Self::UserData => "DATASET_SCOPE_USER_DATA",
43 Self::Label => "DATASET_SCOPE_LABEL",
44 Self::Metadata => "DATASET_SCOPE_METADATA",
45 }
46 }
47 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
49 match value {
50 "DATASET_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
51 "DATASET_SCOPE_USER_DATA" => Some(Self::UserData),
52 "DATASET_SCOPE_LABEL" => Some(Self::Label),
53 "DATASET_SCOPE_METADATA" => Some(Self::Metadata),
54 _ => None,
55 }
56 }
57}
58#[derive(serde::Serialize, serde::Deserialize)]
59#[serde(rename_all = "snake_case")]
60#[derive(Clone, PartialEq, ::prost::Message)]
61pub struct DataprimeQuery {
62 #[prost(string, tag = "1")]
63 pub text: ::prost::alloc::string::String,
64}
65#[derive(serde::Serialize, serde::Deserialize)]
66#[serde(rename_all = "snake_case")]
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct SerializedDataprimeQuery {
69 #[prost(bytes = "vec", tag = "1")]
70 pub data: ::prost::alloc::vec::Vec<u8>,
71}
72#[derive(serde::Serialize, serde::Deserialize)]
73#[serde(rename_all = "snake_case")]
74#[derive(Clone, PartialEq, ::prost::Message)]
75pub struct FullDataprimeQuery {
76 #[prost(message, optional, tag = "1")]
77 pub serialized: ::core::option::Option<SerializedDataprimeQuery>,
78 #[prost(message, optional, tag = "2")]
79 pub raw: ::core::option::Option<DataprimeQuery>,
80}
81#[derive(serde::Serialize, serde::Deserialize)]
82#[serde(rename_all = "snake_case")]
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct PromQlQuery {
85 #[prost(message, optional, tag = "1")]
86 pub value: ::core::option::Option<::prost::alloc::string::String>,
87}
88#[derive(serde::Serialize, serde::Deserialize)]
89#[serde(rename_all = "snake_case")]
90#[derive(Clone, PartialEq, ::prost::Message)]
91pub struct LuceneQuery {
92 #[prost(message, optional, tag = "1")]
93 pub value: ::core::option::Option<::prost::alloc::string::String>,
94}
95#[derive(serde::Serialize, serde::Deserialize)]
96#[serde(rename_all = "snake_case")]
97#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
98#[repr(i32)]
99pub enum PromQlQueryType {
100 Unspecified = 0,
101 Range = 1,
102 Instant = 2,
103}
104impl PromQlQueryType {
105 pub fn as_str_name(&self) -> &'static str {
110 match self {
111 Self::Unspecified => "PROM_QL_QUERY_TYPE_UNSPECIFIED",
112 Self::Range => "PROM_QL_QUERY_TYPE_RANGE",
113 Self::Instant => "PROM_QL_QUERY_TYPE_INSTANT",
114 }
115 }
116 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
118 match value {
119 "PROM_QL_QUERY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
120 "PROM_QL_QUERY_TYPE_RANGE" => Some(Self::Range),
121 "PROM_QL_QUERY_TYPE_INSTANT" => Some(Self::Instant),
122 _ => None,
123 }
124 }
125}
126#[derive(serde::Serialize, serde::Deserialize)]
127#[serde(rename_all = "snake_case")]
128#[derive(Clone, PartialEq, ::prost::Message)]
129pub struct SpanField {
130 #[prost(oneof = "span_field::Value", tags = "1, 2, 3")]
131 pub value: ::core::option::Option<span_field::Value>,
132}
133pub mod span_field {
135 #[derive(serde::Serialize, serde::Deserialize)]
136 #[serde(rename_all = "snake_case")]
137 #[derive(
138 Clone,
139 Copy,
140 Debug,
141 PartialEq,
142 Eq,
143 Hash,
144 PartialOrd,
145 Ord,
146 ::prost::Enumeration
147 )]
148 #[repr(i32)]
149 pub enum MetadataField {
150 Unspecified = 0,
151 ApplicationName = 1,
152 SubsystemName = 2,
153 ServiceName = 3,
154 OperationName = 4,
155 }
156 impl MetadataField {
157 pub fn as_str_name(&self) -> &'static str {
162 match self {
163 Self::Unspecified => "METADATA_FIELD_UNSPECIFIED",
164 Self::ApplicationName => "METADATA_FIELD_APPLICATION_NAME",
165 Self::SubsystemName => "METADATA_FIELD_SUBSYSTEM_NAME",
166 Self::ServiceName => "METADATA_FIELD_SERVICE_NAME",
167 Self::OperationName => "METADATA_FIELD_OPERATION_NAME",
168 }
169 }
170 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
172 match value {
173 "METADATA_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
174 "METADATA_FIELD_APPLICATION_NAME" => Some(Self::ApplicationName),
175 "METADATA_FIELD_SUBSYSTEM_NAME" => Some(Self::SubsystemName),
176 "METADATA_FIELD_SERVICE_NAME" => Some(Self::ServiceName),
177 "METADATA_FIELD_OPERATION_NAME" => Some(Self::OperationName),
178 _ => None,
179 }
180 }
181 }
182 #[derive(serde::Serialize, serde::Deserialize)]
183 #[serde(rename_all = "snake_case")]
184 #[derive(Clone, PartialEq, ::prost::Oneof)]
185 pub enum Value {
186 #[prost(enumeration = "MetadataField", tag = "1")]
187 MetadataField(i32),
188 #[prost(message, tag = "2")]
189 TagField(::prost::alloc::string::String),
190 #[prost(message, tag = "3")]
191 ProcessTagField(::prost::alloc::string::String),
192 }
193}
194#[derive(serde::Serialize, serde::Deserialize)]
195#[serde(rename_all = "snake_case")]
196#[derive(Clone, PartialEq, ::prost::Message)]
197pub struct LogsAggregation {
198 #[prost(oneof = "logs_aggregation::Value", tags = "1, 2, 3, 4, 5, 6, 7")]
199 pub value: ::core::option::Option<logs_aggregation::Value>,
200}
201pub mod logs_aggregation {
203 #[derive(serde::Serialize, serde::Deserialize)]
204 #[serde(rename_all = "snake_case")]
205 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
206 pub struct Count {}
207 #[derive(serde::Serialize, serde::Deserialize)]
208 #[serde(rename_all = "snake_case")]
209 #[derive(Clone, PartialEq, ::prost::Message)]
210 pub struct CountDistinct {
211 #[prost(message, optional, tag = "1")]
212 pub field: ::core::option::Option<::prost::alloc::string::String>,
213 #[prost(message, optional, tag = "2")]
214 pub observation_field: ::core::option::Option<super::ObservationField>,
215 }
216 #[derive(serde::Serialize, serde::Deserialize)]
217 #[serde(rename_all = "snake_case")]
218 #[derive(Clone, PartialEq, ::prost::Message)]
219 pub struct Sum {
220 #[prost(message, optional, tag = "1")]
221 pub field: ::core::option::Option<::prost::alloc::string::String>,
222 #[prost(message, optional, tag = "2")]
223 pub observation_field: ::core::option::Option<super::ObservationField>,
224 }
225 #[derive(serde::Serialize, serde::Deserialize)]
226 #[serde(rename_all = "snake_case")]
227 #[derive(Clone, PartialEq, ::prost::Message)]
228 pub struct Average {
229 #[prost(message, optional, tag = "1")]
230 pub field: ::core::option::Option<::prost::alloc::string::String>,
231 #[prost(message, optional, tag = "2")]
232 pub observation_field: ::core::option::Option<super::ObservationField>,
233 }
234 #[derive(serde::Serialize, serde::Deserialize)]
235 #[serde(rename_all = "snake_case")]
236 #[derive(Clone, PartialEq, ::prost::Message)]
237 pub struct Min {
238 #[prost(message, optional, tag = "1")]
239 pub field: ::core::option::Option<::prost::alloc::string::String>,
240 #[prost(message, optional, tag = "2")]
241 pub observation_field: ::core::option::Option<super::ObservationField>,
242 }
243 #[derive(serde::Serialize, serde::Deserialize)]
244 #[serde(rename_all = "snake_case")]
245 #[derive(Clone, PartialEq, ::prost::Message)]
246 pub struct Max {
247 #[prost(message, optional, tag = "1")]
248 pub field: ::core::option::Option<::prost::alloc::string::String>,
249 #[prost(message, optional, tag = "2")]
250 pub observation_field: ::core::option::Option<super::ObservationField>,
251 }
252 #[derive(serde::Serialize, serde::Deserialize)]
253 #[serde(rename_all = "snake_case")]
254 #[derive(Clone, PartialEq, ::prost::Message)]
255 pub struct Percentile {
256 #[prost(message, optional, tag = "1")]
257 pub field: ::core::option::Option<::prost::alloc::string::String>,
258 #[prost(message, optional, tag = "2")]
260 pub percent: ::core::option::Option<f64>,
261 #[prost(message, optional, tag = "3")]
262 pub observation_field: ::core::option::Option<super::ObservationField>,
263 }
264 #[derive(serde::Serialize, serde::Deserialize)]
265 #[serde(rename_all = "snake_case")]
266 #[derive(Clone, PartialEq, ::prost::Oneof)]
267 pub enum Value {
268 #[prost(message, tag = "1")]
269 Count(Count),
270 #[prost(message, tag = "2")]
271 CountDistinct(CountDistinct),
272 #[prost(message, tag = "3")]
273 Sum(Sum),
274 #[prost(message, tag = "4")]
275 Average(Average),
276 #[prost(message, tag = "5")]
277 Min(Min),
278 #[prost(message, tag = "6")]
279 Max(Max),
280 #[prost(message, tag = "7")]
281 Percentile(Percentile),
282 }
283}
284#[derive(serde::Serialize, serde::Deserialize)]
285#[serde(rename_all = "snake_case")]
286#[derive(Clone, Copy, PartialEq, ::prost::Message)]
287pub struct SpansAggregation {
288 #[prost(oneof = "spans_aggregation::Aggregation", tags = "1, 2")]
289 pub aggregation: ::core::option::Option<spans_aggregation::Aggregation>,
290}
291pub mod spans_aggregation {
293 #[derive(serde::Serialize, serde::Deserialize)]
294 #[serde(rename_all = "snake_case")]
295 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
296 pub struct MetricAggregation {
297 #[prost(enumeration = "metric_aggregation::MetricField", tag = "1")]
298 pub metric_field: i32,
299 #[prost(enumeration = "metric_aggregation::MetricAggregationType", tag = "2")]
300 pub aggregation_type: i32,
301 }
302 pub mod metric_aggregation {
304 #[derive(serde::Serialize, serde::Deserialize)]
305 #[serde(rename_all = "snake_case")]
306 #[derive(
307 Clone,
308 Copy,
309 Debug,
310 PartialEq,
311 Eq,
312 Hash,
313 PartialOrd,
314 Ord,
315 ::prost::Enumeration
316 )]
317 #[repr(i32)]
318 pub enum MetricField {
319 Unspecified = 0,
320 Duration = 1,
321 }
322 impl MetricField {
323 pub fn as_str_name(&self) -> &'static str {
328 match self {
329 Self::Unspecified => "METRIC_FIELD_UNSPECIFIED",
330 Self::Duration => "METRIC_FIELD_DURATION",
331 }
332 }
333 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
335 match value {
336 "METRIC_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
337 "METRIC_FIELD_DURATION" => Some(Self::Duration),
338 _ => None,
339 }
340 }
341 }
342 #[derive(serde::Serialize, serde::Deserialize)]
343 #[serde(rename_all = "snake_case")]
344 #[derive(
345 Clone,
346 Copy,
347 Debug,
348 PartialEq,
349 Eq,
350 Hash,
351 PartialOrd,
352 Ord,
353 ::prost::Enumeration
354 )]
355 #[repr(i32)]
356 pub enum MetricAggregationType {
357 Unspecified = 0,
358 Min = 1,
359 Max = 2,
360 Average = 3,
361 Sum = 4,
362 Percentile99 = 5,
363 Percentile95 = 6,
364 Percentile50 = 7,
365 }
366 impl MetricAggregationType {
367 pub fn as_str_name(&self) -> &'static str {
372 match self {
373 Self::Unspecified => "METRIC_AGGREGATION_TYPE_UNSPECIFIED",
374 Self::Min => "METRIC_AGGREGATION_TYPE_MIN",
375 Self::Max => "METRIC_AGGREGATION_TYPE_MAX",
376 Self::Average => "METRIC_AGGREGATION_TYPE_AVERAGE",
377 Self::Sum => "METRIC_AGGREGATION_TYPE_SUM",
378 Self::Percentile99 => "METRIC_AGGREGATION_TYPE_PERCENTILE_99",
379 Self::Percentile95 => "METRIC_AGGREGATION_TYPE_PERCENTILE_95",
380 Self::Percentile50 => "METRIC_AGGREGATION_TYPE_PERCENTILE_50",
381 }
382 }
383 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
385 match value {
386 "METRIC_AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
387 "METRIC_AGGREGATION_TYPE_MIN" => Some(Self::Min),
388 "METRIC_AGGREGATION_TYPE_MAX" => Some(Self::Max),
389 "METRIC_AGGREGATION_TYPE_AVERAGE" => Some(Self::Average),
390 "METRIC_AGGREGATION_TYPE_SUM" => Some(Self::Sum),
391 "METRIC_AGGREGATION_TYPE_PERCENTILE_99" => Some(Self::Percentile99),
392 "METRIC_AGGREGATION_TYPE_PERCENTILE_95" => Some(Self::Percentile95),
393 "METRIC_AGGREGATION_TYPE_PERCENTILE_50" => Some(Self::Percentile50),
394 _ => None,
395 }
396 }
397 }
398 }
399 #[derive(serde::Serialize, serde::Deserialize)]
400 #[serde(rename_all = "snake_case")]
401 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
402 pub struct DimensionAggregation {
403 #[prost(enumeration = "dimension_aggregation::DimensionField", tag = "1")]
404 pub dimension_field: i32,
405 #[prost(
406 enumeration = "dimension_aggregation::DimensionAggregationType",
407 tag = "2"
408 )]
409 pub aggregation_type: i32,
410 }
411 pub mod dimension_aggregation {
413 #[derive(serde::Serialize, serde::Deserialize)]
414 #[serde(rename_all = "snake_case")]
415 #[derive(
416 Clone,
417 Copy,
418 Debug,
419 PartialEq,
420 Eq,
421 Hash,
422 PartialOrd,
423 Ord,
424 ::prost::Enumeration
425 )]
426 #[repr(i32)]
427 pub enum DimensionField {
428 Unspecified = 0,
429 TraceId = 1,
430 }
431 impl DimensionField {
432 pub fn as_str_name(&self) -> &'static str {
437 match self {
438 Self::Unspecified => "DIMENSION_FIELD_UNSPECIFIED",
439 Self::TraceId => "DIMENSION_FIELD_TRACE_ID",
440 }
441 }
442 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
444 match value {
445 "DIMENSION_FIELD_UNSPECIFIED" => Some(Self::Unspecified),
446 "DIMENSION_FIELD_TRACE_ID" => Some(Self::TraceId),
447 _ => None,
448 }
449 }
450 }
451 #[derive(serde::Serialize, serde::Deserialize)]
452 #[serde(rename_all = "snake_case")]
453 #[derive(
454 Clone,
455 Copy,
456 Debug,
457 PartialEq,
458 Eq,
459 Hash,
460 PartialOrd,
461 Ord,
462 ::prost::Enumeration
463 )]
464 #[repr(i32)]
465 pub enum DimensionAggregationType {
466 Unspecified = 0,
467 UniqueCount = 1,
468 ErrorCount = 2,
469 }
470 impl DimensionAggregationType {
471 pub fn as_str_name(&self) -> &'static str {
476 match self {
477 Self::Unspecified => "DIMENSION_AGGREGATION_TYPE_UNSPECIFIED",
478 Self::UniqueCount => "DIMENSION_AGGREGATION_TYPE_UNIQUE_COUNT",
479 Self::ErrorCount => "DIMENSION_AGGREGATION_TYPE_ERROR_COUNT",
480 }
481 }
482 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
484 match value {
485 "DIMENSION_AGGREGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
486 "DIMENSION_AGGREGATION_TYPE_UNIQUE_COUNT" => Some(Self::UniqueCount),
487 "DIMENSION_AGGREGATION_TYPE_ERROR_COUNT" => Some(Self::ErrorCount),
488 _ => None,
489 }
490 }
491 }
492 }
493 #[derive(serde::Serialize, serde::Deserialize)]
494 #[serde(rename_all = "snake_case")]
495 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
496 pub enum Aggregation {
497 #[prost(message, tag = "1")]
498 MetricAggregation(MetricAggregation),
499 #[prost(message, tag = "2")]
500 DimensionAggregation(DimensionAggregation),
501 }
502}
503#[derive(serde::Serialize, serde::Deserialize)]
504#[serde(rename_all = "snake_case")]
505#[derive(Clone, Copy, PartialEq, ::prost::Message)]
506pub struct TimeFrameSelect {
507 #[prost(oneof = "time_frame_select::Value", tags = "1, 2")]
508 pub value: ::core::option::Option<time_frame_select::Value>,
509}
510pub mod time_frame_select {
512 #[derive(serde::Serialize, serde::Deserialize)]
513 #[serde(rename_all = "snake_case")]
514 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
515 pub enum Value {
516 #[prost(message, tag = "1")]
517 AbsoluteTimeFrame(super::TimeFrame),
518 #[prost(message, tag = "2")]
519 RelativeTimeFrame(::prost_wkt_types::Duration),
520 }
521}
522#[derive(serde::Serialize, serde::Deserialize)]
523#[serde(rename_all = "snake_case")]
524#[derive(Clone, Copy, PartialEq, ::prost::Message)]
525pub struct TimeFrame {
526 #[prost(message, optional, tag = "1")]
527 pub from: ::core::option::Option<::prost_wkt_types::Timestamp>,
528 #[prost(message, optional, tag = "2")]
529 pub to: ::core::option::Option<::prost_wkt_types::Timestamp>,
530}
531#[derive(serde::Serialize, serde::Deserialize)]
532#[serde(rename_all = "snake_case")]
533#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
534#[repr(i32)]
535pub enum OrderDirection {
536 Unspecified = 0,
537 Asc = 1,
538 Desc = 2,
539}
540impl OrderDirection {
541 pub fn as_str_name(&self) -> &'static str {
546 match self {
547 Self::Unspecified => "ORDER_DIRECTION_UNSPECIFIED",
548 Self::Asc => "ORDER_DIRECTION_ASC",
549 Self::Desc => "ORDER_DIRECTION_DESC",
550 }
551 }
552 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
554 match value {
555 "ORDER_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified),
556 "ORDER_DIRECTION_ASC" => Some(Self::Asc),
557 "ORDER_DIRECTION_DESC" => Some(Self::Desc),
558 _ => None,
559 }
560 }
561}
562#[derive(serde::Serialize, serde::Deserialize)]
563#[serde(rename_all = "snake_case")]
564#[derive(Clone, PartialEq, ::prost::Message)]
565pub struct OrderingField {
566 #[prost(message, optional, tag = "1")]
567 pub field: ::core::option::Option<::prost::alloc::string::String>,
568 #[prost(enumeration = "OrderDirection", tag = "2")]
569 pub order_direction: i32,
570}