2015-02-02 17:14:36 +03:00
|
|
|
// Copyright 2014 The Prometheus Authors
|
2014-05-07 22:08:33 +04:00
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package prometheus
|
|
|
|
|
|
|
|
import (
|
2023-09-21 12:46:54 +03:00
|
|
|
"errors"
|
2014-05-07 22:08:33 +04:00
|
|
|
"fmt"
|
|
|
|
"sort"
|
2020-01-14 21:22:19 +03:00
|
|
|
"time"
|
|
|
|
"unicode/utf8"
|
2014-05-07 22:08:33 +04:00
|
|
|
|
2022-06-17 10:04:06 +03:00
|
|
|
"github.com/prometheus/client_golang/prometheus/internal"
|
|
|
|
|
2018-09-10 02:13:17 +03:00
|
|
|
dto "github.com/prometheus/client_model/go"
|
2022-12-22 18:14:00 +03:00
|
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
2014-05-07 22:08:33 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
// ValueType is an enumeration of metric types that represent a simple value.
|
|
|
|
type ValueType int
|
|
|
|
|
2020-02-13 22:52:44 +03:00
|
|
|
// Possible values for the ValueType enum. Use UntypedValue to mark a metric
|
|
|
|
// with an unknown type.
|
2014-05-07 22:08:33 +04:00
|
|
|
const (
|
|
|
|
_ ValueType = iota
|
|
|
|
CounterValue
|
|
|
|
GaugeValue
|
|
|
|
UntypedValue
|
|
|
|
)
|
|
|
|
|
2022-02-23 14:22:52 +03:00
|
|
|
var (
|
|
|
|
CounterMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_COUNTER; return &d }()
|
|
|
|
GaugeMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_GAUGE; return &d }()
|
|
|
|
UntypedMetricTypePtr = func() *dto.MetricType { d := dto.MetricType_UNTYPED; return &d }()
|
|
|
|
)
|
|
|
|
|
|
|
|
func (v ValueType) ToDTO() *dto.MetricType {
|
|
|
|
switch v {
|
|
|
|
case CounterValue:
|
|
|
|
return CounterMetricTypePtr
|
|
|
|
case GaugeValue:
|
|
|
|
return GaugeMetricTypePtr
|
|
|
|
default:
|
|
|
|
return UntypedMetricTypePtr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-23 16:15:35 +04:00
|
|
|
// valueFunc is a generic metric for simple values retrieved on collect time
|
|
|
|
// from a function. It implements Metric and Collector. Its effective type is
|
|
|
|
// determined by ValueType. This is a low-level building block used by the
|
|
|
|
// library to back the implementations of CounterFunc, GaugeFunc, and
|
|
|
|
// UntypedFunc.
|
|
|
|
type valueFunc struct {
|
2016-08-03 02:09:27 +03:00
|
|
|
selfCollector
|
2014-06-23 16:15:35 +04:00
|
|
|
|
|
|
|
desc *Desc
|
|
|
|
valType ValueType
|
|
|
|
function func() float64
|
|
|
|
labelPairs []*dto.LabelPair
|
|
|
|
}
|
|
|
|
|
|
|
|
// newValueFunc returns a newly allocated valueFunc with the given Desc and
|
|
|
|
// ValueType. The value reported is determined by calling the given function
|
|
|
|
// from within the Write method. Take into account that metric collection may
|
|
|
|
// happen concurrently. If that results in concurrent calls to Write, like in
|
|
|
|
// the case where a valueFunc is directly registered with Prometheus, the
|
|
|
|
// provided function must be concurrency-safe.
|
|
|
|
func newValueFunc(desc *Desc, valueType ValueType, function func() float64) *valueFunc {
|
|
|
|
result := &valueFunc{
|
|
|
|
desc: desc,
|
|
|
|
valType: valueType,
|
|
|
|
function: function,
|
2020-09-10 19:05:44 +03:00
|
|
|
labelPairs: MakeLabelPairs(desc, nil),
|
2014-06-23 16:15:35 +04:00
|
|
|
}
|
2016-08-03 02:09:27 +03:00
|
|
|
result.init(result)
|
2014-06-23 16:15:35 +04:00
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
|
|
|
func (v *valueFunc) Desc() *Desc {
|
|
|
|
return v.desc
|
|
|
|
}
|
|
|
|
|
Allow error reporting during metrics collection and simplify Register().
Both are interface changes I want to get in before public
announcement. They only break rare usage cases, and are always easy to
fix, but still we want to avoid breaking changes after a wider
announcement of the project.
The change of Register() simply removes the return of the Collector,
which nobody was using in practice. It was just bloating the call
syntax. Note that this is different from RegisterOrGet(), which is
used at various occasions where you want to register something that
might or might not be registered already, but if it is, you want the
previously registered Collector back (because that's the relevant
one).
WRT error reporting: I first tried the obvious way of letting the
Collector methods Describe() and Collect() return error. However, I
had to conclude that that bloated _many_ calls and their handling in
very obnoxious ways. On the other hand, the case where you actually
want to report errors during registration or collection is very
rare. Hence, this approach has the wrong trade-off. The approach taken
here might at first appear clunky but is in practice quite handy,
mostly because there is almost no change for the "normal" case of "no
special error handling", but also because it plays well with the way
descriptors and metrics are handled (via channels).
Explaining the approach in more detail:
- During registration / describe: Error handling was actually already
in place (for invalid descriptors, which carry an error anyway). I
only added a convenience function to create an invalid descriptor
with a given error on purpose.
- Metrics are now treated in a similar way. The Write method returns
an error now (the only change in interface). An "invalid metric" is
provided that can be sent via the channel to signal that that metric
could not be collected. It alse transports an error.
NON-GOALS OF THIS COMMIT:
This is NOT yet the major improvement of the whole registry part,
where we want a public Registry interface and plenty of modular
configurations (for error handling, various auto-metrics, http
instrumentation, testing, ...). However, we can do that whole thing
without breaking existing interfaces. For now (which is a significant
issue) any error during collection will either cause a 500 HTTP
response or a panic (depending on registry config). Later, we
definitely want to have a possibility to skip (and only report
somehow) non-collectible metrics instead of aborting the whole scrape.
2015-01-12 21:16:09 +03:00
|
|
|
func (v *valueFunc) Write(out *dto.Metric) error {
|
2023-09-21 12:46:54 +03:00
|
|
|
return populateMetric(v.valType, v.function(), v.labelPairs, nil, out, nil)
|
2014-06-23 16:15:35 +04:00
|
|
|
}
|
|
|
|
|
2014-05-07 22:08:33 +04:00
|
|
|
// NewConstMetric returns a metric with one fixed value that cannot be
|
|
|
|
// changed. Users of this package will not have much use for it in regular
|
|
|
|
// operations. However, when implementing custom Collectors, it is useful as a
|
|
|
|
// throw-away metric that is generated on the fly to send it to Prometheus in
|
|
|
|
// the Collect method. NewConstMetric returns an error if the length of
|
2018-09-17 12:50:42 +03:00
|
|
|
// labelValues is not consistent with the variable labels in Desc or if Desc is
|
|
|
|
// invalid.
|
2014-05-07 22:08:33 +04:00
|
|
|
func NewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) (Metric, error) {
|
2018-09-17 12:50:42 +03:00
|
|
|
if desc.err != nil {
|
|
|
|
return nil, desc.err
|
|
|
|
}
|
2023-06-27 14:21:36 +03:00
|
|
|
if err := validateLabelValues(labelValues, len(desc.variableLabels.names)); err != nil {
|
2017-08-19 23:57:48 +03:00
|
|
|
return nil, err
|
2014-05-07 22:08:33 +04:00
|
|
|
}
|
2022-02-23 14:22:52 +03:00
|
|
|
|
|
|
|
metric := &dto.Metric{}
|
2023-09-21 12:46:54 +03:00
|
|
|
if err := populateMetric(valueType, value, MakeLabelPairs(desc, labelValues), nil, metric, nil); err != nil {
|
2022-02-23 14:22:52 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2014-05-07 22:08:33 +04:00
|
|
|
return &constMetric{
|
2022-02-23 14:22:52 +03:00
|
|
|
desc: desc,
|
|
|
|
metric: metric,
|
2014-05-07 22:08:33 +04:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// MustNewConstMetric is a version of NewConstMetric that panics where
|
|
|
|
// NewConstMetric would have returned an error.
|
|
|
|
func MustNewConstMetric(desc *Desc, valueType ValueType, value float64, labelValues ...string) Metric {
|
|
|
|
m, err := NewConstMetric(desc, valueType, value, labelValues...)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2023-09-21 12:46:54 +03:00
|
|
|
// NewConstMetricWithCreatedTimestamp does the same thing as NewConstMetric, but generates Counters
|
|
|
|
// with created timestamp set and returns an error for other metric types.
|
|
|
|
func NewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) (Metric, error) {
|
|
|
|
if desc.err != nil {
|
|
|
|
return nil, desc.err
|
|
|
|
}
|
|
|
|
if err := validateLabelValues(labelValues, len(desc.variableLabels.names)); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
switch valueType {
|
|
|
|
case CounterValue:
|
|
|
|
break
|
|
|
|
default:
|
|
|
|
return nil, errors.New("created timestamps are only supported for counters")
|
|
|
|
}
|
|
|
|
|
|
|
|
metric := &dto.Metric{}
|
|
|
|
if err := populateMetric(valueType, value, MakeLabelPairs(desc, labelValues), nil, metric, timestamppb.New(ct)); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return &constMetric{
|
|
|
|
desc: desc,
|
|
|
|
metric: metric,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// MustNewConstMetricWithCreatedTimestamp is a version of NewConstMetricWithCreatedTimestamp that panics where
|
|
|
|
// NewConstMetricWithCreatedTimestamp would have returned an error.
|
|
|
|
func MustNewConstMetricWithCreatedTimestamp(desc *Desc, valueType ValueType, value float64, ct time.Time, labelValues ...string) Metric {
|
|
|
|
m, err := NewConstMetricWithCreatedTimestamp(desc, valueType, value, ct, labelValues...)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2014-05-07 22:08:33 +04:00
|
|
|
type constMetric struct {
|
2022-02-23 14:22:52 +03:00
|
|
|
desc *Desc
|
|
|
|
metric *dto.Metric
|
2014-05-07 22:08:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *constMetric) Desc() *Desc {
|
|
|
|
return m.desc
|
|
|
|
}
|
|
|
|
|
Allow error reporting during metrics collection and simplify Register().
Both are interface changes I want to get in before public
announcement. They only break rare usage cases, and are always easy to
fix, but still we want to avoid breaking changes after a wider
announcement of the project.
The change of Register() simply removes the return of the Collector,
which nobody was using in practice. It was just bloating the call
syntax. Note that this is different from RegisterOrGet(), which is
used at various occasions where you want to register something that
might or might not be registered already, but if it is, you want the
previously registered Collector back (because that's the relevant
one).
WRT error reporting: I first tried the obvious way of letting the
Collector methods Describe() and Collect() return error. However, I
had to conclude that that bloated _many_ calls and their handling in
very obnoxious ways. On the other hand, the case where you actually
want to report errors during registration or collection is very
rare. Hence, this approach has the wrong trade-off. The approach taken
here might at first appear clunky but is in practice quite handy,
mostly because there is almost no change for the "normal" case of "no
special error handling", but also because it plays well with the way
descriptors and metrics are handled (via channels).
Explaining the approach in more detail:
- During registration / describe: Error handling was actually already
in place (for invalid descriptors, which carry an error anyway). I
only added a convenience function to create an invalid descriptor
with a given error on purpose.
- Metrics are now treated in a similar way. The Write method returns
an error now (the only change in interface). An "invalid metric" is
provided that can be sent via the channel to signal that that metric
could not be collected. It alse transports an error.
NON-GOALS OF THIS COMMIT:
This is NOT yet the major improvement of the whole registry part,
where we want a public Registry interface and plenty of modular
configurations (for error handling, various auto-metrics, http
instrumentation, testing, ...). However, we can do that whole thing
without breaking existing interfaces. For now (which is a significant
issue) any error during collection will either cause a 500 HTTP
response or a panic (depending on registry config). Later, we
definitely want to have a possibility to skip (and only report
somehow) non-collectible metrics instead of aborting the whole scrape.
2015-01-12 21:16:09 +03:00
|
|
|
func (m *constMetric) Write(out *dto.Metric) error {
|
2022-02-23 14:22:52 +03:00
|
|
|
out.Label = m.metric.Label
|
|
|
|
out.Counter = m.metric.Counter
|
|
|
|
out.Gauge = m.metric.Gauge
|
|
|
|
out.Untyped = m.metric.Untyped
|
|
|
|
return nil
|
2014-05-07 22:08:33 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func populateMetric(
|
|
|
|
t ValueType,
|
|
|
|
v float64,
|
|
|
|
labelPairs []*dto.LabelPair,
|
2020-01-14 21:22:19 +03:00
|
|
|
e *dto.Exemplar,
|
2014-05-07 22:08:33 +04:00
|
|
|
m *dto.Metric,
|
2023-09-21 12:46:54 +03:00
|
|
|
ct *timestamppb.Timestamp,
|
Allow error reporting during metrics collection and simplify Register().
Both are interface changes I want to get in before public
announcement. They only break rare usage cases, and are always easy to
fix, but still we want to avoid breaking changes after a wider
announcement of the project.
The change of Register() simply removes the return of the Collector,
which nobody was using in practice. It was just bloating the call
syntax. Note that this is different from RegisterOrGet(), which is
used at various occasions where you want to register something that
might or might not be registered already, but if it is, you want the
previously registered Collector back (because that's the relevant
one).
WRT error reporting: I first tried the obvious way of letting the
Collector methods Describe() and Collect() return error. However, I
had to conclude that that bloated _many_ calls and their handling in
very obnoxious ways. On the other hand, the case where you actually
want to report errors during registration or collection is very
rare. Hence, this approach has the wrong trade-off. The approach taken
here might at first appear clunky but is in practice quite handy,
mostly because there is almost no change for the "normal" case of "no
special error handling", but also because it plays well with the way
descriptors and metrics are handled (via channels).
Explaining the approach in more detail:
- During registration / describe: Error handling was actually already
in place (for invalid descriptors, which carry an error anyway). I
only added a convenience function to create an invalid descriptor
with a given error on purpose.
- Metrics are now treated in a similar way. The Write method returns
an error now (the only change in interface). An "invalid metric" is
provided that can be sent via the channel to signal that that metric
could not be collected. It alse transports an error.
NON-GOALS OF THIS COMMIT:
This is NOT yet the major improvement of the whole registry part,
where we want a public Registry interface and plenty of modular
configurations (for error handling, various auto-metrics, http
instrumentation, testing, ...). However, we can do that whole thing
without breaking existing interfaces. For now (which is a significant
issue) any error during collection will either cause a 500 HTTP
response or a panic (depending on registry config). Later, we
definitely want to have a possibility to skip (and only report
somehow) non-collectible metrics instead of aborting the whole scrape.
2015-01-12 21:16:09 +03:00
|
|
|
) error {
|
2014-05-07 22:08:33 +04:00
|
|
|
m.Label = labelPairs
|
|
|
|
switch t {
|
|
|
|
case CounterValue:
|
2023-09-21 12:46:54 +03:00
|
|
|
m.Counter = &dto.Counter{Value: proto.Float64(v), Exemplar: e, CreatedTimestamp: ct}
|
2014-05-07 22:08:33 +04:00
|
|
|
case GaugeValue:
|
|
|
|
m.Gauge = &dto.Gauge{Value: proto.Float64(v)}
|
|
|
|
case UntypedValue:
|
|
|
|
m.Untyped = &dto.Untyped{Value: proto.Float64(v)}
|
|
|
|
default:
|
Allow error reporting during metrics collection and simplify Register().
Both are interface changes I want to get in before public
announcement. They only break rare usage cases, and are always easy to
fix, but still we want to avoid breaking changes after a wider
announcement of the project.
The change of Register() simply removes the return of the Collector,
which nobody was using in practice. It was just bloating the call
syntax. Note that this is different from RegisterOrGet(), which is
used at various occasions where you want to register something that
might or might not be registered already, but if it is, you want the
previously registered Collector back (because that's the relevant
one).
WRT error reporting: I first tried the obvious way of letting the
Collector methods Describe() and Collect() return error. However, I
had to conclude that that bloated _many_ calls and their handling in
very obnoxious ways. On the other hand, the case where you actually
want to report errors during registration or collection is very
rare. Hence, this approach has the wrong trade-off. The approach taken
here might at first appear clunky but is in practice quite handy,
mostly because there is almost no change for the "normal" case of "no
special error handling", but also because it plays well with the way
descriptors and metrics are handled (via channels).
Explaining the approach in more detail:
- During registration / describe: Error handling was actually already
in place (for invalid descriptors, which carry an error anyway). I
only added a convenience function to create an invalid descriptor
with a given error on purpose.
- Metrics are now treated in a similar way. The Write method returns
an error now (the only change in interface). An "invalid metric" is
provided that can be sent via the channel to signal that that metric
could not be collected. It alse transports an error.
NON-GOALS OF THIS COMMIT:
This is NOT yet the major improvement of the whole registry part,
where we want a public Registry interface and plenty of modular
configurations (for error handling, various auto-metrics, http
instrumentation, testing, ...). However, we can do that whole thing
without breaking existing interfaces. For now (which is a significant
issue) any error during collection will either cause a 500 HTTP
response or a panic (depending on registry config). Later, we
definitely want to have a possibility to skip (and only report
somehow) non-collectible metrics instead of aborting the whole scrape.
2015-01-12 21:16:09 +03:00
|
|
|
return fmt.Errorf("encountered unknown type %v", t)
|
2014-05-07 22:08:33 +04:00
|
|
|
}
|
Allow error reporting during metrics collection and simplify Register().
Both are interface changes I want to get in before public
announcement. They only break rare usage cases, and are always easy to
fix, but still we want to avoid breaking changes after a wider
announcement of the project.
The change of Register() simply removes the return of the Collector,
which nobody was using in practice. It was just bloating the call
syntax. Note that this is different from RegisterOrGet(), which is
used at various occasions where you want to register something that
might or might not be registered already, but if it is, you want the
previously registered Collector back (because that's the relevant
one).
WRT error reporting: I first tried the obvious way of letting the
Collector methods Describe() and Collect() return error. However, I
had to conclude that that bloated _many_ calls and their handling in
very obnoxious ways. On the other hand, the case where you actually
want to report errors during registration or collection is very
rare. Hence, this approach has the wrong trade-off. The approach taken
here might at first appear clunky but is in practice quite handy,
mostly because there is almost no change for the "normal" case of "no
special error handling", but also because it plays well with the way
descriptors and metrics are handled (via channels).
Explaining the approach in more detail:
- During registration / describe: Error handling was actually already
in place (for invalid descriptors, which carry an error anyway). I
only added a convenience function to create an invalid descriptor
with a given error on purpose.
- Metrics are now treated in a similar way. The Write method returns
an error now (the only change in interface). An "invalid metric" is
provided that can be sent via the channel to signal that that metric
could not be collected. It alse transports an error.
NON-GOALS OF THIS COMMIT:
This is NOT yet the major improvement of the whole registry part,
where we want a public Registry interface and plenty of modular
configurations (for error handling, various auto-metrics, http
instrumentation, testing, ...). However, we can do that whole thing
without breaking existing interfaces. For now (which is a significant
issue) any error during collection will either cause a 500 HTTP
response or a panic (depending on registry config). Later, we
definitely want to have a possibility to skip (and only report
somehow) non-collectible metrics instead of aborting the whole scrape.
2015-01-12 21:16:09 +03:00
|
|
|
return nil
|
2014-05-07 22:08:33 +04:00
|
|
|
}
|
|
|
|
|
2020-09-10 19:05:44 +03:00
|
|
|
// MakeLabelPairs is a helper function to create protobuf LabelPairs from the
|
|
|
|
// variable and constant labels in the provided Desc. The values for the
|
|
|
|
// variable labels are defined by the labelValues slice, which must be in the
|
|
|
|
// same order as the corresponding variable labels in the Desc.
|
|
|
|
//
|
|
|
|
// This function is only needed for custom Metric implementations. See MetricVec
|
|
|
|
// example.
|
|
|
|
func MakeLabelPairs(desc *Desc, labelValues []string) []*dto.LabelPair {
|
2023-06-27 14:21:36 +03:00
|
|
|
totalLen := len(desc.variableLabels.names) + len(desc.constLabelPairs)
|
2014-05-07 22:08:33 +04:00
|
|
|
if totalLen == 0 {
|
|
|
|
// Super fast path.
|
|
|
|
return nil
|
|
|
|
}
|
2023-06-27 14:21:36 +03:00
|
|
|
if len(desc.variableLabels.names) == 0 {
|
2014-05-07 22:08:33 +04:00
|
|
|
// Moderately fast path.
|
|
|
|
return desc.constLabelPairs
|
|
|
|
}
|
|
|
|
labelPairs := make([]*dto.LabelPair, 0, totalLen)
|
2023-06-27 14:21:36 +03:00
|
|
|
for i, l := range desc.variableLabels.names {
|
2014-05-07 22:08:33 +04:00
|
|
|
labelPairs = append(labelPairs, &dto.LabelPair{
|
2023-06-27 14:21:36 +03:00
|
|
|
Name: proto.String(l),
|
2014-05-07 22:08:33 +04:00
|
|
|
Value: proto.String(labelValues[i]),
|
|
|
|
})
|
|
|
|
}
|
2018-04-13 23:15:28 +03:00
|
|
|
labelPairs = append(labelPairs, desc.constLabelPairs...)
|
2022-02-23 14:22:52 +03:00
|
|
|
sort.Sort(internal.LabelPairSorter(labelPairs))
|
2014-05-07 22:08:33 +04:00
|
|
|
return labelPairs
|
|
|
|
}
|
2020-01-14 21:22:19 +03:00
|
|
|
|
|
|
|
// ExemplarMaxRunes is the max total number of runes allowed in exemplar labels.
|
2022-07-19 17:50:45 +03:00
|
|
|
const ExemplarMaxRunes = 128
|
2020-01-14 21:22:19 +03:00
|
|
|
|
|
|
|
// newExemplar creates a new dto.Exemplar from the provided values. An error is
|
|
|
|
// returned if any of the label names or values are invalid or if the total
|
|
|
|
// number of runes in the label names and values exceeds ExemplarMaxRunes.
|
|
|
|
func newExemplar(value float64, ts time.Time, l Labels) (*dto.Exemplar, error) {
|
|
|
|
e := &dto.Exemplar{}
|
|
|
|
e.Value = proto.Float64(value)
|
2022-01-18 22:32:44 +03:00
|
|
|
tsProto := timestamppb.New(ts)
|
|
|
|
if err := tsProto.CheckValid(); err != nil {
|
2020-01-14 21:22:19 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
e.Timestamp = tsProto
|
|
|
|
labelPairs := make([]*dto.LabelPair, 0, len(l))
|
|
|
|
var runes int
|
|
|
|
for name, value := range l {
|
|
|
|
if !checkLabelName(name) {
|
|
|
|
return nil, fmt.Errorf("exemplar label name %q is invalid", name)
|
|
|
|
}
|
|
|
|
runes += utf8.RuneCountInString(name)
|
|
|
|
if !utf8.ValidString(value) {
|
|
|
|
return nil, fmt.Errorf("exemplar label value %q is not valid UTF-8", value)
|
|
|
|
}
|
|
|
|
runes += utf8.RuneCountInString(value)
|
|
|
|
labelPairs = append(labelPairs, &dto.LabelPair{
|
|
|