vendor/google.golang.org/genproto/googleapis/api/metric/metric.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/api/metric.proto
   3
   4 /*
   5 Package metric is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/api/metric.proto
   9
  10 It has these top-level messages:
  11         MetricDescriptor
  12         Metric
  13 */
  14 package metric
  15
  16 import proto "github.com/golang/protobuf/proto"
  17 import fmt "fmt"
  18 import math "math"
  19 import google_api "google.golang.org/genproto/googleapis/api/label"
  20
  21 // Reference imports to suppress errors if they are not otherwise used.
  22 var _ = proto.Marshal
  23 var _ = fmt.Errorf
  24 var _ = math.Inf
  25
  26 // This is a compile-time assertion to ensure that this generated file
  27 // is compatible with the proto package it is being compiled against.
  28 // A compilation error at this line likely means your copy of the
  29 // proto package needs to be updated.
  30 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  31
  32 // The kind of measurement. It describes how the data is reported.
  33 type MetricDescriptor_MetricKind int32
  34
  35 const (
  36         // Do not use this default value.
  37         MetricDescriptor_METRIC_KIND_UNSPECIFIED MetricDescriptor_MetricKind = 0
  38         // An instantaneous measurement of a value.
  39         MetricDescriptor_GAUGE MetricDescriptor_MetricKind = 1
  40         // The change in a value during a time interval.
  41         MetricDescriptor_DELTA MetricDescriptor_MetricKind = 2
  42         // A value accumulated over a time interval.  Cumulative
  43         // measurements in a time series should have the same start time
  44         // and increasing end times, until an event resets the cumulative
  45         // value to zero and sets a new start time for the following
  46         // points.
  47         MetricDescriptor_CUMULATIVE MetricDescriptor_MetricKind = 3
  48 )
  49
  50 var MetricDescriptor_MetricKind_name = map[int32]string{
  51         0: "METRIC_KIND_UNSPECIFIED",
  52         1: "GAUGE",
  53         2: "DELTA",
  54         3: "CUMULATIVE",
  55 }
  56 var MetricDescriptor_MetricKind_value = map[string]int32{
  57         "METRIC_KIND_UNSPECIFIED": 0,
  58         "GAUGE":                   1,
  59         "DELTA":                   2,
  60         "CUMULATIVE":              3,
  61 }
  62
  63 func (x MetricDescriptor_MetricKind) String() string {
  64         return proto.EnumName(MetricDescriptor_MetricKind_name, int32(x))
  65 }
  66 func (MetricDescriptor_MetricKind) EnumDescriptor() ([]byte, []int) {
  67         return fileDescriptor0, []int{0, 0}
  68 }
  69
  70 // The value type of a metric.
  71 type MetricDescriptor_ValueType int32
  72
  73 const (
  74         // Do not use this default value.
  75         MetricDescriptor_VALUE_TYPE_UNSPECIFIED MetricDescriptor_ValueType = 0
  76         // The value is a boolean.
  77         // This value type can be used only if the metric kind is `GAUGE`.
  78         MetricDescriptor_BOOL MetricDescriptor_ValueType = 1
  79         // The value is a signed 64-bit integer.
  80         MetricDescriptor_INT64 MetricDescriptor_ValueType = 2
  81         // The value is a double precision floating point number.
  82         MetricDescriptor_DOUBLE MetricDescriptor_ValueType = 3
  83         // The value is a text string.
  84         // This value type can be used only if the metric kind is `GAUGE`.
  85         MetricDescriptor_STRING MetricDescriptor_ValueType = 4
  86         // The value is a [`Distribution`][google.api.Distribution].
  87         MetricDescriptor_DISTRIBUTION MetricDescriptor_ValueType = 5
  88         // The value is money.
  89         MetricDescriptor_MONEY MetricDescriptor_ValueType = 6
  90 )
  91
  92 var MetricDescriptor_ValueType_name = map[int32]string{
  93         0: "VALUE_TYPE_UNSPECIFIED",
  94         1: "BOOL",
  95         2: "INT64",
  96         3: "DOUBLE",
  97         4: "STRING",
  98         5: "DISTRIBUTION",
  99         6: "MONEY",
 100 }
 101 var MetricDescriptor_ValueType_value = map[string]int32{
 102         "VALUE_TYPE_UNSPECIFIED": 0,
 103         "BOOL":         1,
 104         "INT64":        2,
 105         "DOUBLE":       3,
 106         "STRING":       4,
 107         "DISTRIBUTION": 5,
 108         "MONEY":        6,
 109 }
 110
 111 func (x MetricDescriptor_ValueType) String() string {
 112         return proto.EnumName(MetricDescriptor_ValueType_name, int32(x))
 113 }
 114 func (MetricDescriptor_ValueType) EnumDescriptor() ([]byte, []int) {
 115         return fileDescriptor0, []int{0, 1}
 116 }
 117
 118 // Defines a metric type and its schema. Once a metric descriptor is created,
 119 // deleting or altering it stops data collection and makes the metric type's
 120 // existing data unusable.
 121 type MetricDescriptor struct {
 122         // The resource name of the metric descriptor. Depending on the
 123         // implementation, the name typically includes: (1) the parent resource name
 124         // that defines the scope of the metric type or of its data; and (2) the
 125         // metric's URL-encoded type, which also appears in the `type` field of this
 126         // descriptor. For example, following is the resource name of a custom
 127         // metric within the GCP project `my-project-id`:
 128         //
 129         //     "projects/my-project-id/metricDescriptors/custom.googleapis.com%2Finvoice%2Fpaid%2Famount"
 130         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 131         // The metric type, including its DNS name prefix. The type is not
 132         // URL-encoded.  All user-defined custom metric types have the DNS name
 133         // `custom.googleapis.com`.  Metric types should use a natural hierarchical
 134         // grouping. For example:
 135         //
 136         //     "custom.googleapis.com/invoice/paid/amount"
 137         //     "appengine.googleapis.com/http/server/response_latencies"
 138         Type string `protobuf:"bytes,8,opt,name=type" json:"type,omitempty"`
 139         // The set of labels that can be used to describe a specific
 140         // instance of this metric type. For example, the
 141         // `appengine.googleapis.com/http/server/response_latencies` metric
 142         // type has a label for the HTTP response code, `response_code`, so
 143         // you can look at latencies for successful responses or just
 144         // for responses that failed.
 145         Labels []*google_api.LabelDescriptor `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty"`
 146         // Whether the metric records instantaneous values, changes to a value, etc.
 147         // Some combinations of `metric_kind` and `value_type` might not be supported.
 148         MetricKind MetricDescriptor_MetricKind `protobuf:"varint,3,opt,name=metric_kind,json=metricKind,enum=google.api.MetricDescriptor_MetricKind" json:"metric_kind,omitempty"`
 149         // Whether the measurement is an integer, a floating-point number, etc.
 150         // Some combinations of `metric_kind` and `value_type` might not be supported.
 151         ValueType MetricDescriptor_ValueType `protobuf:"varint,4,opt,name=value_type,json=valueType,enum=google.api.MetricDescriptor_ValueType" json:"value_type,omitempty"`
 152         // The unit in which the metric value is reported. It is only applicable
 153         // if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The
 154         // supported units are a subset of [The Unified Code for Units of
 155         // Measure](http://unitsofmeasure.org/ucum.html) standard:
 156         //
 157         // **Basic units (UNIT)**
 158         //
 159         // * `bit`   bit
 160         // * `By`    byte
 161         // * `s`     second
 162         // * `min`   minute
 163         // * `h`     hour
 164         // * `d`     day
 165         //
 166         // **Prefixes (PREFIX)**
 167         //
 168         // * `k`     kilo    (10**3)
 169         // * `M`     mega    (10**6)
 170         // * `G`     giga    (10**9)
 171         // * `T`     tera    (10**12)
 172         // * `P`     peta    (10**15)
 173         // * `E`     exa     (10**18)
 174         // * `Z`     zetta   (10**21)
 175         // * `Y`     yotta   (10**24)
 176         // * `m`     milli   (10**-3)
 177         // * `u`     micro   (10**-6)
 178         // * `n`     nano    (10**-9)
 179         // * `p`     pico    (10**-12)
 180         // * `f`     femto   (10**-15)
 181         // * `a`     atto    (10**-18)
 182         // * `z`     zepto   (10**-21)
 183         // * `y`     yocto   (10**-24)
 184         // * `Ki`    kibi    (2**10)
 185         // * `Mi`    mebi    (2**20)
 186         // * `Gi`    gibi    (2**30)
 187         // * `Ti`    tebi    (2**40)
 188         //
 189         // **Grammar**
 190         //
 191         // The grammar includes the dimensionless unit `1`, such as `1/s`.
 192         //
 193         // The grammar also includes these connectors:
 194         //
 195         // * `/`    division (as an infix operator, e.g. `1/s`).
 196         // * `.`    multiplication (as an infix operator, e.g. `GBy.d`)
 197         //
 198         // The grammar for a unit is as follows:
 199         //
 200         //     Expression = Component { "." Component } { "/" Component } ;
 201         //
 202         //     Component = [ PREFIX ] UNIT [ Annotation ]
 203         //               | Annotation
 204         //               | "1"
 205         //               ;
 206         //
 207         //     Annotation = "{" NAME "}" ;
 208         //
 209         // Notes:
 210         //
 211         // * `Annotation` is just a comment if it follows a `UNIT` and is
 212         //    equivalent to `1` if it is used alone. For examples,
 213         //    `{requests}/s == 1/s`, `By{transmitted}/s == By/s`.
 214         // * `NAME` is a sequence of non-blank printable ASCII characters not
 215         //    containing '{' or '}'.
 216         Unit string `protobuf:"bytes,5,opt,name=unit" json:"unit,omitempty"`
 217         // A detailed description of the metric, which can be used in documentation.
 218         Description string `protobuf:"bytes,6,opt,name=description" json:"description,omitempty"`
 219         // A concise name for the metric, which can be displayed in user interfaces.
 220         // Use sentence case without an ending period, for example "Request count".
 221         DisplayName string `protobuf:"bytes,7,opt,name=display_name,json=displayName" json:"display_name,omitempty"`
 222 }
 223
 224 func (m *MetricDescriptor) Reset()                    { *m = MetricDescriptor{} }
 225 func (m *MetricDescriptor) String() string            { return proto.CompactTextString(m) }
 226 func (*MetricDescriptor) ProtoMessage()               {}
 227 func (*MetricDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 228
 229 func (m *MetricDescriptor) GetName() string {
 230         if m != nil {
 231                 return m.Name
 232         }
 233         return ""
 234 }
 235
 236 func (m *MetricDescriptor) GetType() string {
 237         if m != nil {
 238                 return m.Type
 239         }
 240         return ""
 241 }
 242
 243 func (m *MetricDescriptor) GetLabels() []*google_api.LabelDescriptor {
 244         if m != nil {
 245                 return m.Labels
 246         }
 247         return nil
 248 }
 249
 250 func (m *MetricDescriptor) GetMetricKind() MetricDescriptor_MetricKind {
 251         if m != nil {
 252                 return m.MetricKind
 253         }
 254         return MetricDescriptor_METRIC_KIND_UNSPECIFIED
 255 }
 256
 257 func (m *MetricDescriptor) GetValueType() MetricDescriptor_ValueType {
 258         if m != nil {
 259                 return m.ValueType
 260         }
 261         return MetricDescriptor_VALUE_TYPE_UNSPECIFIED
 262 }
 263
 264 func (m *MetricDescriptor) GetUnit() string {
 265         if m != nil {
 266                 return m.Unit
 267         }
 268         return ""
 269 }
 270
 271 func (m *MetricDescriptor) GetDescription() string {
 272         if m != nil {
 273                 return m.Description
 274         }
 275         return ""
 276 }
 277
 278 func (m *MetricDescriptor) GetDisplayName() string {
 279         if m != nil {
 280                 return m.DisplayName
 281         }
 282         return ""
 283 }
 284
 285 // A specific metric, identified by specifying values for all of the
 286 // labels of a [`MetricDescriptor`][google.api.MetricDescriptor].
 287 type Metric struct {
 288         // An existing metric type, see [google.api.MetricDescriptor][google.api.MetricDescriptor].
 289         // For example, `custom.googleapis.com/invoice/paid/amount`.
 290         Type string `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"`
 291         // The set of label values that uniquely identify this metric. All
 292         // labels listed in the `MetricDescriptor` must be assigned values.
 293         Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
 294 }
 295
 296 func (m *Metric) Reset()                    { *m = Metric{} }
 297 func (m *Metric) String() string            { return proto.CompactTextString(m) }
 298 func (*Metric) ProtoMessage()               {}
 299 func (*Metric) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 300
 301 func (m *Metric) GetType() string {
 302         if m != nil {
 303                 return m.Type
 304         }
 305         return ""
 306 }
 307
 308 func (m *Metric) GetLabels() map[string]string {
 309         if m != nil {
 310                 return m.Labels
 311         }
 312         return nil
 313 }
 314
 315 func init() {
 316         proto.RegisterType((*MetricDescriptor)(nil), "google.api.MetricDescriptor")
 317         proto.RegisterType((*Metric)(nil), "google.api.Metric")
 318         proto.RegisterEnum("google.api.MetricDescriptor_MetricKind", MetricDescriptor_MetricKind_name, MetricDescriptor_MetricKind_value)
 319         proto.RegisterEnum("google.api.MetricDescriptor_ValueType", MetricDescriptor_ValueType_name, MetricDescriptor_ValueType_value)
 320 }
 321
 322 func init() { proto.RegisterFile("google/api/metric.proto", fileDescriptor0) }
 323
 324 var fileDescriptor0 = []byte{
 325         // 506 bytes of a gzipped FileDescriptorProto
 326         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x4d, 0x6f, 0xda, 0x40,
 327         0x10, 0xad, 0x3f, 0x70, 0xc3, 0x10, 0xa1, 0xd5, 0xaa, 0x4a, 0x2c, 0x22, 0x55, 0x94, 0x43, 0xcb,
 328         0x09, 0xa4, 0xa4, 0x4a, 0xbf, 0x4e, 0x80, 0xb7, 0xd4, 0x8a, 0xb1, 0x91, 0x63, 0x23, 0xa5, 0x17,
 329         0xcb, 0x81, 0x95, 0x65, 0xc5, 0xd8, 0xae, 0x71, 0x22, 0xf9, 0x57, 0xf4, 0x17, 0xf4, 0xd2, 0x5f,
 330         0x5a, 0xed, 0xae, 0x03, 0x16, 0x95, 0x72, 0xe2, 0xed, 0x9b, 0x37, 0x6f, 0x67, 0x96, 0x67, 0x38,
 331         0x8f, 0xb2, 0x2c, 0x4a, 0xe8, 0x38, 0xcc, 0xe3, 0xf1, 0x96, 0x96, 0x45, 0xbc, 0x1e, 0xe5, 0x45,
 332         0x56, 0x66, 0x18, 0x44, 0x61, 0x14, 0xe6, 0x71, 0xef, 0xac, 0x21, 0x4a, 0xc2, 0x7b, 0x9a, 0x08,
 333         0xcd, 0xe0, 0x8f, 0x0a, 0x68, 0xc1, 0x9b, 0x0c, 0xba, 0x5b, 0x17, 0x71, 0x5e, 0x66, 0x05, 0xc6,
 334         0xa0, 0xa6, 0xe1, 0x96, 0xea, 0x52, 0x5f, 0x1a, 0xb6, 0x5d, 0x8e, 0x19, 0x57, 0x56, 0x39, 0xd5,
 335         0x4f, 0x04, 0xc7, 0x30, 0xbe, 0x02, 0x8d, 0x7b, 0xed, 0x74, 0xb9, 0xaf, 0x0c, 0x3b, 0x97, 0x17,
 336         0xa3, 0xc3, 0x8d, 0x23, 0x8b, 0x55, 0x0e, 0xa6, 0x6e, 0x2d, 0xc5, 0x3f, 0xa0, 0x23, 0xa6, 0x0c,
 337         0x1e, 0xe2, 0x74, 0xa3, 0x2b, 0x7d, 0x69, 0xd8, 0xbd, 0xfc, 0xd0, 0xec, 0x3c, 0x9e, 0xa7, 0x26,
 338         0x6e, 0xe2, 0x74, 0xe3, 0xc2, 0x76, 0x8f, 0x31, 0x01, 0x78, 0x0a, 0x93, 0x47, 0x1a, 0xf0, 0xc1,
 339         0x54, 0x6e, 0xf4, 0xfe, 0x45, 0xa3, 0x15, 0x93, 0x7b, 0x55, 0x4e, 0xdd, 0xf6, 0xd3, 0x33, 0x64,
 340         0x9b, 0x3d, 0xa6, 0x71, 0xa9, 0xb7, 0xc4, 0x66, 0x0c, 0xe3, 0x3e, 0x74, 0x36, 0x75, 0x5b, 0x9c,
 341         0xa5, 0xba, 0xc6, 0x4b, 0x4d, 0x0a, 0xbf, 0x83, 0xd3, 0x4d, 0xbc, 0xcb, 0x93, 0xb0, 0x0a, 0xf8,
 342         0x5b, 0xbd, 0xae, 0x25, 0x82, 0xb3, 0xc3, 0x2d, 0x1d, 0x38, 0x00, 0x87, 0xc9, 0xf1, 0x05, 0x9c,
 343         0x2f, 0x88, 0xe7, 0x9a, 0xb3, 0xe0, 0xc6, 0xb4, 0x8d, 0xc0, 0xb7, 0x6f, 0x97, 0x64, 0x66, 0x7e,
 344         0x37, 0x89, 0x81, 0x5e, 0xe1, 0x36, 0xb4, 0xe6, 0x13, 0x7f, 0x4e, 0x90, 0xc4, 0xa0, 0x41, 0x2c,
 345         0x6f, 0x82, 0x64, 0xdc, 0x05, 0x98, 0xf9, 0x0b, 0xdf, 0x9a, 0x78, 0xe6, 0x8a, 0x20, 0x65, 0xf0,
 346         0x0b, 0xda, 0xfb, 0x0d, 0x70, 0x0f, 0xce, 0x56, 0x13, 0xcb, 0x27, 0x81, 0x77, 0xb7, 0x24, 0x47,
 347         0x76, 0x27, 0xa0, 0x4e, 0x1d, 0xc7, 0x12, 0x6e, 0xa6, 0xed, 0x5d, 0x7f, 0x44, 0x32, 0x06, 0xd0,
 348         0x0c, 0xc7, 0x9f, 0x5a, 0x04, 0x29, 0x0c, 0xdf, 0x7a, 0xae, 0x69, 0xcf, 0x91, 0x8a, 0x11, 0x9c,
 349         0x1a, 0x26, 0x3b, 0x4d, 0x7d, 0xcf, 0x74, 0x6c, 0xd4, 0x62, 0x4d, 0x0b, 0xc7, 0x26, 0x77, 0x48,
 350         0x1b, 0xfc, 0x96, 0x40, 0x13, 0x4b, 0xec, 0x13, 0xa0, 0x34, 0x12, 0x70, 0x7d, 0x94, 0x80, 0xb7,
 351         0xff, 0x3f, 0xbf, 0x08, 0xc2, 0x8e, 0xa4, 0x65, 0x51, 0x3d, 0x87, 0xa0, 0xf7, 0x05, 0x3a, 0x0d,
 352         0x1a, 0x23, 0x50, 0x1e, 0x68, 0x55, 0xe7, 0x8d, 0x41, 0xfc, 0x06, 0x5a, 0xfc, 0x1f, 0xd2, 0x65,
 353         0xce, 0x89, 0xc3, 0x57, 0xf9, 0xb3, 0x34, 0x0d, 0xa0, 0xbb, 0xce, 0xb6, 0x8d, 0x7b, 0xa6, 0x1d,
 354         0x71, 0xd1, 0x92, 0x05, 0x7a, 0x29, 0xfd, 0xfc, 0x54, 0x97, 0xa2, 0x2c, 0x09, 0xd3, 0x68, 0x94,
 355         0x15, 0xd1, 0x38, 0xa2, 0x29, 0x8f, 0xfb, 0x58, 0x94, 0xc2, 0x3c, 0xde, 0x35, 0x3e, 0x97, 0x6f,
 356         0xe2, 0xe7, 0xaf, 0xac, 0xce, 0x27, 0x4b, 0xf3, 0x5e, 0xe3, 0xd2, 0xab, 0x7f, 0x01, 0x00, 0x00,
 357         0xff, 0xff, 0x18, 0x04, 0x05, 0x82, 0x58, 0x03, 0x00, 0x00,
 358 }