mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2025-02-02 08:31:11 -08:00
Code Issues Actions 55 Packages Projects Releases Wiki Activity

Merge pull request #10932 from prometheus/beorn7/protobuf

Browse source 
prompb: Update exposition protobuf to include float and gauge histograms
This commit is contained in:
Björn Rabenstein 2022-06-30 10:44:38 +02:00 committed by GitHub
parent a97b64c2cc d758198e37
commit 1dc732c130
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 311 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

353
prompb/io/prometheus/client/metrics.pb.go
View file

@ -28,11 +28,18 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type MetricType int32 type MetricType int32
const ( const (
MetricType_COUNTER MetricType = 0 // COUNTER must use the Metric field "counter".
MetricType_GAUGE MetricType = 1 MetricType_COUNTER MetricType = 0
MetricType_SUMMARY MetricType = 2 // GAUGE must use the Metric field "gauge".
MetricType_UNTYPED MetricType = 3 MetricType_GAUGE MetricType = 1
// SUMMARY must use the Metric field "summary".
MetricType_SUMMARY MetricType = 2
// UNTYPED must use the Metric field "untyped".
MetricType_UNTYPED MetricType = 3
// HISTOGRAM must use the Metric field "histogram".
MetricType_HISTOGRAM MetricType = 4 MetricType_HISTOGRAM MetricType = 4
// GAUGE_HISTOGRAM must use the Metric field "histogram".
MetricType_GAUGE_HISTOGRAM MetricType = 5
) )
var MetricType_name = map[int32]string{ var MetricType_name = map[int32]string{
@ -41,14 +48,16 @@ var MetricType_name = map[int32]string{
2: "SUMMARY", 2: "SUMMARY",
3: "UNTYPED", 3: "UNTYPED",
4: "HISTOGRAM", 4: "HISTOGRAM",
5: "GAUGE_HISTOGRAM",
} }
var MetricType_value = map[string]int32{ var MetricType_value = map[string]int32{
"COUNTER": 0, "COUNTER": 0,
"GAUGE": 1, "GAUGE": 1,
"SUMMARY": 2, "SUMMARY": 2,
"UNTYPED": 3, "UNTYPED": 3,
"HISTOGRAM": 4, "HISTOGRAM": 4,
"GAUGE_HISTOGRAM": 5,
} }
func (x MetricType) String() string { func (x MetricType) String() string {
@ -382,9 +391,10 @@ func (m *Untyped) GetValue() float64 {
} }
type Histogram struct { type Histogram struct {
SampleCount uint64 `protobuf:"varint,1,opt,name=sample_count,json=sampleCount,proto3" json:"sample_count,omitempty"` SampleCount uint64 `protobuf:"varint,1,opt,name=sample_count,json=sampleCount,proto3" json:"sample_count,omitempty"`
SampleSum float64 `protobuf:"fixed64,2,opt,name=sample_sum,json=sampleSum,proto3" json:"sample_sum,omitempty"` SampleCountFloat float64 `protobuf:"fixed64,9,opt,name=sample_count_float,json=sampleCountFloat,proto3" json:"sample_count_float,omitempty"`
Bucket []*Bucket `protobuf:"bytes,3,rep,name=bucket,proto3" json:"bucket,omitempty"` SampleSum float64 `protobuf:"fixed64,2,opt,name=sample_sum,json=sampleSum,proto3" json:"sample_sum,omitempty"`
Bucket []*Bucket `protobuf:"bytes,3,rep,name=bucket,proto3" json:"bucket,omitempty"`
// Sparse bucket (sb) stuff: // Sparse bucket (sb) stuff:
// The sb_schema defines the bucket schema. Currently, valid numbers are -4 <= n <= 8. // The sb_schema defines the bucket schema. Currently, valid numbers are -4 <= n <= 8.
// They are all for base-2 bucket schemas, where 1 is a bucket boundary in each case, and // They are all for base-2 bucket schemas, where 1 is a bucket boundary in each case, and
@ -394,6 +404,7 @@ type Histogram struct {
SbSchema int32 `protobuf:"zigzag32,4,opt,name=sb_schema,json=sbSchema,proto3" json:"sb_schema,omitempty"` SbSchema int32 `protobuf:"zigzag32,4,opt,name=sb_schema,json=sbSchema,proto3" json:"sb_schema,omitempty"`
SbZeroThreshold float64 `protobuf:"fixed64,5,opt,name=sb_zero_threshold,json=sbZeroThreshold,proto3" json:"sb_zero_threshold,omitempty"` SbZeroThreshold float64 `protobuf:"fixed64,5,opt,name=sb_zero_threshold,json=sbZeroThreshold,proto3" json:"sb_zero_threshold,omitempty"`
SbZeroCount uint64 `protobuf:"varint,6,opt,name=sb_zero_count,json=sbZeroCount,proto3" json:"sb_zero_count,omitempty"` SbZeroCount uint64 `protobuf:"varint,6,opt,name=sb_zero_count,json=sbZeroCount,proto3" json:"sb_zero_count,omitempty"`
SbZeroCountFloat float64 `protobuf:"fixed64,10,opt,name=sb_zero_count_float,json=sbZeroCountFloat,proto3" json:"sb_zero_count_float,omitempty"`
SbNegative *SparseBuckets `protobuf:"bytes,7,opt,name=sb_negative,json=sbNegative,proto3" json:"sb_negative,omitempty"` SbNegative *SparseBuckets `protobuf:"bytes,7,opt,name=sb_negative,json=sbNegative,proto3" json:"sb_negative,omitempty"`
SbPositive *SparseBuckets `protobuf:"bytes,8,opt,name=sb_positive,json=sbPositive,proto3" json:"sb_positive,omitempty"` SbPositive *SparseBuckets `protobuf:"bytes,8,opt,name=sb_positive,json=sbPositive,proto3" json:"sb_positive,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -441,6 +452,13 @@ func (m *Histogram) GetSampleCount() uint64 {
return 0 return 0
} }
func (m *Histogram) GetSampleCountFloat() float64 {
if m != nil {
return m.SampleCountFloat
}
return 0
}
func (m *Histogram) GetSampleSum() float64 { func (m *Histogram) GetSampleSum() float64 {
if m != nil { if m != nil {
return m.SampleSum return m.SampleSum
@ -476,6 +494,13 @@ func (m *Histogram) GetSbZeroCount() uint64 {
return 0 return 0
} }
func (m *Histogram) GetSbZeroCountFloat() float64 {
if m != nil {
return m.SbZeroCountFloat
}
return 0
}
func (m *Histogram) GetSbNegative() *SparseBuckets { func (m *Histogram) GetSbNegative() *SparseBuckets {
if m != nil { if m != nil {
return m.SbNegative return m.SbNegative
@ -492,6 +517,7 @@ func (m *Histogram) GetSbPositive() *SparseBuckets {
type Bucket struct { type Bucket struct {
CumulativeCount uint64 `protobuf:"varint,1,opt,name=cumulative_count,json=cumulativeCount,proto3" json:"cumulative_count,omitempty"` CumulativeCount uint64 `protobuf:"varint,1,opt,name=cumulative_count,json=cumulativeCount,proto3" json:"cumulative_count,omitempty"`
CumulativeCountFloat float64 `protobuf:"fixed64,4,opt,name=cumulative_count_float,json=cumulativeCountFloat,proto3" json:"cumulative_count_float,omitempty"`
UpperBound float64 `protobuf:"fixed64,2,opt,name=upper_bound,json=upperBound,proto3" json:"upper_bound,omitempty"` UpperBound float64 `protobuf:"fixed64,2,opt,name=upper_bound,json=upperBound,proto3" json:"upper_bound,omitempty"`
Exemplar *Exemplar `protobuf:"bytes,3,opt,name=exemplar,proto3" json:"exemplar,omitempty"` Exemplar *Exemplar `protobuf:"bytes,3,opt,name=exemplar,proto3" json:"exemplar,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -539,6 +565,13 @@ func (m *Bucket) GetCumulativeCount() uint64 {
return 0 return 0
} }
func (m *Bucket) GetCumulativeCountFloat() float64 {
if m != nil {
return m.CumulativeCountFloat
}
return 0
}
func (m *Bucket) GetUpperBound() float64 { func (m *Bucket) GetUpperBound() float64 {
if m != nil { if m != nil {
return m.UpperBound return m.UpperBound
@ -554,11 +587,14 @@ func (m *Bucket) GetExemplar() *Exemplar {
} }
type SparseBuckets struct { type SparseBuckets struct {
Span []*SparseBuckets_Span `protobuf:"bytes,1,rep,name=span,proto3" json:"span,omitempty"` Span []*SparseBuckets_Span `protobuf:"bytes,1,rep,name=span,proto3" json:"span,omitempty"`
Delta []int64 `protobuf:"zigzag64,2,rep,packed,name=delta,proto3" json:"delta,omitempty"` // Only one of "delta" or "count" may be used, the former for regular
XXX_NoUnkeyedLiteral struct{} `json:"-"` // histograms with integer counts, the latter for float histograms.
XXX_unrecognized []byte `json:"-"` Delta []int64 `protobuf:"zigzag64,2,rep,packed,name=delta,proto3" json:"delta,omitempty"`
XXX_sizecache int32 `json:"-"` Count []float64 `protobuf:"fixed64,3,rep,packed,name=count,proto3" json:"count,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
} }
func (m *SparseBuckets) Reset() { *m = SparseBuckets{} } func (m *SparseBuckets) Reset() { *m = SparseBuckets{} }
@ -608,6 +644,19 @@ func (m *SparseBuckets) GetDelta() []int64 {
return nil return nil
} }
func (m *SparseBuckets) GetCount() []float64 {
if m != nil {
return m.Count
}
return nil
}
// A Span is a given number of consecutive buckets at a given
// offset. Logically, it would be more straightforward to include
// the bucket counts in the Span. However, the protobuf
// representation is more compact in the way the data is structured
// here (with all the buckets in a single array separate from the
// Spans).
type SparseBuckets_Span struct { type SparseBuckets_Span struct {
Offset int32 `protobuf:"zigzag32,1,opt,name=offset,proto3" json:"offset,omitempty"` Offset int32 `protobuf:"zigzag32,1,opt,name=offset,proto3" json:"offset,omitempty"`
Length uint32 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"` Length uint32 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"`
@ -914,60 +963,65 @@ func init() {
} }
var fileDescriptor_d1e5ddb18987a258 = []byte{ var fileDescriptor_d1e5ddb18987a258 = []byte{
// 848 bytes of a gzipped FileDescriptorProto // 913 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4f, 0x8f, 0xdb, 0x44, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xdd, 0x72, 0xdb, 0x44,
0x14, 0xc7, 0x89, 0xf3, 0xc7, 0x2f, 0x5d, 0x9a, 0x1d, 0xad, 0x90, 0xb5, 0x65, 0x77, 0x83, 0xb9, 0x14, 0x46, 0xb1, 0xfc, 0xa3, 0xe3, 0x86, 0x38, 0xdb, 0x4c, 0x47, 0x93, 0x92, 0xc4, 0x88, 0x9b,
0x2c, 0x3d, 0x38, 0xa2, 0xb4, 0x80, 0x50, 0x39, 0xec, 0xb6, 0x21, 0x45, 0x22, 0xdb, 0x65, 0x92, 0xd0, 0x01, 0x7b, 0x28, 0x29, 0x30, 0x4c, 0xb9, 0x48, 0xda, 0x34, 0x65, 0x06, 0xa7, 0x61, 0x6d,
0x1c, 0x5a, 0x0e, 0xd6, 0x38, 0x99, 0x4d, 0x2c, 0x3c, 0x1e, 0xe3, 0xb1, 0x2b, 0xc2, 0x17, 0xe0, 0x5f, 0xb4, 0x5c, 0x68, 0x56, 0xce, 0xc6, 0xd6, 0x20, 0x69, 0x85, 0x76, 0xd5, 0xc1, 0xbc, 0x00,
0x0a, 0x67, 0x6e, 0x7c, 0x1a, 0x8e, 0x7c, 0x04, 0xb4, 0x9f, 0x03, 0x09, 0x34, 0x7f, 0xec, 0x10, 0xd7, 0xbc, 0x02, 0x6f, 0xc0, 0x4b, 0x30, 0x5c, 0x72, 0xcb, 0x1d, 0x93, 0x17, 0x81, 0xd9, 0x1f,
0xc9, 0x41, 0x14, 0xf5, 0xe6, 0xf7, 0xfc, 0xfb, 0xbd, 0xf9, 0xbd, 0x37, 0x33, 0xbf, 0x01, 0x2f, 0x49, 0x71, 0x47, 0x86, 0xb6, 0x77, 0x3e, 0xc7, 0xdf, 0x77, 0xf4, 0x7d, 0x47, 0xbb, 0x9f, 0xc0,
0xe2, 0xc3, 0x34, 0xe3, 0x8c, 0xe6, 0x6b, 0x5a, 0x88, 0xe1, 0x22, 0x8e, 0x68, 0x92, 0x0f, 0x19, 0x0b, 0xd9, 0x30, 0xcd, 0x58, 0x4c, 0xc5, 0x82, 0xe6, 0x7c, 0x38, 0x8b, 0x42, 0x9a, 0x88, 0x61,
0xcd, 0xb3, 0x68, 0x21, 0xfc, 0x34, 0xe3, 0x39, 0x47, 0x47, 0x11, 0xf7, 0xb7, 0x18, 0x5f, 0x63, 0x4c, 0x45, 0x16, 0xce, 0xf8, 0x20, 0xcd, 0x98, 0x60, 0x68, 0x27, 0x64, 0x83, 0x0a, 0x33, 0xd0,
0x8e, 0xcf, 0x56, 0x9c, 0xaf, 0x62, 0x3a, 0x54, 0x98, 0xb0, 0xb8, 0x19, 0xe6, 0x11, 0xa3, 0x22, 0x98, 0xdd, 0x83, 0x39, 0x63, 0xf3, 0x88, 0x0e, 0x15, 0x26, 0xc8, 0xaf, 0x86, 0x22, 0x8c, 0x29,
0x27, 0x2c, 0xd5, 0x34, 0xef, 0x11, 0x38, 0x5f, 0x91, 0x90, 0xc6, 0xd7, 0x24, 0xca, 0x10, 0x02, 0x17, 0x24, 0x4e, 0x35, 0xcd, 0x7b, 0x00, 0xce, 0x37, 0x24, 0xa0, 0xd1, 0x05, 0x09, 0x33, 0x84,
0x3b, 0x21, 0x8c, 0xba, 0xd6, 0xc0, 0x3a, 0x77, 0xb0, 0xfa, 0x46, 0x47, 0xd0, 0x7a, 0x45, 0xe2, 0xc0, 0x4e, 0x48, 0x4c, 0x5d, 0xab, 0x6f, 0x1d, 0x3a, 0x58, 0xfd, 0x46, 0x3b, 0xd0, 0x7c, 0x49,
0x82, 0xba, 0x0d, 0x95, 0xd4, 0x81, 0x77, 0x02, 0xad, 0x31, 0x29, 0x56, 0xff, 0xf8, 0x2d, 0x39, 0xa2, 0x9c, 0xba, 0x1b, 0xaa, 0xa9, 0x0b, 0x6f, 0x0f, 0x9a, 0x67, 0x24, 0x9f, 0xdf, 0xf8, 0x5b,
0x56, 0xf9, 0xfb, 0x1b, 0xe8, 0x3c, 0xe1, 0x45, 0x92, 0xd3, 0xac, 0x1e, 0x80, 0x3e, 0x83, 0x2e, 0x72, 0xac, 0xe2, 0xef, 0xef, 0xa0, 0xfd, 0x88, 0xe5, 0x89, 0xa0, 0x59, 0x3d, 0x00, 0x7d, 0x09,
0xfd, 0x9e, 0xb2, 0x34, 0x26, 0x99, 0x2a, 0xdc, 0x7b, 0x70, 0xea, 0xd7, 0x35, 0xe0, 0x8f, 0x0c, 0x1d, 0xfa, 0x23, 0x8d, 0xd3, 0x88, 0x64, 0x6a, 0x70, 0xf7, 0xfe, 0xfe, 0xa0, 0xce, 0xc0, 0xe0,
0x0a, 0x57, 0x78, 0xef, 0x31, 0x74, 0xbf, 0x2e, 0x48, 0x92, 0x47, 0x31, 0x45, 0xc7, 0xd0, 0xfd, 0xd4, 0xa0, 0x70, 0x89, 0xf7, 0x1e, 0x42, 0xe7, 0xdb, 0x9c, 0x24, 0x22, 0x8c, 0x28, 0xda, 0x85,
0xce, 0x7c, 0x9b, 0x05, 0xaa, 0x78, 0x57, 0x79, 0x25, 0xed, 0x47, 0x0b, 0x3a, 0xd3, 0x82, 0x31, 0xce, 0x0f, 0xe6, 0xb7, 0x79, 0x40, 0x59, 0xaf, 0x2a, 0x2f, 0xa5, 0xfd, 0x6c, 0x41, 0x7b, 0x9c,
0x92, 0x6d, 0xd0, 0x7b, 0x70, 0x47, 0x10, 0x96, 0xc6, 0x34, 0x58, 0x48, 0xb5, 0xaa, 0x82, 0x8d, 0xc7, 0x31, 0xc9, 0x96, 0xe8, 0x7d, 0xb8, 0xc5, 0x49, 0x9c, 0x46, 0xd4, 0x9f, 0x49, 0xb5, 0x6a,
0x7b, 0x3a, 0xa7, 0x1a, 0x40, 0x27, 0x00, 0x06, 0x22, 0x0a, 0x66, 0x2a, 0x39, 0x3a, 0x33, 0x2d, 0x82, 0x8d, 0xbb, 0xba, 0xa7, 0x0c, 0xa0, 0x3d, 0x00, 0x03, 0xe1, 0x79, 0x6c, 0x26, 0x39, 0xba,
0x98, 0xec, 0xa3, 0x5a, 0xbf, 0x39, 0x68, 0xee, 0xef, 0xa3, 0x54, 0xbc, 0xd5, 0xe7, 0x9d, 0x41, 0x33, 0xce, 0x63, 0xe9, 0xa3, 0x7c, 0x7e, 0xa3, 0xdf, 0x58, 0xef, 0xa3, 0x50, 0x5c, 0xe9, 0xf3,
0x67, 0x9e, 0xe4, 0x9b, 0x94, 0x2e, 0xf7, 0x4c, 0xf1, 0xcf, 0x06, 0x38, 0xcf, 0x22, 0x91, 0xf3, 0x0e, 0xa0, 0x3d, 0x4d, 0xc4, 0x32, 0xa5, 0x97, 0x6b, 0xb6, 0xf8, 0x57, 0x03, 0x9c, 0xa7, 0x21,
0x55, 0x46, 0xd8, 0x1b, 0x10, 0xfb, 0x10, 0xda, 0x61, 0xb1, 0xf8, 0x96, 0xe6, 0x46, 0xea, 0xbb, 0x17, 0x6c, 0x9e, 0x91, 0xf8, 0x75, 0xc4, 0x7e, 0x04, 0xe8, 0x26, 0xc4, 0xbf, 0x8a, 0x18, 0x11,
0xf5, 0x52, 0x2f, 0x15, 0x06, 0x1b, 0x2c, 0xba, 0x07, 0x8e, 0x08, 0x03, 0xb1, 0x58, 0x53, 0x46, 0xae, 0xa3, 0x66, 0xf6, 0x6e, 0x00, 0x9f, 0xc8, 0xfe, 0xff, 0x59, 0x3b, 0x82, 0x56, 0x90, 0xcf,
0x5c, 0x7b, 0x60, 0x9d, 0x1f, 0xe2, 0xae, 0x08, 0xa7, 0x2a, 0x46, 0xf7, 0xe1, 0x50, 0x84, 0xc1, 0xbe, 0xa7, 0xc2, 0x18, 0x7b, 0xaf, 0xde, 0xd8, 0x89, 0xc2, 0x60, 0x83, 0x45, 0x77, 0xc1, 0xe1,
0x0f, 0x34, 0xe3, 0x41, 0xbe, 0xce, 0xa8, 0x58, 0xf3, 0x78, 0xe9, 0xb6, 0xd4, 0xc2, 0x77, 0x45, 0x81, 0xcf, 0x67, 0x0b, 0x1a, 0x13, 0xd7, 0xee, 0x5b, 0x87, 0xdb, 0xb8, 0xc3, 0x83, 0xb1, 0xaa,
0xf8, 0x92, 0x66, 0x7c, 0x56, 0xa6, 0x91, 0x07, 0x07, 0x25, 0x56, 0x77, 0xd0, 0x36, 0x1d, 0x28, 0xd1, 0x3d, 0xd8, 0xe6, 0x81, 0xff, 0x13, 0xcd, 0x98, 0x2f, 0x16, 0x19, 0xe5, 0x0b, 0x16, 0x5d,
0x9c, 0xee, 0xe0, 0x29, 0xf4, 0x44, 0x18, 0x24, 0x74, 0x45, 0xf2, 0xe8, 0x15, 0x75, 0x3b, 0xea, 0xba, 0x4d, 0xf5, 0xe0, 0x2d, 0x1e, 0xbc, 0xa0, 0x19, 0x9b, 0x14, 0x6d, 0xe4, 0xc1, 0x66, 0x81,
0x68, 0xbc, 0x5f, 0xaf, 0x73, 0x9a, 0x92, 0x4c, 0x50, 0xad, 0x56, 0x60, 0x10, 0xe1, 0x95, 0xa1, 0xd5, 0x7e, 0x5b, 0xc6, 0xaf, 0xc2, 0x69, 0xbf, 0x1f, 0xc3, 0xed, 0x15, 0x8c, 0x31, 0x0c, 0xc6,
0x99, 0x2a, 0x29, 0x17, 0x91, 0xaa, 0xd2, 0x7d, 0xad, 0x2a, 0xd7, 0x86, 0xe6, 0xfd, 0x64, 0x41, 0x70, 0x85, 0xd4, 0x86, 0x1f, 0x43, 0x97, 0x07, 0x7e, 0x42, 0xe7, 0x44, 0x84, 0x2f, 0xa9, 0xdb,
0x5b, 0xe7, 0xd1, 0x07, 0xd0, 0x5f, 0x14, 0xac, 0x88, 0x55, 0xf9, 0x9d, 0xf9, 0xdf, 0xdd, 0xe6, 0x56, 0xe7, 0xee, 0x83, 0x7a, 0x5b, 0xe3, 0x94, 0x64, 0x9c, 0x6a, 0x73, 0x1c, 0x03, 0x0f, 0xce,
0x75, 0x07, 0x67, 0xd0, 0x2b, 0xd2, 0x94, 0x66, 0x41, 0xc8, 0x8b, 0x64, 0x69, 0x36, 0x01, 0x54, 0x0d, 0xcd, 0x4c, 0x49, 0x19, 0x0f, 0xd5, 0x94, 0xce, 0x1b, 0x4d, 0xb9, 0x30, 0x34, 0xef, 0x77,
0xea, 0x52, 0x66, 0x76, 0x8e, 0x7e, 0xf3, 0x35, 0x8f, 0xfe, 0x2f, 0x16, 0x1c, 0xec, 0x08, 0x46, 0x0b, 0x5a, 0xba, 0x8f, 0x3e, 0x84, 0xde, 0x2c, 0x8f, 0xf3, 0x48, 0x8d, 0x5f, 0x79, 0xb9, 0x5b,
0x8f, 0xc1, 0x16, 0x29, 0x49, 0x5c, 0x4b, 0xed, 0xe8, 0xf9, 0x7f, 0xe8, 0x51, 0x46, 0x09, 0x56, 0x55, 0x5f, 0x1b, 0x3e, 0x82, 0x3b, 0xaf, 0x42, 0x8d, 0x67, 0x5b, 0x79, 0xde, 0x79, 0x85, 0xa0,
0x2c, 0x79, 0xee, 0x96, 0x34, 0xce, 0x89, 0xdb, 0x18, 0x34, 0xcf, 0x11, 0xd6, 0xc1, 0xf1, 0xc7, 0x7d, 0x1f, 0x40, 0x37, 0x4f, 0x53, 0x9a, 0xf9, 0x01, 0xcb, 0x93, 0x4b, 0xf3, 0xa6, 0x41, 0xb5,
0x60, 0x4b, 0x0c, 0x7a, 0x07, 0xda, 0xfc, 0xe6, 0x46, 0x50, 0xdd, 0xeb, 0x21, 0x36, 0x91, 0xcc, 0x4e, 0x64, 0x67, 0xe5, 0x36, 0x36, 0xde, 0xf0, 0x36, 0xfe, 0x66, 0xc1, 0xe6, 0x8a, 0x4d, 0xf4,
0xc7, 0x34, 0x59, 0xe5, 0x6b, 0xd5, 0xdd, 0x01, 0x36, 0x91, 0xf7, 0xb3, 0x05, 0xdd, 0x52, 0x34, 0x10, 0x6c, 0x9e, 0x92, 0xc4, 0xb5, 0xd4, 0xb1, 0x39, 0x7c, 0x8d, 0xcd, 0xc8, 0x2a, 0xc1, 0x8a,
0x7a, 0x04, 0xad, 0x58, 0x1a, 0x8b, 0x51, 0x76, 0x56, 0xaf, 0xac, 0xf2, 0x1e, 0xac, 0xd1, 0xf5, 0x25, 0xaf, 0xc2, 0x25, 0x8d, 0x04, 0x71, 0x37, 0xfa, 0x8d, 0x43, 0x84, 0x75, 0x21, 0xbb, 0x7a,
0x97, 0x16, 0x7d, 0x0a, 0x4e, 0x65, 0x5c, 0x66, 0x68, 0xc7, 0xbe, 0xb6, 0x36, 0xbf, 0xb4, 0x36, 0x31, 0xf2, 0x2c, 0x5a, 0x58, 0x17, 0xbb, 0x9f, 0x81, 0x2d, 0x99, 0xe8, 0x0e, 0xb4, 0xd8, 0xd5,
0x7f, 0x56, 0x22, 0xf0, 0x16, 0xec, 0xfd, 0xd5, 0x80, 0xf6, 0x44, 0x19, 0xe5, 0xff, 0x55, 0xf4, 0x15, 0xa7, 0x7a, 0x6f, 0xdb, 0xd8, 0x54, 0xb2, 0x1f, 0xd1, 0x64, 0x2e, 0x16, 0xca, 0xf3, 0x26,
0x21, 0xb4, 0x56, 0xd2, 0xea, 0x8c, 0x4f, 0xdd, 0xab, 0xa7, 0x29, 0x37, 0xc4, 0x1a, 0x89, 0x3e, 0x36, 0x95, 0xf7, 0x8b, 0x05, 0x9d, 0xc2, 0x0a, 0x7a, 0x00, 0xcd, 0x48, 0x26, 0xa0, 0xd1, 0x7b,
0x81, 0xce, 0x42, 0xdb, 0x9f, 0x11, 0x7b, 0x52, 0x4f, 0x32, 0x1e, 0x89, 0x4b, 0xb4, 0x24, 0x0a, 0x50, 0xaf, 0xb7, 0x0c, 0x49, 0xac, 0xd1, 0xf5, 0xe9, 0x82, 0xbe, 0x00, 0xa7, 0x4c, 0x58, 0xb3,
0xed, 0x4d, 0xea, 0xa6, 0xed, 0x25, 0x1a, 0x03, 0xc3, 0x25, 0x5a, 0x12, 0x0b, 0xed, 0x25, 0xea, 0xca, 0xdd, 0x81, 0xce, 0xe0, 0x41, 0x91, 0xc1, 0x83, 0x49, 0x81, 0xc0, 0x15, 0xd8, 0xfb, 0x67,
0xf6, 0xed, 0x25, 0x1a, 0xc3, 0xc1, 0x25, 0x1a, 0x7d, 0x0e, 0xce, 0xba, 0xb4, 0x18, 0x73, 0xdd, 0x03, 0x5a, 0x23, 0x95, 0xe8, 0x6f, 0xab, 0xe8, 0x13, 0x68, 0xce, 0x65, 0x26, 0x9b, 0x40, 0xbd,
0xf6, 0x0c, 0xa6, 0x72, 0x22, 0xbc, 0x65, 0x48, 0x53, 0xaa, 0x66, 0x1d, 0x30, 0xa1, 0xae, 0x74, 0x5b, 0x4f, 0x53, 0xb1, 0x8d, 0x35, 0x12, 0x7d, 0x0e, 0xed, 0x99, 0xce, 0x69, 0x23, 0x76, 0xaf,
0x13, 0xf7, 0xaa, 0xdc, 0x44, 0x78, 0xbf, 0x5a, 0x70, 0x47, 0xef, 0xc0, 0x17, 0x84, 0x45, 0xf1, 0x9e, 0x64, 0xc2, 0x1c, 0x17, 0x68, 0x49, 0xe4, 0x3a, 0x44, 0xd5, 0xc9, 0x5b, 0x4b, 0x34, 0x49,
0xa6, 0xf6, 0x95, 0x41, 0x60, 0xaf, 0x69, 0x9c, 0x9a, 0x47, 0x46, 0x7d, 0xa3, 0x87, 0x60, 0x4b, 0x8b, 0x0b, 0xb4, 0x24, 0xe6, 0x3a, 0xf4, 0xd4, 0xc5, 0x5f, 0x4b, 0x34, 0xc9, 0x88, 0x0b, 0x34,
0x8d, 0x6a, 0x84, 0x6f, 0x3f, 0x18, 0xd4, 0xab, 0xd2, 0x95, 0x67, 0x9b, 0x94, 0x62, 0x85, 0x96, 0xfa, 0x0a, 0x9c, 0x45, 0x91, 0x85, 0xe6, 0xea, 0xae, 0x59, 0x4c, 0x19, 0x99, 0xb8, 0x62, 0xc8,
0x26, 0xa7, 0x1f, 0x46, 0xd7, 0xfe, 0x37, 0x93, 0xd3, 0x3c, 0x6c, 0xb0, 0xf7, 0x27, 0x00, 0xdb, 0xf4, 0x2c, 0x77, 0xed, 0xc7, 0x5c, 0xa5, 0x49, 0x03, 0x77, 0xcb, 0xde, 0x88, 0x7b, 0xbf, 0x5a,
0x4a, 0xa8, 0x07, 0x9d, 0x27, 0xcf, 0xe7, 0x57, 0xb3, 0x11, 0xee, 0xbf, 0x85, 0x1c, 0x68, 0x8d, 0x70, 0x4b, 0xbf, 0x81, 0x27, 0x24, 0x0e, 0xa3, 0x65, 0xed, 0xe7, 0x10, 0x81, 0xbd, 0xa0, 0x51,
0x2f, 0xe6, 0xe3, 0x51, 0xdf, 0x92, 0xf9, 0xe9, 0x7c, 0x32, 0xb9, 0xc0, 0x2f, 0xfa, 0x0d, 0x19, 0x6a, 0xbe, 0x86, 0xea, 0x37, 0x3a, 0x02, 0x5b, 0x6a, 0x54, 0x2b, 0x7c, 0xf7, 0x7e, 0xbf, 0x5e,
0xcc, 0xaf, 0x66, 0x2f, 0xae, 0x47, 0x4f, 0xfb, 0x4d, 0x74, 0x00, 0xce, 0xb3, 0x2f, 0xa7, 0xb3, 0x95, 0x9e, 0x3c, 0x59, 0xa6, 0x14, 0x2b, 0xb4, 0xcc, 0x57, 0xfd, 0x05, 0x77, 0xed, 0xff, 0xca,
0xe7, 0x63, 0x7c, 0x31, 0xe9, 0xdb, 0x97, 0xde, 0x6f, 0xb7, 0xa7, 0xd6, 0xef, 0xb7, 0xa7, 0xd6, 0x57, 0xcd, 0xc3, 0x06, 0x7b, 0x2f, 0x00, 0xa8, 0x26, 0xa1, 0x2e, 0xb4, 0x1f, 0x3d, 0x9b, 0x9e,
0x1f, 0xb7, 0xa7, 0xd6, 0xcb, 0xa3, 0x88, 0x07, 0x5b, 0x05, 0x81, 0x56, 0x10, 0xb6, 0xd5, 0xc1, 0x4f, 0x4e, 0x71, 0xef, 0x1d, 0xe4, 0x40, 0xf3, 0xec, 0x78, 0x7a, 0x76, 0xda, 0xb3, 0x64, 0x7f,
0xfd, 0xe8, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x94, 0x4a, 0x80, 0xdd, 0x07, 0x00, 0x00, 0x3c, 0x1d, 0x8d, 0x8e, 0xf1, 0xf3, 0xde, 0x86, 0x2c, 0xa6, 0xe7, 0x93, 0xe7, 0x17, 0xa7, 0x8f,
0x7b, 0x0d, 0xb4, 0x09, 0xce, 0xd3, 0xaf, 0xc7, 0x93, 0x67, 0x67, 0xf8, 0x78, 0xd4, 0xb3, 0xd1,
0x6d, 0xd8, 0x52, 0x1c, 0xbf, 0x6a, 0x36, 0x4f, 0xbc, 0x3f, 0xae, 0xf7, 0xad, 0x3f, 0xaf, 0xf7,
0xad, 0xbf, 0xaf, 0xf7, 0xad, 0x17, 0x3b, 0x21, 0xf3, 0x2b, 0x59, 0xbe, 0x96, 0x15, 0xb4, 0xd4,
0x69, 0xfe, 0xf4, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x06, 0x77, 0x31, 0x97, 0x9b, 0x08, 0x00,
0x00,
} }
func (m *LabelPair) Marshal() (dAtA []byte, err error) { func (m *LabelPair) Marshal() (dAtA []byte, err error) {
@ -1237,6 +1291,18 @@ func (m *Histogram) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized) i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized)
} }
if m.SbZeroCountFloat != 0 {
i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.SbZeroCountFloat))))
i--
dAtA[i] = 0x51
}
if m.SampleCountFloat != 0 {
i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.SampleCountFloat))))
i--
dAtA[i] = 0x49
}
if m.SbPositive != nil { if m.SbPositive != nil {
{ {
size, err := m.SbPositive.MarshalToSizedBuffer(dAtA[:i]) size, err := m.SbPositive.MarshalToSizedBuffer(dAtA[:i])
@ -1329,6 +1395,12 @@ func (m *Bucket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized) i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized)
} }
if m.CumulativeCountFloat != 0 {
i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CumulativeCountFloat))))
i--
dAtA[i] = 0x21
}
if m.Exemplar != nil { if m.Exemplar != nil {
{ {
size, err := m.Exemplar.MarshalToSizedBuffer(dAtA[:i]) size, err := m.Exemplar.MarshalToSizedBuffer(dAtA[:i])
@ -1379,22 +1451,32 @@ func (m *SparseBuckets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized) i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized)
} }
if len(m.Delta) > 0 { if len(m.Count) > 0 {
var j5 int for iNdEx := len(m.Count) - 1; iNdEx >= 0; iNdEx-- {
dAtA7 := make([]byte, len(m.Delta)*10) f5 := math.Float64bits(float64(m.Count[iNdEx]))
for _, num := range m.Delta { i -= 8
x6 := (uint64(num) << 1) ^ uint64((num >> 63)) encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f5))
for x6 >= 1<<7 {
dAtA7[j5] = uint8(uint64(x6)&0x7f | 0x80)
j5++
x6 >>= 7
}
dAtA7[j5] = uint8(x6)
j5++
} }
i -= j5 i = encodeVarintMetrics(dAtA, i, uint64(len(m.Count)*8))
copy(dAtA[i:], dAtA7[:j5]) i--
i = encodeVarintMetrics(dAtA, i, uint64(j5)) dAtA[i] = 0x1a
}
if len(m.Delta) > 0 {
var j6 int
dAtA8 := make([]byte, len(m.Delta)*10)
for _, num := range m.Delta {
x7 := (uint64(num) << 1) ^ uint64((num >> 63))
for x7 >= 1<<7 {
dAtA8[j6] = uint8(uint64(x7)&0x7f | 0x80)
j6++
x7 >>= 7
}
dAtA8[j6] = uint8(x7)
j6++
}
i -= j6
copy(dAtA[i:], dAtA8[:j6])
i = encodeVarintMetrics(dAtA, i, uint64(j6))
i-- i--
dAtA[i] = 0x12 dAtA[i] = 0x12
} }
@ -1834,6 +1916,12 @@ func (m *Histogram) Size() (n int) {
l = m.SbPositive.Size() l = m.SbPositive.Size()
n += 1 + l + sovMetrics(uint64(l)) n += 1 + l + sovMetrics(uint64(l))
} }
if m.SampleCountFloat != 0 {
n += 9
}
if m.SbZeroCountFloat != 0 {
n += 9
}
if m.XXX_unrecognized != nil { if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized) n += len(m.XXX_unrecognized)
} }
@ -1856,6 +1944,9 @@ func (m *Bucket) Size() (n int) {
l = m.Exemplar.Size() l = m.Exemplar.Size()
n += 1 + l + sovMetrics(uint64(l)) n += 1 + l + sovMetrics(uint64(l))
} }
if m.CumulativeCountFloat != 0 {
n += 9
}
if m.XXX_unrecognized != nil { if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized) n += len(m.XXX_unrecognized)
} }
@ -1881,6 +1972,9 @@ func (m *SparseBuckets) Size() (n int) {
} }
n += 1 + sovMetrics(uint64(l)) + l n += 1 + sovMetrics(uint64(l)) + l
} }
if len(m.Count) > 0 {
n += 1 + sovMetrics(uint64(len(m.Count)*8)) + len(m.Count)*8
}
if m.XXX_unrecognized != nil { if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized) n += len(m.XXX_unrecognized)
} }
@ -2747,6 +2841,28 @@ func (m *Histogram) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 9:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field SampleCountFloat", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
m.SampleCountFloat = float64(math.Float64frombits(v))
case 10:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field SbZeroCountFloat", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
m.SbZeroCountFloat = float64(math.Float64frombits(v))
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:]) skippy, err := skipMetrics(dAtA[iNdEx:])
@ -2864,6 +2980,17 @@ func (m *Bucket) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 4:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field CumulativeCountFloat", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
m.CumulativeCountFloat = float64(math.Float64frombits(v))
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:]) skippy, err := skipMetrics(dAtA[iNdEx:])
@ -3027,6 +3154,60 @@ func (m *SparseBuckets) Unmarshal(dAtA []byte) error {
} else { } else {
return fmt.Errorf("proto: wrong wireType = %d for field Delta", wireType) return fmt.Errorf("proto: wrong wireType = %d for field Delta", wireType)
} }
case 3:
if wireType == 1 {
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
v2 := float64(math.Float64frombits(v))
m.Count = append(m.Count, v2)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowMetrics
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthMetrics
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthMetrics
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
elementCount = packedLen / 8
if elementCount != 0 && len(m.Count) == 0 {
m.Count = make([]float64, 0, elementCount)
}
for iNdEx < postIndex {
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
v2 := float64(math.Float64frombits(v))
m.Count = append(m.Count, v2)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
}
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipMetrics(dAtA[iNdEx:]) skippy, err := skipMetrics(dAtA[iNdEx:])

69
prompb/io/prometheus/client/metrics.proto
View file

@ -29,11 +29,18 @@ message LabelPair {
} }
enum MetricType { enum MetricType {
COUNTER = 0; // COUNTER must use the Metric field "counter".
GAUGE = 1; COUNTER = 0;
SUMMARY = 2; // GAUGE must use the Metric field "gauge".
UNTYPED = 3; GAUGE = 1;
HISTOGRAM = 4; // SUMMARY must use the Metric field "summary".
SUMMARY = 2;
// UNTYPED must use the Metric field "untyped".
UNTYPED = 3;
// HISTOGRAM must use the Metric field "histogram".
HISTOGRAM = 4;
// GAUGE_HISTOGRAM must use the Metric field "histogram".
GAUGE_HISTOGRAM = 5;
} }
message Gauge { message Gauge {
@ -62,6 +69,7 @@ message Untyped {
message Histogram { message Histogram {
uint64 sample_count = 1; uint64 sample_count = 1;
double sample_count_float = 9; // Overrides sample_count if > 0.
double sample_sum = 2; double sample_sum = 2;
repeated Bucket bucket = 3; // Ordered in increasing order of upper_bound, +Inf bucket is optional. repeated Bucket bucket = 3; // Ordered in increasing order of upper_bound, +Inf bucket is optional.
// Sparse bucket (sb) stuff: // Sparse bucket (sb) stuff:
@ -70,26 +78,37 @@ message Histogram {
// then each power of two is divided into 2^n logarithmic buckets. // then each power of two is divided into 2^n logarithmic buckets.
// Or in other words, each bucket boundary is the previous boundary times 2^(2^-n). // Or in other words, each bucket boundary is the previous boundary times 2^(2^-n).
// In the future, more bucket schemas may be added using numbers < -4 or > 8. // In the future, more bucket schemas may be added using numbers < -4 or > 8.
sint32 sb_schema = 4; sint32 sb_schema = 4;
double sb_zero_threshold = 5; // Breadth of the zero bucket. double sb_zero_threshold = 5; // Breadth of the zero bucket.
uint64 sb_zero_count = 6; // Count in zero bucket. uint64 sb_zero_count = 6; // Count in zero bucket.
SparseBuckets sb_negative = 7; // Negative sparse buckets. double sb_zero_count_float = 10; // Overrides sb_zero_count if > 0.
SparseBuckets sb_positive = 8; // Positive sparse buckets. SparseBuckets sb_negative = 7; // Negative sparse buckets.
SparseBuckets sb_positive = 8; // Positive sparse buckets.
} }
message Bucket { message Bucket {
uint64 cumulative_count = 1; // Cumulative in increasing order. uint64 cumulative_count = 1; // Cumulative in increasing order.
double upper_bound = 2; // Inclusive. double cumulative_count_float = 4; // Overrides cumulative_count if > 0.
Exemplar exemplar = 3; double upper_bound = 2; // Inclusive.
Exemplar exemplar = 3;
} }
message SparseBuckets { message SparseBuckets {
// A Span is a given number of consecutive buckets at a given
// offset. Logically, it would be more straightforward to include
// the bucket counts in the Span. However, the protobuf
// representation is more compact in the way the data is structured
// here (with all the buckets in a single array separate from the
// Spans).
message Span { message Span {
sint32 offset = 1; // Gap to previous span, or starting point for 1st span (which can be negative). sint32 offset = 1; // Gap to previous span, or starting point for 1st span (which can be negative).
uint32 length = 2; // Length of consecutive buckets. uint32 length = 2; // Length of consecutive buckets.
} }
repeated Span span = 1; repeated Span span = 1;
// Only one of "delta" or "count" may be used, the former for regular
// histograms with integer counts, the latter for float histograms.
repeated sint64 delta = 2; // Count delta of each bucket compared to previous one (or to zero for 1st bucket). repeated sint64 delta = 2; // Count delta of each bucket compared to previous one (or to zero for 1st bucket).
repeated double count = 3; // Absolute count of each bucket.
} }
message Exemplar { message Exemplar {
@ -99,18 +118,18 @@ message Exemplar {
} }
message Metric { message Metric {
repeated LabelPair label = 1; repeated LabelPair label = 1;
Gauge gauge = 2; Gauge gauge = 2;
Counter counter = 3; Counter counter = 3;
Summary summary = 4; Summary summary = 4;
Untyped untyped = 5; Untyped untyped = 5;
Histogram histogram = 7; Histogram histogram = 7;
int64 timestamp_ms = 6; int64 timestamp_ms = 6;
} }
message MetricFamily { message MetricFamily {
string name = 1; string name = 1;
string help = 2; string help = 2;
MetricType type = 3; MetricType type = 3;
repeated Metric metric = 4; repeated Metric metric = 4;
} }