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

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