Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 bench_test.go // Copyright 2015 The Prometheus Authors // 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 expfmt import ( "bufio" "bytes" "compress/gzip" "errors" "io" "os" "testing" "google.golang.org/protobuf/encoding/protodelim" dto "github.com/prometheus/client_model/go" "github.com/stretchr/testify/require" ) var parser TextParser // Benchmarks to show how much penalty text format parsing actually inflicts. // // Example results on Linux 3.13.0, Intel(R) Core(TM) i7-4700MQ CPU @ 2.40GHz, go1.4. // // BenchmarkParseText 1000 1188535 ns/op 205085 B/op 6135 allocs/op // BenchmarkParseTextGzip 1000 1376567 ns/op 246224 B/op 6151 allocs/op // BenchmarkParseProto 10000 172790 ns/op 52258 B/op 1160 allocs/op // BenchmarkParseProtoGzip 5000 324021 ns/op 94931 B/op 1211 allocs/op // BenchmarkParseProtoMap 10000 187946 ns/op 58714 B/op 1203 allocs/op // // CONCLUSION: The overhead for the map is negligible. Text format needs ~5x more allocations. // Without compression, it needs ~7x longer, but with compression (the more relevant scenario), // the difference becomes less relevant, only ~4x. // // The test data contains 248 samples. // BenchmarkParseText benchmarks the parsing of a text-format scrape into metric // family DTOs. func BenchmarkParseText(b testing.B) { b.StopTimer() data, err := os.ReadFile("testdata/text") require.NoError(b, err) b.StartTimer() for i := 0; i < b.N; i++ { _, err := parser.TextToMetricFamilies(bytes.NewReader(data)) require.NoError(b, err) } } // BenchmarkParseTextGzip benchmarks the parsing of a gzipped text-format scrape // into metric family DTOs. func BenchmarkParseTextGzip(b testing.B) { b.StopTimer() data, err := os.ReadFile("testdata/text.gz") require.NoError(b, err) b.StartTimer() for i := 0; i < b.N; i++ { in, err := gzip.NewReader(bytes.NewReader(data)) require.NoError(b, err) _, err = parser.TextToMetricFamilies(in) require.NoError(b, err) } } // BenchmarkParseProto benchmarks the parsing of a protobuf-format scrape into // metric family DTOs. Note that this does not build a map of metric families // (as the text version does), because it is not required for Prometheus // ingestion either. (However, it is required for the text-format parsing, as // the metric family might be sprinkled all over the text, while the // protobuf-format guarantees bundling at one place.) func BenchmarkParseProto(b testing.B) { b.StopTimer() data, err := os.ReadFile("testdata/protobuf") require.NoError(b, err) b.StartTimer() for i := 0; i < b.N; i++ { family := &dto.MetricFamily{} in := bufio.NewReader(bytes.NewReader(data)) unmarshaler := protodelim.UnmarshalOptions{ MaxSize: -1, } for { family.Reset() if err := unmarshaler.UnmarshalFrom(in, family); err != nil { if errors.Is(err, io.EOF) { break } b.Fatal(err) } } } } // BenchmarkParseProtoGzip is like BenchmarkParseProto above, but parses gzipped // protobuf format. func BenchmarkParseProtoGzip(b testing.B) { b.StopTimer() data, err := os.ReadFile("testdata/protobuf.gz") require.NoError(b, err) b.StartTimer() for i := 0; i < b.N; i++ { family := &dto.MetricFamily{} gz, err := gzip.NewReader(bytes.NewReader(data)) require.NoError(b, err) in := bufio.NewReader(gz) unmarshaler := protodelim.UnmarshalOptions{ MaxSize: -1, } for { family.Reset() if err := unmarshaler.UnmarshalFrom(in, family); err != nil { if errors.Is(err, io.EOF) { break } b.Fatal(err) } } } } // BenchmarkParseProtoMap is like BenchmarkParseProto but DOES put the parsed // metric family DTOs into a map. This is not happening during Prometheus // ingestion. It is just here to measure the overhead of that map creation and // separate it from the overhead of the text format parsing. func BenchmarkParseProtoMap(b testing.B) { b.StopTimer() data, err := os.ReadFile("testdata/protobuf") require.NoError(b, err) b.StartTimer() for i := 0; i < b.N; i++ { families := map[string]dto.MetricFamily{} in := bufio.NewReader(bytes.NewReader(data)) unmarshaler := protodelim.UnmarshalOptions{ MaxSize: -1, } for { family := &dto.MetricFamily{} if err := unmarshaler.UnmarshalFrom(in, family); err != nil { if errors.Is(err, io.EOF) { break } b.Fatal(err) } families[family.GetName()] = family } } }	4.92 KB	2025-05-25 12:27
📄 decode.go // Copyright 2015 The Prometheus Authors // 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 expfmt import ( "bufio" "fmt" "io" "math" "mime" "net/http" dto "github.com/prometheus/client_model/go" "google.golang.org/protobuf/encoding/protodelim" "github.com/prometheus/common/model" ) // Decoder types decode an input stream into metric families. type Decoder interface { Decode(dto.MetricFamily) error } // DecodeOptions contains options used by the Decoder and in sample extraction. type DecodeOptions struct { // Timestamp is added to each value from the stream that has no explicit timestamp set. Timestamp model.Time } // ResponseFormat extracts the correct format from a HTTP response header. // If no matching format can be found FormatUnknown is returned. func ResponseFormat(h http.Header) Format { ct := h.Get(hdrContentType) mediatype, params, err := mime.ParseMediaType(ct) if err != nil { return FmtUnknown } const textType = "text/plain" switch mediatype { case ProtoType: if p, ok := params["proto"]; ok && p != ProtoProtocol { return FmtUnknown } if e, ok := params["encoding"]; ok && e != "delimited" { return FmtUnknown } return FmtProtoDelim case textType: if v, ok := params["version"]; ok && v != TextVersion { return FmtUnknown } return FmtText } return FmtUnknown } // NewDecoder returns a new decoder based on the given input format. // If the input format does not imply otherwise, a text format decoder is returned. func NewDecoder(r io.Reader, format Format) Decoder { switch format.FormatType() { case TypeProtoDelim: return &protoDecoder{r: bufio.NewReader(r)} } return &textDecoder{r: r} } // protoDecoder implements the Decoder interface for protocol buffers. type protoDecoder struct { r protodelim.Reader } // Decode implements the Decoder interface. func (d protoDecoder) Decode(v dto.MetricFamily) error { opts := protodelim.UnmarshalOptions{ MaxSize: -1, } if err := opts.UnmarshalFrom(d.r, v); err != nil { return err } if !model.IsValidMetricName(model.LabelValue(v.GetName())) { return fmt.Errorf("invalid metric name %q", v.GetName()) } for _, m := range v.GetMetric() { if m == nil { continue } for _, l := range m.GetLabel() { if l == nil { continue } if !model.LabelValue(l.GetValue()).IsValid() { return fmt.Errorf("invalid label value %q", l.GetValue()) } if !model.LabelName(l.GetName()).IsValid() { return fmt.Errorf("invalid label name %q", l.GetName()) } } } return nil } // textDecoder implements the Decoder interface for the text protocol. type textDecoder struct { r io.Reader fams map[string]dto.MetricFamily err error } // Decode implements the Decoder interface. func (d textDecoder) Decode(v dto.MetricFamily) error { if d.err == nil { // Read all metrics in one shot. var p TextParser d.fams, d.err = p.TextToMetricFamilies(d.r) // If we don't get an error, store io.EOF for the end. if d.err == nil { d.err = io.EOF } } // Pick off one MetricFamily per Decode until there's nothing left. for key, fam := range d.fams { v.Name = fam.Name v.Help = fam.Help v.Type = fam.Type v.Metric = fam.Metric delete(d.fams, key) return nil } return d.err } // SampleDecoder wraps a Decoder to extract samples from the metric families // decoded by the wrapped Decoder. type SampleDecoder struct { Dec Decoder Opts DecodeOptions f dto.MetricFamily } // Decode calls the Decode method of the wrapped Decoder and then extracts the // samples from the decoded MetricFamily into the provided model.Vector. func (sd SampleDecoder) Decode(s model.Vector) error { err := sd.Dec.Decode(&sd.f) if err != nil { return err } s, err = extractSamples(&sd.f, sd.Opts) return err } // ExtractSamples builds a slice of samples from the provided metric // families. If an error occurs during sample extraction, it continues to // extract from the remaining metric families. The returned error is the last // error that has occurred. func ExtractSamples(o DecodeOptions, fams ...dto.MetricFamily) (model.Vector, error) { var ( all model.Vector lastErr error ) for _, f := range fams { some, err := extractSamples(f, o) if err != nil { lastErr = err continue } all = append(all, some...) } return all, lastErr } func extractSamples(f dto.MetricFamily, o DecodeOptions) (model.Vector, error) { switch f.GetType() { case dto.MetricType_COUNTER: return extractCounter(o, f), nil case dto.MetricType_GAUGE: return extractGauge(o, f), nil case dto.MetricType_SUMMARY: return extractSummary(o, f), nil case dto.MetricType_UNTYPED: return extractUntyped(o, f), nil case dto.MetricType_HISTOGRAM: return extractHistogram(o, f), nil } return nil, fmt.Errorf("expfmt.extractSamples: unknown metric family type %v", f.GetType()) } func extractCounter(o DecodeOptions, f dto.MetricFamily) model.Vector { samples := make(model.Vector, 0, len(f.Metric)) for _, m := range f.Metric { if m.Counter == nil { continue } lset := make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName()) smpl := &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Counter.GetValue()), } if m.TimestampMs != nil { smpl.Timestamp = model.TimeFromUnixNano(m.TimestampMs 1000000) } else { smpl.Timestamp = o.Timestamp } samples = append(samples, smpl) } return samples } func extractGauge(o DecodeOptions, f dto.MetricFamily) model.Vector { samples := make(model.Vector, 0, len(f.Metric)) for _, m := range f.Metric { if m.Gauge == nil { continue } lset := make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName()) smpl := &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Gauge.GetValue()), } if m.TimestampMs != nil { smpl.Timestamp = model.TimeFromUnixNano(m.TimestampMs 1000000) } else { smpl.Timestamp = o.Timestamp } samples = append(samples, smpl) } return samples } func extractUntyped(o DecodeOptions, f dto.MetricFamily) model.Vector { samples := make(model.Vector, 0, len(f.Metric)) for _, m := range f.Metric { if m.Untyped == nil { continue } lset := make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName()) smpl := &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Untyped.GetValue()), } if m.TimestampMs != nil { smpl.Timestamp = model.TimeFromUnixNano(m.TimestampMs 1000000) } else { smpl.Timestamp = o.Timestamp } samples = append(samples, smpl) } return samples } func extractSummary(o DecodeOptions, f dto.MetricFamily) model.Vector { samples := make(model.Vector, 0, len(f.Metric)) for _, m := range f.Metric { if m.Summary == nil { continue } timestamp := o.Timestamp if m.TimestampMs != nil { timestamp = model.TimeFromUnixNano(m.TimestampMs 1000000) } for _, q := range m.Summary.Quantile { lset := make(model.LabelSet, len(m.Label)+2) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } // BUG(matt): Update other names to "quantile". lset[model.LabelName(model.QuantileLabel)] = model.LabelValue(fmt.Sprint(q.GetQuantile())) lset[model.MetricNameLabel] = model.LabelValue(f.GetName()) samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(q.GetValue()), Timestamp: timestamp, }) } lset := make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_sum") samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Summary.GetSampleSum()), Timestamp: timestamp, }) lset = make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_count") samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Summary.GetSampleCount()), Timestamp: timestamp, }) } return samples } func extractHistogram(o DecodeOptions, f dto.MetricFamily) model.Vector { samples := make(model.Vector, 0, len(f.Metric)) for _, m := range f.Metric { if m.Histogram == nil { continue } timestamp := o.Timestamp if m.TimestampMs != nil { timestamp = model.TimeFromUnixNano(m.TimestampMs 1000000) } infSeen := false for _, q := range m.Histogram.Bucket { lset := make(model.LabelSet, len(m.Label)+2) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.LabelName(model.BucketLabel)] = model.LabelValue(fmt.Sprint(q.GetUpperBound())) lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_bucket") if math.IsInf(q.GetUpperBound(), +1) { infSeen = true } samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(q.GetCumulativeCount()), Timestamp: timestamp, }) } lset := make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_sum") samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Histogram.GetSampleSum()), Timestamp: timestamp, }) lset = make(model.LabelSet, len(m.Label)+1) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_count") count := &model.Sample{ Metric: model.Metric(lset), Value: model.SampleValue(m.Histogram.GetSampleCount()), Timestamp: timestamp, } samples = append(samples, count) if !infSeen { // Append an infinity bucket sample. lset := make(model.LabelSet, len(m.Label)+2) for _, p := range m.Label { lset[model.LabelName(p.GetName())] = model.LabelValue(p.GetValue()) } lset[model.LabelName(model.BucketLabel)] = model.LabelValue("+Inf") lset[model.MetricNameLabel] = model.LabelValue(f.GetName() + "_bucket") samples = append(samples, &model.Sample{ Metric: model.Metric(lset), Value: count.Value, Timestamp: timestamp, }) } } return samples }	11.27 KB	2025-05-25 12:27
📄 decode_test.go // Copyright 2015 The Prometheus Authors // 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 expfmt import ( "bufio" "bytes" "errors" "io" "math" "net/http" "os" "reflect" "sort" "strings" "testing" dto "github.com/prometheus/client_model/go" "github.com/stretchr/testify/require" "google.golang.org/protobuf/proto" "github.com/prometheus/common/model" ) func TestTextDecoder(t testing.T) { var ( ts = model.Now() in = ` # Only a quite simple scenario with two metric families. # More complicated tests of the parser itself can be found in the text package. # TYPE mf2 counter mf2 3 mf1{label="value1"} -3.14 123456 mf1{label="value2"} 42 mf2 4 ` out = model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "mf1", "label": "value1", }, Value: -3.14, Timestamp: 123456, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "mf1", "label": "value2", }, Value: 42, Timestamp: ts, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "mf2", }, Value: 3, Timestamp: ts, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "mf2", }, Value: 4, Timestamp: ts, }, } ) dec := &SampleDecoder{ Dec: &textDecoder{r: strings.NewReader(in)}, Opts: &DecodeOptions{ Timestamp: ts, }, } var all model.Vector for { var smpls model.Vector err := dec.Decode(&smpls) if err != nil && errors.Is(err, io.EOF) { break } require.NoError(t, err) all = append(all, smpls...) } sort.Sort(all) sort.Sort(out) require.Truef(t, reflect.DeepEqual(all, out), "output does not match") } func TestProtoDecoder(t testing.T) { testTime := model.Now() scenarios := []struct { in string expected model.Vector legacyNameFail bool fail bool }{ { in: "", }, { in: "\x8f\x01\n\rrequest_count\x12\x12Number of requests\x18\x00\"0\n#\n\x0fsome_!abel_name\x12\x10some_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00E\xc0\"6\n)\n\x12another_label_name\x12\x13another_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00U@", fail: true, }, { in: "\x8f\x01\n\rrequest_count\x12\x12Number of requests\x18\x00\"0\n#\n\x0fsome_label_name\x12\x10some_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00E\xc0\"6\n)\n\x12another_label_name\x12\x13another_label_value\x1a\t\t\x00\x00\x00\x00\x00\x00U@", expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", "some_label_name": "some_label_value", }, Value: -42, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", "another_label_name": "another_label_value", }, Value: 84, Timestamp: testTime, }, }, }, { in: "\xb9\x01\n\rrequest_count\x12\x12Number of requests\x18\x02\"O\n#\n\x0fsome_label_name\x12\x10some_label_value\"(\x1a\x12\t\xaeG\xe1z\x14\xae\xef?\x11\x00\x00\x00\x00\x00\x00E\xc0\x1a\x12\t+\x87\x16\xd9\xce\xf7\xef?\x11\x00\x00\x00\x00\x00\x00U\xc0\"A\n)\n\x12another_label_name\x12\x13another_label_value\"\x14\x1a\x12\t\x00\x00\x00\x00\x00\x00\xe0?\x11\x00\x00\x00\x00\x00\x00$@", expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count_count", "some_label_name": "some_label_value", }, Value: 0, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count_sum", "some_label_name": "some_label_value", }, Value: 0, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", "some_label_name": "some_label_value", "quantile": "0.99", }, Value: -42, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", "some_label_name": "some_label_value", "quantile": "0.999", }, Value: -84, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count_count", "another_label_name": "another_label_value", }, Value: 0, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count_sum", "another_label_name": "another_label_value", }, Value: 0, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", "another_label_name": "another_label_value", "quantile": "0.5", }, Value: 10, Timestamp: testTime, }, }, }, { in: "\x8d\x01\n\x1drequest_duration_microseconds\x12\x15The response latency.\x18\x04\"S:Q\b\x85\x15\x11\xcd\xcc\xccL\x8f\xcb:A\x1a\v\b{\x11\x00\x00\x00\x00\x00\x00Y@\x1a\f\b\x9c\x03\x11\x00\x00\x00\x00\x00\x00^@\x1a\f\b\xd0\x04\x11\x00\x00\x00\x00\x00\x00b@\x1a\f\b\xf4\v\x11\x9a\x99\x99\x99\x99\x99e@\x1a\f\b\x85\x15\x11\x00\x00\x00\x00\x00\x00\xf0\u007f", expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "100", }, Value: 123, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "120", }, Value: 412, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "144", }, Value: 592, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "172.8", }, Value: 1524, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_bucket", "le": "+Inf", }, Value: 2693, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_sum", }, Value: 1756047.3, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_count", }, Value: 2693, Timestamp: testTime, }, }, }, { in: "\u007f\n\x1drequest_duration_microseconds\x12\x15The response latency.\x18\x04\"E:C\b\x85\x15\x11\xcd\xcc\xccL\x8f\xcb:A\x1a\v\b{\x11\x00\x00\x00\x00\x00\x00Y@\x1a\f\b\x9c\x03\x11\x00\x00\x00\x00\x00\x00^@\x1a\f\b\xd0\x04\x11\x00\x00\x00\x00\x00\x00b@\x1a\f\b\xf4\v\x11\x9a\x99\x99\x99\x99\x99e@", expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_count", }, Value: 2693, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ "le": "+Inf", model.MetricNameLabel: "request_duration_microseconds_bucket", }, Value: 2693, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_duration_microseconds_sum", }, Value: 1756047.3, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ "le": "172.8", model.MetricNameLabel: "request_duration_microseconds_bucket", }, Value: 1524, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ "le": "144", model.MetricNameLabel: "request_duration_microseconds_bucket", }, Value: 592, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ "le": "120", model.MetricNameLabel: "request_duration_microseconds_bucket", }, Value: 412, Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ "le": "100", model.MetricNameLabel: "request_duration_microseconds_bucket", }, Value: 123, Timestamp: testTime, }, }, }, { // The metric type is unset in this protobuf, which needs to be handled // correctly by the decoder. in: "\x1c\n\rrequest_count\"\v\x1a\t\t\x00\x00\x00\x00\x00\x00\xf0?", expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "request_count", }, Value: 1, Timestamp: testTime, }, }, }, { in: "\xa8\x01\n\ngauge.name\x12\x11gauge\ndoc\nstr\"ing\x18\x01\"T\n\x1b\n\x06name.1\x12\x11val with\nnew line\n\n\x06name2\x12 val with \\backslash and \"quotes\"\x12\t\t\x00\x00\x00\x00\x00\x00\xf0\x7f\"/\n\x10\n\x06name.1\x12\x06Björn\n\x10\n\x06name2\x12\x06佖佥\x12\t\t\xd1\xcfD\xb9\xd0\x05\xc2H", legacyNameFail: true, expected: model.Vector{ &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "gauge.name", "name.1": "val with\nnew line", "name2": "val with \\backslash and \"quotes\"", }, Value: model.SampleValue(math.Inf(+1)), Timestamp: testTime, }, &model.Sample{ Metric: model.Metric{ model.MetricNameLabel: "gauge.name", "name.1": "Björn", "name2": "佖佥", }, Value: 3.14e42, Timestamp: testTime, }, }, }, } for i, scenario := range scenarios { dec := &SampleDecoder{ Dec: &protoDecoder{r: strings.NewReader(scenario.in)}, Opts: &DecodeOptions{ Timestamp: testTime, }, } var all model.Vector for { model.NameValidationScheme = model.LegacyValidation var smpls model.Vector err := dec.Decode(&smpls) if err != nil && errors.Is(err, io.EOF) { break } if scenario.legacyNameFail { require.Errorf(t, err, "Expected error when decoding without UTF-8 support enabled but got none") model.NameValidationScheme = model.UTF8Validation dec = &SampleDecoder{ Dec: &protoDecoder{r: strings.NewReader(scenario.in)}, Opts: &DecodeOptions{ Timestamp: testTime, }, } err = dec.Decode(&smpls) if errors.Is(err, io.EOF) { break } require.NoErrorf(t, err, "Unexpected error when decoding with UTF-8 support: %v", err) } if scenario.fail { require.Errorf(t, err, "Expected error but got none") break } require.NoError(t, err) all = append(all, smpls...) } sort.Sort(all) sort.Sort(scenario.expected) require.Truef(t, reflect.DeepEqual(all, scenario.expected), "%d. output does not match, want: %#v, got %#v", i, scenario.expected, all) } } func TestProtoMultiMessageDecoder(t testing.T) { data, err := os.ReadFile("testdata/protobuf-multimessage") require.NoErrorf(t, err, "Reading file failed: %v", err) buf := bytes.NewReader(data) decoder := NewDecoder(buf, FmtProtoDelim) var metrics []dto.MetricFamily for { var mf dto.MetricFamily if err := decoder.Decode(&mf); err != nil { if errors.Is(err, io.EOF) { break } t.Fatalf("Unmarshalling failed: %v", err) } metrics = append(metrics, &mf) } require.Lenf(t, metrics, 6, "Expected %d metrics but got %d!", 6, len(metrics)) } func testDiscriminatorHTTPHeader(t testing.TB) { scenarios := []struct { input map[string]string output Format }{ { input: map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="delimited"`}, output: FmtProtoDelim, }, { input: map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="illegal"; encoding="delimited"`}, output: FmtUnknown, }, { input: map[string]string{"Content-Type": `application/vnd.google.protobuf; proto="io.prometheus.client.MetricFamily"; encoding="illegal"`}, output: FmtUnknown, }, { input: map[string]string{"Content-Type": `text/plain; version=0.0.4`}, output: FmtText, }, { input: map[string]string{"Content-Type": `text/plain`}, output: FmtText, }, { input: map[string]string{"Content-Type": `text/plain; version=0.0.3`}, output: FmtUnknown, }, } for i, scenario := range scenarios { var header http.Header if len(scenario.input) > 0 { header = http.Header{} } for key, value := range scenario.input { header.Add(key, value) } actual := ResponseFormat(header) if scenario.output != actual { t.Errorf("%d. expected %s, got %s", i, scenario.output, actual) } } } func TestDiscriminatorHTTPHeader(t testing.T) { testDiscriminatorHTTPHeader(t) } func BenchmarkDiscriminatorHTTPHeader(b testing.B) { for i := 0; i < b.N; i++ { testDiscriminatorHTTPHeader(b) } } func TestExtractSamples(t testing.T) { var ( goodMetricFamily1 = &dto.MetricFamily{ Name: proto.String("foo"), Help: proto.String("Help for foo."), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(4711), }, }, }, } goodMetricFamily2 = &dto.MetricFamily{ Name: proto.String("bar"), Help: proto.String("Help for bar."), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Gauge: &dto.Gauge{ Value: proto.Float64(3.14), }, }, }, } badMetricFamily = &dto.MetricFamily{ Name: proto.String("bad"), Help: proto.String("Help for bad."), Type: dto.MetricType(42).Enum(), Metric: []dto.Metric{ { Gauge: &dto.Gauge{ Value: proto.Float64(2.7), }, }, }, } opts = &DecodeOptions{ Timestamp: 42, } ) got, err := ExtractSamples(opts, goodMetricFamily1, goodMetricFamily2) if err != nil { t.Error("Unexpected error from ExtractSamples:", err) } want := model.Vector{ &model.Sample{Metric: model.Metric{model.MetricNameLabel: "foo"}, Value: 4711, Timestamp: 42}, &model.Sample{Metric: model.Metric{model.MetricNameLabel: "bar"}, Value: 3.14, Timestamp: 42}, } if !reflect.DeepEqual(got, want) { t.Errorf("unexpected samples extracted, got: %v, want: %v", got, want) } got, err = ExtractSamples(opts, goodMetricFamily1, badMetricFamily, goodMetricFamily2) if err == nil { t.Error("Expected error from ExtractSamples") } if !reflect.DeepEqual(got, want) { t.Errorf("unexpected samples extracted, got: %v, want: %v", got, want) } } func TestTextDecoderWithBufioReader(t testing.T) { example := ` # TYPE foo gauge foo 0 ` var decoded bool r := bufio.NewReader(strings.NewReader(example)) dec := NewDecoder(r, FmtText) for { var mf dto.MetricFamily if err := dec.Decode(&mf); err != nil { if errors.Is(err, io.EOF) { break } t.Fatalf("Unexpected error: %v", err) } if mf.GetName() != "foo" { t.Errorf("Unexpected metric name: got %v, expected %v", mf.GetName(), "foo") } if len(mf.Metric) != 1 { t.Errorf("Unexpected number of metrics: got %v, expected %v", len(mf.Metric), 1) } decoded = true } require.Truef(t, decoded, "Metric foo not decoded") }	15.55 KB	2025-05-25 12:27
📄 encode.go // Copyright 2015 The Prometheus Authors // 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 expfmt import ( "fmt" "io" "net/http" "google.golang.org/protobuf/encoding/protodelim" "google.golang.org/protobuf/encoding/prototext" "github.com/prometheus/common/model" "github.com/munnerz/goautoneg" dto "github.com/prometheus/client_model/go" ) // Encoder types encode metric families into an underlying wire protocol. type Encoder interface { Encode(dto.MetricFamily) error } // Closer is implemented by Encoders that need to be closed to finalize // encoding. (For example, OpenMetrics needs a final `# EOF` line.) // // Note that all Encoder implementations returned from this package implement // Closer, too, even if the Close call is a no-op. This happens in preparation // for adding a Close method to the Encoder interface directly in a (mildly // breaking) release in the future. type Closer interface { Close() error } type encoderCloser struct { encode func(dto.MetricFamily) error close func() error } func (ec encoderCloser) Encode(v dto.MetricFamily) error { return ec.encode(v) } func (ec encoderCloser) Close() error { return ec.close() } // Negotiate returns the Content-Type based on the given Accept header. If no // appropriate accepted type is found, FmtText is returned (which is the // Prometheus text format). This function will never negotiate FmtOpenMetrics, // as the support is still experimental. To include the option to negotiate // FmtOpenMetrics, use NegotiateOpenMetrics. func Negotiate(h http.Header) Format { escapingScheme := Format(fmt.Sprintf("; escaping=%s", Format(model.NameEscapingScheme.String()))) for _, ac := range goautoneg.ParseAccept(h.Get(hdrAccept)) { if escapeParam := ac.Params[model.EscapingKey]; escapeParam != "" { switch Format(escapeParam) { case model.AllowUTF8, model.EscapeUnderscores, model.EscapeDots, model.EscapeValues: escapingScheme = Format("; escaping=" + escapeParam) default: // If the escaping parameter is unknown, ignore it. } } ver := ac.Params["version"] if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol { switch ac.Params["encoding"] { case "delimited": return FmtProtoDelim + escapingScheme case "text": return FmtProtoText + escapingScheme case "compact-text": return FmtProtoCompact + escapingScheme } } if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion \|\| ver == "") { return FmtText + escapingScheme } } return FmtText + escapingScheme } // NegotiateIncludingOpenMetrics works like Negotiate but includes // FmtOpenMetrics as an option for the result. Note that this function is // temporary and will disappear once FmtOpenMetrics is fully supported and as // such may be negotiated by the normal Negotiate function. func NegotiateIncludingOpenMetrics(h http.Header) Format { escapingScheme := Format(fmt.Sprintf("; escaping=%s", Format(model.NameEscapingScheme.String()))) for _, ac := range goautoneg.ParseAccept(h.Get(hdrAccept)) { if escapeParam := ac.Params[model.EscapingKey]; escapeParam != "" { switch Format(escapeParam) { case model.AllowUTF8, model.EscapeUnderscores, model.EscapeDots, model.EscapeValues: escapingScheme = Format("; escaping=" + escapeParam) default: // If the escaping parameter is unknown, ignore it. } } ver := ac.Params["version"] if ac.Type+"/"+ac.SubType == ProtoType && ac.Params["proto"] == ProtoProtocol { switch ac.Params["encoding"] { case "delimited": return FmtProtoDelim + escapingScheme case "text": return FmtProtoText + escapingScheme case "compact-text": return FmtProtoCompact + escapingScheme } } if ac.Type == "text" && ac.SubType == "plain" && (ver == TextVersion \|\| ver == "") { return FmtText + escapingScheme } if ac.Type+"/"+ac.SubType == OpenMetricsType && (ver == OpenMetricsVersion_0_0_1 \|\| ver == OpenMetricsVersion_1_0_0 \|\| ver == "") { switch ver { case OpenMetricsVersion_1_0_0: return FmtOpenMetrics_1_0_0 + escapingScheme default: return FmtOpenMetrics_0_0_1 + escapingScheme } } } return FmtText + escapingScheme } // NewEncoder returns a new encoder based on content type negotiation. All // Encoder implementations returned by NewEncoder also implement Closer, and // callers should always call the Close method. It is currently only required // for FmtOpenMetrics, but a future (breaking) release will add the Close method // to the Encoder interface directly. The current version of the Encoder // interface is kept for backwards compatibility. // In cases where the Format does not allow for UTF-8 names, the global // NameEscapingScheme will be applied. // // NewEncoder can be called with additional options to customize the OpenMetrics text output. // For example: // NewEncoder(w, FmtOpenMetrics_1_0_0, WithCreatedLines()) // // Extra options are ignored for all other formats. func NewEncoder(w io.Writer, format Format, options ...EncoderOption) Encoder { escapingScheme := format.ToEscapingScheme() switch format.FormatType() { case TypeProtoDelim: return encoderCloser{ encode: func(v dto.MetricFamily) error { _, err := protodelim.MarshalTo(w, v) return err }, close: func() error { return nil }, } case TypeProtoCompact: return encoderCloser{ encode: func(v dto.MetricFamily) error { _, err := fmt.Fprintln(w, model.EscapeMetricFamily(v, escapingScheme).String()) return err }, close: func() error { return nil }, } case TypeProtoText: return encoderCloser{ encode: func(v dto.MetricFamily) error { _, err := fmt.Fprintln(w, prototext.Format(model.EscapeMetricFamily(v, escapingScheme))) return err }, close: func() error { return nil }, } case TypeTextPlain: return encoderCloser{ encode: func(v dto.MetricFamily) error { _, err := MetricFamilyToText(w, model.EscapeMetricFamily(v, escapingScheme)) return err }, close: func() error { return nil }, } case TypeOpenMetrics: return encoderCloser{ encode: func(v dto.MetricFamily) error { _, err := MetricFamilyToOpenMetrics(w, model.EscapeMetricFamily(v, escapingScheme), options...) return err }, close: func() error { _, err := FinalizeOpenMetrics(w) return err }, } } panic(fmt.Errorf("expfmt.NewEncoder: unknown format %q", format)) }	6.76 KB	2025-05-25 12:27
📄 encode_test.go // Copyright 2018 The Prometheus Authors // 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 expfmt import ( "bytes" "net/http" "testing" "google.golang.org/protobuf/proto" "github.com/prometheus/common/model" dto "github.com/prometheus/client_model/go" ) func TestNegotiate(t testing.T) { acceptValuePrefix := "application/vnd.google.protobuf;proto=io.prometheus.client.MetricFamily" tests := []struct { name string acceptHeaderValue string expectedFmt string }{ { name: "delimited format", acceptHeaderValue: acceptValuePrefix + ";encoding=delimited", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited; escaping=underscores", }, { name: "text format", acceptHeaderValue: acceptValuePrefix + ";encoding=text", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=text; escaping=underscores", }, { name: "compact text format", acceptHeaderValue: acceptValuePrefix + ";encoding=compact-text", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=underscores", }, { name: "plain text format", acceptHeaderValue: "text/plain;version=0.0.4", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=underscores", }, { name: "delimited format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=delimited; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited; escaping=allow-utf-8", }, { name: "text format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=text; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=text; escaping=allow-utf-8", }, { name: "compact text format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=compact-text; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=allow-utf-8", }, { name: "plain text format 0.0.4 with utf-8 not valid, falls back", acceptHeaderValue: "text/plain;version=0.0.4;", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=underscores", }, { name: "plain text format 0.0.4 with utf-8 not valid, falls back", acceptHeaderValue: "text/plain;version=0.0.4; escaping=values;", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=values", }, } oldDefault := model.NameEscapingScheme model.NameEscapingScheme = model.UnderscoreEscaping defer func() { model.NameEscapingScheme = oldDefault }() for i, test := range tests { t.Run(test.name, func(t testing.T) { h := http.Header{} h.Add(hdrAccept, test.acceptHeaderValue) actualFmt := string(Negotiate(h)) if actualFmt != test.expectedFmt { t.Errorf("case %d: expected Negotiate to return format %s, but got %s instead", i, test.expectedFmt, actualFmt) } }) } } func TestNegotiateOpenMetrics(t testing.T) { acceptValuePrefix := "application/vnd.google.protobuf;proto=io.prometheus.client.MetricFamily" tests := []struct { name string acceptHeaderValue string expectedFmt string }{ { name: "OM format, no version", acceptHeaderValue: "application/openmetrics-text", expectedFmt: "application/openmetrics-text; version=0.0.1; charset=utf-8; escaping=values", }, { name: "OM format, 0.0.1 version", acceptHeaderValue: "application/openmetrics-text;version=0.0.1; escaping=underscores", expectedFmt: "application/openmetrics-text; version=0.0.1; charset=utf-8; escaping=underscores", }, { name: "OM format, 1.0.0 version", acceptHeaderValue: "application/openmetrics-text;version=1.0.0", expectedFmt: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=values", }, { name: "OM format, 0.0.1 version with utf-8 is not valid, falls back", acceptHeaderValue: "application/openmetrics-text;version=0.0.1", expectedFmt: "application/openmetrics-text; version=0.0.1; charset=utf-8; escaping=values", }, { name: "OM format, 1.0.0 version with utf-8 is not valid, falls back", acceptHeaderValue: "application/openmetrics-text;version=1.0.0; escaping=values;", expectedFmt: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=values", }, { name: "OM format, invalid version", acceptHeaderValue: "application/openmetrics-text;version=0.0.4", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=values", }, { name: "compact text format", acceptHeaderValue: acceptValuePrefix + ";encoding=compact-text; escaping=underscores", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=underscores", }, { name: "plain text format", acceptHeaderValue: "text/plain;version=0.0.4", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=values", }, { name: "plain text format 0.0.4", acceptHeaderValue: "text/plain;version=0.0.4; escaping=allow-utf-8", expectedFmt: "text/plain; version=0.0.4; charset=utf-8; escaping=allow-utf-8", }, { name: "delimited format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=delimited; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited; escaping=allow-utf-8", }, { name: "text format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=text; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=text; escaping=allow-utf-8", }, { name: "compact text format utf-8", acceptHeaderValue: acceptValuePrefix + ";encoding=compact-text; escaping=allow-utf-8;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=allow-utf-8", }, { name: "delimited format escaped", acceptHeaderValue: acceptValuePrefix + ";encoding=delimited; escaping=underscores;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=delimited; escaping=underscores", }, { name: "text format escaped", acceptHeaderValue: acceptValuePrefix + ";encoding=text; escaping=underscores;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=text; escaping=underscores", }, { name: "compact text format escaped", acceptHeaderValue: acceptValuePrefix + ";encoding=compact-text; escaping=underscores;", expectedFmt: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=underscores", }, } oldDefault := model.NameEscapingScheme model.NameEscapingScheme = model.ValueEncodingEscaping defer func() { model.NameEscapingScheme = oldDefault }() for i, test := range tests { t.Run(test.name, func(t testing.T) { h := http.Header{} h.Add(hdrAccept, test.acceptHeaderValue) actualFmt := string(NegotiateIncludingOpenMetrics(h)) if actualFmt != test.expectedFmt { t.Errorf("case %d: expected Negotiate to return format %s, but got %s instead", i, test.expectedFmt, actualFmt) } }) } } func TestEncode(t testing.T) { metric1 := &dto.MetricFamily{ Name: proto.String("foo_metric"), Type: dto.MetricType_UNTYPED.Enum(), Unit: proto.String("seconds"), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1.234), }, }, }, } scenarios := []struct { metric dto.MetricFamily format Format options []EncoderOption expOut string }{ // 1: Untyped ProtoDelim { metric: metric1, format: FmtProtoDelim, }, // 2: Untyped FmtProtoCompact { metric: metric1, format: FmtProtoCompact, }, // 3: Untyped FmtProtoText { metric: metric1, format: FmtProtoText, }, // 4: Untyped FmtText { metric: metric1, format: FmtText, expOut: `# TYPE foo_metric untyped foo_metric 1.234 `, }, // 5: Untyped FmtOpenMetrics_0_0_1 { metric: metric1, format: FmtOpenMetrics_0_0_1, expOut: `# TYPE foo_metric unknown foo_metric 1.234 `, }, // 6: Untyped FmtOpenMetrics_1_0_0 { metric: metric1, format: FmtOpenMetrics_1_0_0, expOut: `# TYPE foo_metric unknown foo_metric 1.234 `, }, // 7: Simple Counter FmtOpenMetrics_0_0_1 unit opted in { metric: metric1, format: FmtOpenMetrics_0_0_1, options: []EncoderOption{WithUnit()}, expOut: `# TYPE foo_metric_seconds unknown # UNIT foo_metric_seconds seconds foo_metric_seconds 1.234 `, }, // 8: Simple Counter FmtOpenMetrics_1_0_0 unit opted out { metric: metric1, format: FmtOpenMetrics_1_0_0, expOut: `# TYPE foo_metric unknown foo_metric 1.234 `, }, } for i, scenario := range scenarios { out := bytes.NewBuffer(make([]byte, 0, len(scenario.expOut))) enc := NewEncoder(out, scenario.format, scenario.options...) err := enc.Encode(scenario.metric) if err != nil { t.Errorf("%d. error: %s", i, err) continue } if expected, got := len(scenario.expOut), len(out.Bytes()); expected != 0 && expected != got { t.Errorf( "%d. expected %d bytes written, got %d", i, expected, got, ) } if expected, got := scenario.expOut, out.String(); expected != "" && expected != got { t.Errorf( "%d. expected out=%q, got %q", i, expected, got, ) } if len(out.Bytes()) == 0 { t.Errorf( "%d. expected output not to be empty", i, ) } } } func TestEscapedEncode(t testing.T) { var buff bytes.Buffer delimEncoder := NewEncoder(&buff, FmtProtoDelim+"; escaping=underscores") metric := &dto.MetricFamily{ Name: proto.String("foo.metric"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1.234), }, }, { Label: []dto.LabelPair{ { Name: proto.String("dotted.label.name"), Value: proto.String("my.label.value"), }, }, Untyped: &dto.Untyped{ Value: proto.Float64(8), }, }, }, } err := delimEncoder.Encode(metric) if err != nil { t.Errorf("unexpected error during encode: %s", err.Error()) } out := buff.Bytes() if len(out) == 0 { t.Errorf("expected the output bytes buffer to be non-empty") } buff.Reset() compactEncoder := NewEncoder(&buff, FmtProtoCompact) err = compactEncoder.Encode(metric) if err != nil { t.Errorf("unexpected error during encode: %s", err.Error()) } out = buff.Bytes() if len(out) == 0 { t.Errorf("expected the output bytes buffer to be non-empty") } buff.Reset() protoTextEncoder := NewEncoder(&buff, FmtProtoText) err = protoTextEncoder.Encode(metric) if err != nil { t.Errorf("unexpected error during encode: %s", err.Error()) } out = buff.Bytes() if len(out) == 0 { t.Errorf("expected the output bytes buffer to be non-empty") } buff.Reset() textEncoder := NewEncoder(&buff, FmtText) err = textEncoder.Encode(metric) if err != nil { t.Errorf("unexpected error during encode: %s", err.Error()) } out = buff.Bytes() if len(out) == 0 { t.Errorf("expected the output bytes buffer to be non-empty") } expected := `# TYPE foo_metric untyped foo_metric 1.234 foo_metric{dotted_label_name="my.label.value"} 8 ` if string(out) != expected { t.Errorf("expected TextEncoder to return %s, but got %s instead", expected, string(out)) } }	12.31 KB	2025-05-25 12:27
📄 expfmt.go // Copyright 2015 The Prometheus Authors // 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 expfmt contains tools for reading and writing Prometheus metrics. package expfmt import ( "errors" "strings" "github.com/prometheus/common/model" ) // Format specifies the HTTP content type of the different wire protocols. type Format string // Constants to assemble the Content-Type values for the different wire // protocols. The Content-Type strings here are all for the legacy exposition // formats, where valid characters for metric names and label names are limited. // Support for arbitrary UTF-8 characters in those names is already partially // implemented in this module (see model.ValidationScheme), but to actually use // it on the wire, new content-type strings will have to be agreed upon and // added here. const ( TextVersion = "0.0.4" ProtoType = `application/vnd.google.protobuf` ProtoProtocol = `io.prometheus.client.MetricFamily` // Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoCompact) instead. ProtoFmt = ProtoType + "; proto=" + ProtoProtocol + ";" OpenMetricsType = `application/openmetrics-text` OpenMetricsVersion_0_0_1 = "0.0.1" OpenMetricsVersion_1_0_0 = "1.0.0" // The Content-Type values for the different wire protocols. Do not do direct // comparisons to these constants, instead use the comparison functions. // Deprecated: Use expfmt.NewFormat(expfmt.TypeUnknown) instead. FmtUnknown Format = `<unknown>` // Deprecated: Use expfmt.NewFormat(expfmt.TypeTextPlain) instead. FmtText Format = `text/plain; version=` + TextVersion + `; charset=utf-8` // Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoDelim) instead. FmtProtoDelim Format = ProtoFmt + ` encoding=delimited` // Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoText) instead. FmtProtoText Format = ProtoFmt + ` encoding=text` // Deprecated: Use expfmt.NewFormat(expfmt.TypeProtoCompact) instead. FmtProtoCompact Format = ProtoFmt + ` encoding=compact-text` // Deprecated: Use expfmt.NewFormat(expfmt.TypeOpenMetrics) instead. FmtOpenMetrics_1_0_0 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_1_0_0 + `; charset=utf-8` // Deprecated: Use expfmt.NewFormat(expfmt.TypeOpenMetrics) instead. FmtOpenMetrics_0_0_1 Format = OpenMetricsType + `; version=` + OpenMetricsVersion_0_0_1 + `; charset=utf-8` ) const ( hdrContentType = "Content-Type" hdrAccept = "Accept" ) // FormatType is a Go enum representing the overall category for the given // Format. As the number of Format permutations increases, doing basic string // comparisons are not feasible, so this enum captures the most useful // high-level attribute of the Format string. type FormatType int const ( TypeUnknown FormatType = iota TypeProtoCompact TypeProtoDelim TypeProtoText TypeTextPlain TypeOpenMetrics ) // NewFormat generates a new Format from the type provided. Mostly used for // tests, most Formats should be generated as part of content negotiation in // encode.go. If a type has more than one version, the latest version will be // returned. func NewFormat(t FormatType) Format { switch t { case TypeProtoCompact: return FmtProtoCompact case TypeProtoDelim: return FmtProtoDelim case TypeProtoText: return FmtProtoText case TypeTextPlain: return FmtText case TypeOpenMetrics: return FmtOpenMetrics_1_0_0 default: return FmtUnknown } } // NewOpenMetricsFormat generates a new OpenMetrics format matching the // specified version number. func NewOpenMetricsFormat(version string) (Format, error) { if version == OpenMetricsVersion_0_0_1 { return FmtOpenMetrics_0_0_1, nil } if version == OpenMetricsVersion_1_0_0 { return FmtOpenMetrics_1_0_0, nil } return FmtUnknown, errors.New("unknown open metrics version string") } // WithEscapingScheme returns a copy of Format with the specified escaping // scheme appended to the end. If an escaping scheme already exists it is // removed. func (f Format) WithEscapingScheme(s model.EscapingScheme) Format { var terms []string for _, p := range strings.Split(string(f), ";") { toks := strings.Split(p, "=") if len(toks) != 2 { trimmed := strings.TrimSpace(p) if len(trimmed) > 0 { terms = append(terms, trimmed) } continue } key := strings.TrimSpace(toks[0]) if key != model.EscapingKey { terms = append(terms, strings.TrimSpace(p)) } } terms = append(terms, model.EscapingKey+"="+s.String()) return Format(strings.Join(terms, "; ")) } // FormatType deduces an overall FormatType for the given format. func (f Format) FormatType() FormatType { toks := strings.Split(string(f), ";") params := make(map[string]string) for i, t := range toks { if i == 0 { continue } args := strings.Split(t, "=") if len(args) != 2 { continue } params[strings.TrimSpace(args[0])] = strings.TrimSpace(args[1]) } switch strings.TrimSpace(toks[0]) { case ProtoType: if params["proto"] != ProtoProtocol { return TypeUnknown } switch params["encoding"] { case "delimited": return TypeProtoDelim case "text": return TypeProtoText case "compact-text": return TypeProtoCompact default: return TypeUnknown } case OpenMetricsType: if params["charset"] != "utf-8" { return TypeUnknown } return TypeOpenMetrics case "text/plain": v, ok := params["version"] if !ok { return TypeTextPlain } if v == TextVersion { return TypeTextPlain } return TypeUnknown default: return TypeUnknown } } // ToEscapingScheme returns an EscapingScheme depending on the Format. Iff the // Format contains a escaping=allow-utf-8 term, it will select NoEscaping. If a valid // "escaping" term exists, that will be used. Otherwise, the global default will // be returned. func (format Format) ToEscapingScheme() model.EscapingScheme { for _, p := range strings.Split(string(format), ";") { toks := strings.Split(p, "=") if len(toks) != 2 { continue } key, value := strings.TrimSpace(toks[0]), strings.TrimSpace(toks[1]) if key == model.EscapingKey { scheme, err := model.ToEscapingScheme(value) if err != nil { return model.NameEscapingScheme } return scheme } } return model.NameEscapingScheme }	6.58 KB	2025-05-25 12:27
📄 expfmt_test.go // Copyright 2024 The Prometheus Authors // 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 expfmt import ( "testing" "github.com/prometheus/common/model" "github.com/stretchr/testify/require" ) // Test Format to Escapting Scheme conversion // Path: expfmt/expfmt_test.go // Compare this snippet from expfmt/expfmt.go: func TestToFormatType(t testing.T) { tests := []struct { format Format expected FormatType }{ { format: FmtProtoCompact, expected: TypeProtoCompact, }, { format: FmtProtoDelim, expected: TypeProtoDelim, }, { format: FmtProtoText, expected: TypeProtoText, }, { format: FmtOpenMetrics_1_0_0, expected: TypeOpenMetrics, }, { format: FmtText, expected: TypeTextPlain, }, { format: FmtOpenMetrics_0_0_1, expected: TypeOpenMetrics, }, { format: "application/vnd.google.protobuf; proto=BadProtocol; encoding=text", expected: TypeUnknown, }, { format: "application/vnd.google.protobuf", expected: TypeUnknown, }, { format: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily=bad", expected: TypeUnknown, }, // encoding missing { format: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily", expected: TypeUnknown, }, // invalid encoding { format: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=textual", expected: TypeUnknown, }, // bad charset, must be utf-8 { format: "application/openmetrics-text; version=1.0.0; charset=ascii", expected: TypeUnknown, }, { format: "text/plain", expected: TypeTextPlain, }, { format: "text/plain; version=invalid", expected: TypeUnknown, }, { format: "gobbledygook", expected: TypeUnknown, }, } for _, test := range tests { require.Equal(t, test.expected, test.format.FormatType()) } } func TestToEscapingScheme(t testing.T) { tests := []struct { format Format expected model.EscapingScheme }{ { format: FmtProtoCompact, expected: model.UnderscoreEscaping, }, { format: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=dots", expected: model.DotsEscaping, }, { format: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=allow-utf-8", expected: model.NoEscaping, }, // error returns default { format: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=invalid", expected: model.NameEscapingScheme, }, } for _, test := range tests { require.Equal(t, test.expected, test.format.ToEscapingScheme()) } } func TestWithEscapingScheme(t *testing.T) { tests := []struct { name string format Format scheme model.EscapingScheme expected string }{ { name: "no existing term, append one", format: FmtProtoCompact, scheme: model.DotsEscaping, expected: "application/vnd.google.protobuf; proto=io.prometheus.client.MetricFamily; encoding=compact-text; escaping=dots", }, { name: "existing term at end, replace", format: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=underscores", scheme: model.ValueEncodingEscaping, expected: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=values", }, { name: "existing term in middle, replace", format: "application/openmetrics-text; escaping=dots; version=1.0.0; charset=utf-8; ", scheme: model.NoEscaping, expected: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=allow-utf-8", }, { name: "multiple existing terms removed", format: "application/openmetrics-text; escaping=dots; version=1.0.0; charset=utf-8; escaping=allow-utf-8", scheme: model.ValueEncodingEscaping, expected: "application/openmetrics-text; version=1.0.0; charset=utf-8; escaping=values", }, } for _, test := range tests { require.Equal(t, test.expected, string(test.format.WithEscapingScheme(test.scheme))) } }	4.45 KB	2025-05-25 12:27
📁 fuzz	-	2025-05-25 12:27
📄 fuzz.go // Copyright 2014 The Prometheus Authors // 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. // Build only when actually fuzzing //go:build gofuzz // +build gofuzz package expfmt import "bytes" // Fuzz text metric parser with with github.com/dvyukov/go-fuzz: // // go-fuzz-build github.com/prometheus/common/expfmt // go-fuzz -bin expfmt-fuzz.zip -workdir fuzz // // Further input samples should go in the folder fuzz/corpus. func Fuzz(in []byte) int { parser := TextParser{} _, err := parser.TextToMetricFamilies(bytes.NewReader(in)) if err != nil { return 0 } return 1 }	1.06 KB	2025-05-25 12:27
📄 openmetrics_create.go // Copyright 2020 The Prometheus Authors // 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 expfmt import ( "bufio" "bytes" "fmt" "io" "math" "strconv" "strings" "google.golang.org/protobuf/types/known/timestamppb" "github.com/prometheus/common/model" dto "github.com/prometheus/client_model/go" ) type encoderOption struct { withCreatedLines bool withUnit bool } type EncoderOption func(encoderOption) // WithCreatedLines is an EncoderOption that configures the OpenMetrics encoder // to include _created lines (See // https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#counter-1). // Created timestamps can improve the accuracy of series reset detection, but // come with a bandwidth cost. // // At the time of writing, created timestamp ingestion is still experimental in // Prometheus and need to be enabled with the feature-flag // `--feature-flag=created-timestamp-zero-ingestion`, and breaking changes are // still possible. Therefore, it is recommended to use this feature with caution. func WithCreatedLines() EncoderOption { return func(t encoderOption) { t.withCreatedLines = true } } // WithUnit is an EncoderOption enabling a set unit to be written to the output // and to be added to the metric name, if it's not there already, as a suffix. // Without opting in this way, the unit will not be added to the metric name and, // on top of that, the unit will not be passed onto the output, even if it // were declared in the dto.MetricFamily struct, i.e. even if in.Unit !=nil. func WithUnit() EncoderOption { return func(t encoderOption) { t.withUnit = true } } // MetricFamilyToOpenMetrics converts a MetricFamily proto message into the // OpenMetrics text format and writes the resulting lines to 'out'. It returns // the number of bytes written and any error encountered. The output will have // the same order as the input, no further sorting is performed. Furthermore, // this function assumes the input is already sanitized and does not perform any // sanity checks. If the input contains duplicate metrics or invalid metric or // label names, the conversion will result in invalid text format output. // // If metric names conform to the legacy validation pattern, they will be placed // outside the brackets in the traditional way, like `foo{}`. If the metric name // fails the legacy validation check, it will be placed quoted inside the // brackets: `{"foo"}`. As stated above, the input is assumed to be santized and // no error will be thrown in this case. // // Similar to metric names, if label names conform to the legacy validation // pattern, they will be unquoted as normal, like `foo{bar="baz"}`. If the label // name fails the legacy validation check, it will be quoted: // `foo{"bar"="baz"}`. As stated above, the input is assumed to be santized and // no error will be thrown in this case. // // This function fulfills the type 'expfmt.encoder'. // // Note that OpenMetrics requires a final `# EOF` line. Since this function acts // on individual metric families, it is the responsibility of the caller to // append this line to 'out' once all metric families have been written. // Conveniently, this can be done by calling FinalizeOpenMetrics. // // The output should be fully OpenMetrics compliant. However, there are a few // missing features and peculiarities to avoid complications when switching from // Prometheus to OpenMetrics or vice versa: // // - Counters are expected to have the `_total` suffix in their metric name. In // the output, the suffix will be truncated from the `# TYPE`, `# HELP` and `# UNIT` // lines. A counter with a missing `_total` suffix is not an error. However, // its type will be set to `unknown` in that case to avoid invalid OpenMetrics // output. // // - According to the OM specs, the `# UNIT` line is optional, but if populated, // the unit has to be present in the metric name as its suffix: // (see https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#unit). // However, in order to accommodate any potential scenario where such a change in the // metric name is not desirable, the users are here given the choice of either explicitly // opt in, in case they wish for the unit to be included in the output AND in the metric name // as a suffix (see the description of the WithUnit function above), // or not to opt in, in case they don't want for any of that to happen. // // - No support for the following (optional) features: info type, // stateset type, gaugehistogram type. // // - The size of exemplar labels is not checked (i.e. it's possible to create // exemplars that are larger than allowed by the OpenMetrics specification). // // - The value of Counters is not checked. (OpenMetrics doesn't allow counters // with a `NaN` value.) func MetricFamilyToOpenMetrics(out io.Writer, in dto.MetricFamily, options ...EncoderOption) (written int, err error) { toOM := encoderOption{} for _, option := range options { option(&toOM) } name := in.GetName() if name == "" { return 0, fmt.Errorf("MetricFamily has no name: %s", in) } // Try the interface upgrade. If it doesn't work, we'll use a // bufio.Writer from the sync.Pool. w, ok := out.(enhancedWriter) if !ok { b := bufPool.Get().(bufio.Writer) b.Reset(out) w = b defer func() { bErr := b.Flush() if err == nil { err = bErr } bufPool.Put(b) }() } var ( n int metricType = in.GetType() compliantName = name ) if metricType == dto.MetricType_COUNTER && strings.HasSuffix(compliantName, "_total") { compliantName = name[:len(name)-6] } if toOM.withUnit && in.Unit != nil && !strings.HasSuffix(compliantName, "_"+in.Unit) { compliantName = compliantName + "_" + in.Unit } // Comments, first HELP, then TYPE. if in.Help != nil { n, err = w.WriteString("# HELP ") written += n if err != nil { return } n, err = writeName(w, compliantName) written += n if err != nil { return } err = w.WriteByte(' ') written++ if err != nil { return } n, err = writeEscapedString(w, in.Help, true) written += n if err != nil { return } err = w.WriteByte('\n') written++ if err != nil { return } } n, err = w.WriteString("# TYPE ") written += n if err != nil { return } n, err = writeName(w, compliantName) written += n if err != nil { return } switch metricType { case dto.MetricType_COUNTER: if strings.HasSuffix(name, "_total") { n, err = w.WriteString(" counter\n") } else { n, err = w.WriteString(" unknown\n") } case dto.MetricType_GAUGE: n, err = w.WriteString(" gauge\n") case dto.MetricType_SUMMARY: n, err = w.WriteString(" summary\n") case dto.MetricType_UNTYPED: n, err = w.WriteString(" unknown\n") case dto.MetricType_HISTOGRAM: n, err = w.WriteString(" histogram\n") default: return written, fmt.Errorf("unknown metric type %s", metricType.String()) } written += n if err != nil { return } if toOM.withUnit && in.Unit != nil { n, err = w.WriteString("# UNIT ") written += n if err != nil { return } n, err = writeName(w, compliantName) written += n if err != nil { return } err = w.WriteByte(' ') written++ if err != nil { return } n, err = writeEscapedString(w, in.Unit, true) written += n if err != nil { return } err = w.WriteByte('\n') written++ if err != nil { return } } var createdTsBytesWritten int // Finally the samples, one line for each. if metricType == dto.MetricType_COUNTER && strings.HasSuffix(name, "_total") { compliantName = compliantName + "_total" } for _, metric := range in.Metric { switch metricType { case dto.MetricType_COUNTER: if metric.Counter == nil { return written, fmt.Errorf( "expected counter in metric %s %s", compliantName, metric, ) } n, err = writeOpenMetricsSample( w, compliantName, "", metric, "", 0, metric.Counter.GetValue(), 0, false, metric.Counter.Exemplar, ) if toOM.withCreatedLines && metric.Counter.CreatedTimestamp != nil { createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "_total", metric, "", 0, metric.Counter.GetCreatedTimestamp()) n += createdTsBytesWritten } case dto.MetricType_GAUGE: if metric.Gauge == nil { return written, fmt.Errorf( "expected gauge in metric %s %s", compliantName, metric, ) } n, err = writeOpenMetricsSample( w, compliantName, "", metric, "", 0, metric.Gauge.GetValue(), 0, false, nil, ) case dto.MetricType_UNTYPED: if metric.Untyped == nil { return written, fmt.Errorf( "expected untyped in metric %s %s", compliantName, metric, ) } n, err = writeOpenMetricsSample( w, compliantName, "", metric, "", 0, metric.Untyped.GetValue(), 0, false, nil, ) case dto.MetricType_SUMMARY: if metric.Summary == nil { return written, fmt.Errorf( "expected summary in metric %s %s", compliantName, metric, ) } for _, q := range metric.Summary.Quantile { n, err = writeOpenMetricsSample( w, compliantName, "", metric, model.QuantileLabel, q.GetQuantile(), q.GetValue(), 0, false, nil, ) written += n if err != nil { return } } n, err = writeOpenMetricsSample( w, compliantName, "_sum", metric, "", 0, metric.Summary.GetSampleSum(), 0, false, nil, ) written += n if err != nil { return } n, err = writeOpenMetricsSample( w, compliantName, "_count", metric, "", 0, 0, metric.Summary.GetSampleCount(), true, nil, ) if toOM.withCreatedLines && metric.Summary.CreatedTimestamp != nil { createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "", metric, "", 0, metric.Summary.GetCreatedTimestamp()) n += createdTsBytesWritten } case dto.MetricType_HISTOGRAM: if metric.Histogram == nil { return written, fmt.Errorf( "expected histogram in metric %s %s", compliantName, metric, ) } infSeen := false for _, b := range metric.Histogram.Bucket { n, err = writeOpenMetricsSample( w, compliantName, "_bucket", metric, model.BucketLabel, b.GetUpperBound(), 0, b.GetCumulativeCount(), true, b.Exemplar, ) written += n if err != nil { return } if math.IsInf(b.GetUpperBound(), +1) { infSeen = true } } if !infSeen { n, err = writeOpenMetricsSample( w, compliantName, "_bucket", metric, model.BucketLabel, math.Inf(+1), 0, metric.Histogram.GetSampleCount(), true, nil, ) written += n if err != nil { return } } n, err = writeOpenMetricsSample( w, compliantName, "_sum", metric, "", 0, metric.Histogram.GetSampleSum(), 0, false, nil, ) written += n if err != nil { return } n, err = writeOpenMetricsSample( w, compliantName, "_count", metric, "", 0, 0, metric.Histogram.GetSampleCount(), true, nil, ) if toOM.withCreatedLines && metric.Histogram.CreatedTimestamp != nil { createdTsBytesWritten, err = writeOpenMetricsCreated(w, compliantName, "", metric, "", 0, metric.Histogram.GetCreatedTimestamp()) n += createdTsBytesWritten } default: return written, fmt.Errorf( "unexpected type in metric %s %s", compliantName, metric, ) } written += n if err != nil { return } } return } // FinalizeOpenMetrics writes the final `# EOF\n` line required by OpenMetrics. func FinalizeOpenMetrics(w io.Writer) (written int, err error) { return w.Write([]byte("# EOF\n")) } // writeOpenMetricsSample writes a single sample in OpenMetrics text format to // w, given the metric name, the metric proto message itself, optionally an // additional label name with a float64 value (use empty string as label name if // not required), the value (optionally as float64 or uint64, determined by // useIntValue), and optionally an exemplar (use nil if not required). The // function returns the number of bytes written and any error encountered. func writeOpenMetricsSample( w enhancedWriter, name, suffix string, metric dto.Metric, additionalLabelName string, additionalLabelValue float64, floatValue float64, intValue uint64, useIntValue bool, exemplar dto.Exemplar, ) (int, error) { written := 0 n, err := writeOpenMetricsNameAndLabelPairs( w, name+suffix, metric.Label, additionalLabelName, additionalLabelValue, ) written += n if err != nil { return written, err } err = w.WriteByte(' ') written++ if err != nil { return written, err } if useIntValue { n, err = writeUint(w, intValue) } else { n, err = writeOpenMetricsFloat(w, floatValue) } written += n if err != nil { return written, err } if metric.TimestampMs != nil { err = w.WriteByte(' ') written++ if err != nil { return written, err } // TODO(beorn7): Format this directly without converting to a float first. n, err = writeOpenMetricsFloat(w, float64(metric.TimestampMs)/1000) written += n if err != nil { return written, err } } if exemplar != nil && len(exemplar.Label) > 0 { n, err = writeExemplar(w, exemplar) written += n if err != nil { return written, err } } err = w.WriteByte('\n') written++ if err != nil { return written, err } return written, nil } // writeOpenMetricsNameAndLabelPairs works like writeOpenMetricsSample but // formats the float in OpenMetrics style. func writeOpenMetricsNameAndLabelPairs( w enhancedWriter, name string, in []dto.LabelPair, additionalLabelName string, additionalLabelValue float64, ) (int, error) { var ( written int separator byte = '{' metricInsideBraces = false ) if name != "" { // If the name does not pass the legacy validity check, we must put the // metric name inside the braces, quoted. if !model.IsValidLegacyMetricName(name) { metricInsideBraces = true err := w.WriteByte(separator) written++ if err != nil { return written, err } separator = ',' } n, err := writeName(w, name) written += n if err != nil { return written, err } } if len(in) == 0 && additionalLabelName == "" { if metricInsideBraces { err := w.WriteByte('}') written++ if err != nil { return written, err } } return written, nil } for _, lp := range in { err := w.WriteByte(separator) written++ if err != nil { return written, err } n, err := writeName(w, lp.GetName()) written += n if err != nil { return written, err } n, err = w.WriteString(`="`) written += n if err != nil { return written, err } n, err = writeEscapedString(w, lp.GetValue(), true) written += n if err != nil { return written, err } err = w.WriteByte('"') written++ if err != nil { return written, err } separator = ',' } if additionalLabelName != "" { err := w.WriteByte(separator) written++ if err != nil { return written, err } n, err := w.WriteString(additionalLabelName) written += n if err != nil { return written, err } n, err = w.WriteString(`="`) written += n if err != nil { return written, err } n, err = writeOpenMetricsFloat(w, additionalLabelValue) written += n if err != nil { return written, err } err = w.WriteByte('"') written++ if err != nil { return written, err } } err := w.WriteByte('}') written++ if err != nil { return written, err } return written, nil } // writeOpenMetricsCreated writes the created timestamp for a single time series // following OpenMetrics text format to w, given the metric name, the metric proto // message itself, optionally a suffix to be removed, e.g. '_total' for counters, // an additional label name with a float64 value (use empty string as label name if // not required) and the timestamp that represents the created timestamp. // The function returns the number of bytes written and any error encountered. func writeOpenMetricsCreated(w enhancedWriter, name, suffixToTrim string, metric dto.Metric, additionalLabelName string, additionalLabelValue float64, createdTimestamp timestamppb.Timestamp, ) (int, error) { written := 0 n, err := writeOpenMetricsNameAndLabelPairs( w, strings.TrimSuffix(name, suffixToTrim)+"_created", metric.Label, additionalLabelName, additionalLabelValue, ) written += n if err != nil { return written, err } err = w.WriteByte(' ') written++ if err != nil { return written, err } // TODO(beorn7): Format this directly from components of ts to // avoid overflow/underflow and precision issues of the float // conversion. n, err = writeOpenMetricsFloat(w, float64(createdTimestamp.AsTime().UnixNano())/1e9) written += n if err != nil { return written, err } err = w.WriteByte('\n') written++ if err != nil { return written, err } return written, nil } // writeExemplar writes the provided exemplar in OpenMetrics format to w. The // function returns the number of bytes written and any error encountered. func writeExemplar(w enhancedWriter, e dto.Exemplar) (int, error) { written := 0 n, err := w.WriteString(" # ") written += n if err != nil { return written, err } n, err = writeOpenMetricsNameAndLabelPairs(w, "", e.Label, "", 0) written += n if err != nil { return written, err } err = w.WriteByte(' ') written++ if err != nil { return written, err } n, err = writeOpenMetricsFloat(w, e.GetValue()) written += n if err != nil { return written, err } if e.Timestamp != nil { err = w.WriteByte(' ') written++ if err != nil { return written, err } err = (e).Timestamp.CheckValid() if err != nil { return written, err } ts := (e).Timestamp.AsTime() // TODO(beorn7): Format this directly from components of ts to // avoid overflow/underflow and precision issues of the float // conversion. n, err = writeOpenMetricsFloat(w, float64(ts.UnixNano())/1e9) written += n if err != nil { return written, err } } return written, nil } // writeOpenMetricsFloat works like writeFloat but appends ".0" if the resulting // number would otherwise contain neither a "." nor an "e". func writeOpenMetricsFloat(w enhancedWriter, f float64) (int, error) { switch { case f == 1: return w.WriteString("1.0") case f == 0: return w.WriteString("0.0") case f == -1: return w.WriteString("-1.0") case math.IsNaN(f): return w.WriteString("NaN") case math.IsInf(f, +1): return w.WriteString("+Inf") case math.IsInf(f, -1): return w.WriteString("-Inf") default: bp := numBufPool.Get().([]byte) bp = strconv.AppendFloat((bp)[:0], f, 'g', -1, 64) if !bytes.ContainsAny(bp, "e.") { bp = append(bp, '.', '0') } written, err := w.Write(bp) numBufPool.Put(bp) return written, err } } // writeUint is like writeInt just for uint64. func writeUint(w enhancedWriter, u uint64) (int, error) { bp := numBufPool.Get().([]byte) bp = strconv.AppendUint((bp)[:0], u, 10) written, err := w.Write(bp) numBufPool.Put(bp) return written, err }	19.2 KB	2025-05-25 12:27
📄 openmetrics_create_test.go // Copyright 2020 The Prometheus Authors // 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 expfmt import ( "bytes" "math" "strings" "testing" "time" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/known/timestamppb" dto "github.com/prometheus/client_model/go" "github.com/stretchr/testify/require" "github.com/prometheus/common/model" ) func TestCreateOpenMetrics(t testing.T) { openMetricsTimestamp := timestamppb.New(time.Unix(12345, 600000000)) if err := openMetricsTimestamp.CheckValid(); err != nil { t.Error(err) } oldDefaultScheme := model.NameEscapingScheme model.NameEscapingScheme = model.NoEscaping defer func() { model.NameEscapingScheme = oldDefaultScheme }() scenarios := []struct { in dto.MetricFamily options []EncoderOption out string }{ // 0: Counter, timestamp given, no _total suffix. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("two-line\n doc str\\ing"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, out: `# HELP name two-line\n doc str\\ing # TYPE name unknown name{labelname="val1",basename="basevalue"} 42.0 name{labelname="val2",basename="basevalue"} 0.23 1.23456789e+06 `, }, // 1: Dots in name { in: &dto.MetricFamily{ Name: proto.String("name.with.dots"), Help: proto.String("boring help"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, out: `# HELP "name.with.dots" boring help # TYPE "name.with.dots" unknown {"name.with.dots",labelname="val1",basename="basevalue"} 42.0 {"name.with.dots",labelname="val2",basename="basevalue"} 0.23 1.23456789e+06 `, }, // 2: Dots in name, no labels { in: &dto.MetricFamily{ Name: proto.String("name.with.dots"), Help: proto.String("boring help"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, out: `# HELP "name.with.dots" boring help # TYPE "name.with.dots" unknown {"name.with.dots"} 42.0 {"name.with.dots"} 0.23 1.23456789e+06 `, }, // 3: Gauge, some escaping required, +Inf as value, multi-byte characters in label values. { in: &dto.MetricFamily{ Name: proto.String("gauge_name"), Help: proto.String("gauge\ndoc\nstr\"ing"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name_2"), Value: proto.String("val with \\backslash and \"quotes\""), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("Björn"), }, { Name: proto.String("name_2"), Value: proto.String("佖佥"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(3.14e42), }, }, }, }, out: `# HELP gauge_name gauge\ndoc\nstr\"ing # TYPE gauge_name gauge gauge_name{name_1="val with\nnew line",name_2="val with \\backslash and \"quotes\""} +Inf gauge_name{name_1="Björn",name_2="佖佥"} 3.14e+42 `, }, // 4: Gauge, utf-8, some escaping required, +Inf as value, multi-byte characters in label values. { in: &dto.MetricFamily{ Name: proto.String("gauge.name\""), Help: proto.String("gauge\ndoc\nstr\"ing"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name2"), Value: proto.String("val with \\backslash and \"quotes\""), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("Björn"), }, { Name: proto.String("name2"), Value: proto.String("佖佥"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(3.14e42), }, }, }, }, out: `# HELP "gauge.name\"" gauge\ndoc\nstr\"ing # TYPE "gauge.name\"" gauge {"gauge.name\"","name.1"="val with\nnew line","name2"="val with \\backslash and \"quotes\""} +Inf {"gauge.name\"","name.1"="Björn","name2"="佖佥"} 3.14e+42 `, }, // 5: Unknown, no help, one sample with no labels and -Inf as value, another sample with one label. { in: &dto.MetricFamily{ Name: proto.String("unknown_name"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("value 1"), }, }, Untyped: &dto.Untyped{ Value: proto.Float64(-1.23e-45), }, }, }, }, out: `# TYPE unknown_name unknown unknown_name -Inf unknown_name{name_1="value 1"} -1.23e-45 `, }, // 6: Summary. { in: &dto.MetricFamily{ Name: proto.String("summary_name"), Help: proto.String("summary docstring"), Type: dto.MetricType_SUMMARY.Enum(), Metric: []dto.Metric{ { Summary: &dto.Summary{ SampleCount: proto.Uint64(42), SampleSum: proto.Float64(-3.4567), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.5), Value: proto.Float64(-1.23), }, { Quantile: proto.Float64(0.9), Value: proto.Float64(.2342354), }, { Quantile: proto.Float64(0.99), Value: proto.Float64(0), }, }, CreatedTimestamp: openMetricsTimestamp, }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("value 1"), }, { Name: proto.String("name_2"), Value: proto.String("value 2"), }, }, Summary: &dto.Summary{ SampleCount: proto.Uint64(4711), SampleSum: proto.Float64(2010.1971), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.5), Value: proto.Float64(1), }, { Quantile: proto.Float64(0.9), Value: proto.Float64(2), }, { Quantile: proto.Float64(0.99), Value: proto.Float64(3), }, }, CreatedTimestamp: openMetricsTimestamp, }, }, }, }, options: []EncoderOption{WithCreatedLines()}, out: `# HELP summary_name summary docstring # TYPE summary_name summary summary_name{quantile="0.5"} -1.23 summary_name{quantile="0.9"} 0.2342354 summary_name{quantile="0.99"} 0.0 summary_name_sum -3.4567 summary_name_count 42 summary_name_created 12345.6 summary_name{name_1="value 1",name_2="value 2",quantile="0.5"} 1.0 summary_name{name_1="value 1",name_2="value 2",quantile="0.9"} 2.0 summary_name{name_1="value 1",name_2="value 2",quantile="0.99"} 3.0 summary_name_sum{name_1="value 1",name_2="value 2"} 2010.1971 summary_name_count{name_1="value 1",name_2="value 2"} 4711 summary_name_created{name_1="value 1",name_2="value 2"} 12345.6 `, }, // 7: Histogram { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Unit: proto.String("microseconds"), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, CreatedTimestamp: openMetricsTimestamp, }, }, }, }, options: []EncoderOption{WithCreatedLines(), WithUnit()}, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram # UNIT request_duration_microseconds microseconds request_duration_microseconds_bucket{le="100.0"} 123 request_duration_microseconds_bucket{le="120.0"} 412 request_duration_microseconds_bucket{le="144.0"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 request_duration_microseconds_created 12345.6 `, }, // 8: Histogram with missing +Inf bucket. { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Unit: proto.String("microseconds"), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, }, }, }, }, }, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100.0"} 123 request_duration_microseconds_bucket{le="120.0"} 412 request_duration_microseconds_bucket{le="144.0"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, }, // 9: Histogram with missing +Inf bucket but with different exemplars. { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), Exemplar: &dto.Exemplar{ Label: []dto.LabelPair{ { Name: proto.String("foo"), Value: proto.String("bar"), }, }, Value: proto.Float64(119.9), Timestamp: openMetricsTimestamp, }, }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), Exemplar: &dto.Exemplar{ Label: []dto.LabelPair{ { Name: proto.String("foo"), Value: proto.String("baz"), }, { Name: proto.String("dings"), Value: proto.String("bums"), }, }, Value: proto.Float64(140.14), }, }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, }, }, }, }, }, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100.0"} 123 request_duration_microseconds_bucket{le="120.0"} 412 # {foo="bar"} 119.9 12345.6 request_duration_microseconds_bucket{le="144.0"} 592 # {foo="baz",dings="bums"} 140.14 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, }, // 10: Simple Counter. { in: &dto.MetricFamily{ Name: proto.String("foos_total"), Help: proto.String("Number of foos."), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(42), CreatedTimestamp: openMetricsTimestamp, }, }, }, }, options: []EncoderOption{WithCreatedLines()}, out: `# HELP foos Number of foos. # TYPE foos counter foos_total 42.0 foos_created 12345.6 `, }, // 11: Simple Counter without created line. { in: &dto.MetricFamily{ Name: proto.String("foos_total"), Help: proto.String("Number of foos."), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(42), CreatedTimestamp: openMetricsTimestamp, }, }, }, }, out: `# HELP foos Number of foos. # TYPE foos counter foos_total 42.0 `, }, // 12: No metric. { in: &dto.MetricFamily{ Name: proto.String("name_total"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{}, }, out: `# HELP name doc string # TYPE name counter `, }, // 13: Simple Counter with exemplar that has empty label set: // ignore the exemplar, since OpenMetrics spec requires labels. { in: &dto.MetricFamily{ Name: proto.String("foos_total"), Help: proto.String("Number of foos."), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(42), Exemplar: &dto.Exemplar{ Label: []dto.LabelPair{}, Value: proto.Float64(1), Timestamp: openMetricsTimestamp, }, }, }, }, }, out: `# HELP foos Number of foos. # TYPE foos counter foos_total 42.0 `, }, // 14: No metric plus unit. { in: &dto.MetricFamily{ Name: proto.String("name_seconds_total"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Unit: proto.String("seconds"), Metric: []dto.Metric{}, }, options: []EncoderOption{WithUnit()}, out: `# HELP name_seconds doc string # TYPE name_seconds counter # UNIT name_seconds seconds `, }, // 15: Histogram plus unit, but unit not opted in. { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Unit: proto.String("microseconds"), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, }, }, }, }, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100.0"} 123 request_duration_microseconds_bucket{le="120.0"} 412 request_duration_microseconds_bucket{le="144.0"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, }, // 16: No metric, unit opted in, no unit in name. { in: &dto.MetricFamily{ Name: proto.String("name_total"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Unit: proto.String("seconds"), Metric: []dto.Metric{}, }, options: []EncoderOption{WithUnit()}, out: `# HELP name_seconds doc string # TYPE name_seconds counter # UNIT name_seconds seconds `, }, // 17: No metric, unit opted in, BUT unit == nil. { in: &dto.MetricFamily{ Name: proto.String("name_total"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{}, }, options: []EncoderOption{WithUnit()}, out: `# HELP name doc string # TYPE name counter `, }, // 18: Counter, timestamp given, unit opted in, _total suffix. { in: &dto.MetricFamily{ Name: proto.String("some_measure_total"), Help: proto.String("some testing measurement"), Type: dto.MetricType_COUNTER.Enum(), Unit: proto.String("seconds"), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, options: []EncoderOption{WithUnit()}, out: `# HELP some_measure_seconds some testing measurement # TYPE some_measure_seconds counter # UNIT some_measure_seconds seconds some_measure_seconds_total{labelname="val1",basename="basevalue"} 42.0 some_measure_seconds_total{labelname="val2",basename="basevalue"} 0.23 1.23456789e+06 `, }, } for i, scenario := range scenarios { out := bytes.NewBuffer(make([]byte, 0, len(scenario.out))) n, err := MetricFamilyToOpenMetrics(out, scenario.in, scenario.options...) if err != nil { t.Errorf("%d. error: %s", i, err) continue } if expected, got := len(scenario.out), n; expected != got { t.Errorf( "%d. expected %d bytes written, got %d", i, expected, got, ) } if expected, got := scenario.out, out.String(); expected != got { t.Errorf( "%d. expected out=%q, got %q", i, expected, got, ) } } } func BenchmarkOpenMetricsCreate(b testing.B) { mf := &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name_2"), Value: proto.String("val with \\backslash and \"quotes\""), }, { Name: proto.String("name_3"), Value: proto.String("Just a quite long label value to test performance."), }, }, Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("Björn"), }, { Name: proto.String("name_2"), Value: proto.String("佖佥"), }, { Name: proto.String("name_3"), Value: proto.String("Just a quite long label value to test performance."), }, }, Histogram: &dto.Histogram{ SampleCount: proto.Uint64(5699), SampleSum: proto.Float64(49484343543.4343), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(120), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(596), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1535), }, }, }, TimestampMs: proto.Int64(1234567890), }, }, } out := bytes.NewBuffer(make([]byte, 0, 1024)) for i := 0; i < b.N; i++ { _, err := MetricFamilyToOpenMetrics(out, mf) require.NoError(b, err) out.Reset() } } func TestOpenMetricsCreateError(t testing.T) { scenarios := []struct { in dto.MetricFamily err string }{ // 0: No metric name. { in: &dto.MetricFamily{ Help: proto.String("doc string"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, err: "MetricFamily has no name", }, // 1: Wrong type. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, err: "expected counter in metric", }, } for i, scenario := range scenarios { var out bytes.Buffer _, err := MetricFamilyToOpenMetrics(&out, scenario.in) if err == nil { t.Errorf("%d. expected error, got nil", i) continue } if expected, got := scenario.err, err.Error(); strings.Index(got, expected) != 0 { t.Errorf( "%d. expected error starting with %q, got %q", i, expected, got, ) } } }	24.31 KB	2025-05-25 12:27
📁 testdata	-	2025-05-25 12:27
📄 text_create.go // Copyright 2014 The Prometheus Authors // 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 expfmt import ( "bufio" "fmt" "io" "math" "strconv" "strings" "sync" "github.com/prometheus/common/model" dto "github.com/prometheus/client_model/go" ) // enhancedWriter has all the enhanced write functions needed here. bufio.Writer // implements it. type enhancedWriter interface { io.Writer WriteRune(r rune) (n int, err error) WriteString(s string) (n int, err error) WriteByte(c byte) error } const ( initialNumBufSize = 24 ) var ( bufPool = sync.Pool{ New: func() interface{} { return bufio.NewWriter(io.Discard) }, } numBufPool = sync.Pool{ New: func() interface{} { b := make([]byte, 0, initialNumBufSize) return &b }, } ) // MetricFamilyToText converts a MetricFamily proto message into text format and // writes the resulting lines to 'out'. It returns the number of bytes written // and any error encountered. The output will have the same order as the input, // no further sorting is performed. Furthermore, this function assumes the input // is already sanitized and does not perform any sanity checks. If the input // contains duplicate metrics or invalid metric or label names, the conversion // will result in invalid text format output. // // If metric names conform to the legacy validation pattern, they will be placed // outside the brackets in the traditional way, like `foo{}`. If the metric name // fails the legacy validation check, it will be placed quoted inside the // brackets: `{"foo"}`. As stated above, the input is assumed to be santized and // no error will be thrown in this case. // // Similar to metric names, if label names conform to the legacy validation // pattern, they will be unquoted as normal, like `foo{bar="baz"}`. If the label // name fails the legacy validation check, it will be quoted: // `foo{"bar"="baz"}`. As stated above, the input is assumed to be santized and // no error will be thrown in this case. // // This method fulfills the type 'prometheus.encoder'. func MetricFamilyToText(out io.Writer, in dto.MetricFamily) (written int, err error) { // Fail-fast checks. if len(in.Metric) == 0 { return 0, fmt.Errorf("MetricFamily has no metrics: %s", in) } name := in.GetName() if name == "" { return 0, fmt.Errorf("MetricFamily has no name: %s", in) } // Try the interface upgrade. If it doesn't work, we'll use a // bufio.Writer from the sync.Pool. w, ok := out.(enhancedWriter) if !ok { b := bufPool.Get().(bufio.Writer) b.Reset(out) w = b defer func() { bErr := b.Flush() if err == nil { err = bErr } bufPool.Put(b) }() } var n int // Comments, first HELP, then TYPE. if in.Help != nil { n, err = w.WriteString("# HELP ") written += n if err != nil { return } n, err = writeName(w, name) written += n if err != nil { return } err = w.WriteByte(' ') written++ if err != nil { return } n, err = writeEscapedString(w, in.Help, false) written += n if err != nil { return } err = w.WriteByte('\n') written++ if err != nil { return } } n, err = w.WriteString("# TYPE ") written += n if err != nil { return } n, err = writeName(w, name) written += n if err != nil { return } metricType := in.GetType() switch metricType { case dto.MetricType_COUNTER: n, err = w.WriteString(" counter\n") case dto.MetricType_GAUGE: n, err = w.WriteString(" gauge\n") case dto.MetricType_SUMMARY: n, err = w.WriteString(" summary\n") case dto.MetricType_UNTYPED: n, err = w.WriteString(" untyped\n") case dto.MetricType_HISTOGRAM: n, err = w.WriteString(" histogram\n") default: return written, fmt.Errorf("unknown metric type %s", metricType.String()) } written += n if err != nil { return } // Finally the samples, one line for each. for _, metric := range in.Metric { switch metricType { case dto.MetricType_COUNTER: if metric.Counter == nil { return written, fmt.Errorf( "expected counter in metric %s %s", name, metric, ) } n, err = writeSample( w, name, "", metric, "", 0, metric.Counter.GetValue(), ) case dto.MetricType_GAUGE: if metric.Gauge == nil { return written, fmt.Errorf( "expected gauge in metric %s %s", name, metric, ) } n, err = writeSample( w, name, "", metric, "", 0, metric.Gauge.GetValue(), ) case dto.MetricType_UNTYPED: if metric.Untyped == nil { return written, fmt.Errorf( "expected untyped in metric %s %s", name, metric, ) } n, err = writeSample( w, name, "", metric, "", 0, metric.Untyped.GetValue(), ) case dto.MetricType_SUMMARY: if metric.Summary == nil { return written, fmt.Errorf( "expected summary in metric %s %s", name, metric, ) } for _, q := range metric.Summary.Quantile { n, err = writeSample( w, name, "", metric, model.QuantileLabel, q.GetQuantile(), q.GetValue(), ) written += n if err != nil { return } } n, err = writeSample( w, name, "_sum", metric, "", 0, metric.Summary.GetSampleSum(), ) written += n if err != nil { return } n, err = writeSample( w, name, "_count", metric, "", 0, float64(metric.Summary.GetSampleCount()), ) case dto.MetricType_HISTOGRAM: if metric.Histogram == nil { return written, fmt.Errorf( "expected histogram in metric %s %s", name, metric, ) } infSeen := false for _, b := range metric.Histogram.Bucket { n, err = writeSample( w, name, "_bucket", metric, model.BucketLabel, b.GetUpperBound(), float64(b.GetCumulativeCount()), ) written += n if err != nil { return } if math.IsInf(b.GetUpperBound(), +1) { infSeen = true } } if !infSeen { n, err = writeSample( w, name, "_bucket", metric, model.BucketLabel, math.Inf(+1), float64(metric.Histogram.GetSampleCount()), ) written += n if err != nil { return } } n, err = writeSample( w, name, "_sum", metric, "", 0, metric.Histogram.GetSampleSum(), ) written += n if err != nil { return } n, err = writeSample( w, name, "_count", metric, "", 0, float64(metric.Histogram.GetSampleCount()), ) default: return written, fmt.Errorf( "unexpected type in metric %s %s", name, metric, ) } written += n if err != nil { return } } return } // writeSample writes a single sample in text format to w, given the metric // name, the metric proto message itself, optionally an additional label name // with a float64 value (use empty string as label name if not required), and // the value. The function returns the number of bytes written and any error // encountered. func writeSample( w enhancedWriter, name, suffix string, metric dto.Metric, additionalLabelName string, additionalLabelValue float64, value float64, ) (int, error) { written := 0 n, err := writeNameAndLabelPairs( w, name+suffix, metric.Label, additionalLabelName, additionalLabelValue, ) written += n if err != nil { return written, err } err = w.WriteByte(' ') written++ if err != nil { return written, err } n, err = writeFloat(w, value) written += n if err != nil { return written, err } if metric.TimestampMs != nil { err = w.WriteByte(' ') written++ if err != nil { return written, err } n, err = writeInt(w, metric.TimestampMs) written += n if err != nil { return written, err } } err = w.WriteByte('\n') written++ if err != nil { return written, err } return written, nil } // writeNameAndLabelPairs converts a slice of LabelPair proto messages plus the // explicitly given metric name and additional label pair into text formatted as // required by the text format and writes it to 'w'. An empty slice in // combination with an empty string 'additionalLabelName' results in nothing // being written. Otherwise, the label pairs are written, escaped as required by // the text format, and enclosed in '{...}'. The function returns the number of // bytes written and any error encountered. If the metric name is not // legacy-valid, it will be put inside the brackets as well. Legacy-invalid // label names will also be quoted. func writeNameAndLabelPairs( w enhancedWriter, name string, in []dto.LabelPair, additionalLabelName string, additionalLabelValue float64, ) (int, error) { var ( written int separator byte = '{' metricInsideBraces = false ) if name != "" { // If the name does not pass the legacy validity check, we must put the // metric name inside the braces. if !model.IsValidLegacyMetricName(name) { metricInsideBraces = true err := w.WriteByte(separator) written++ if err != nil { return written, err } separator = ',' } n, err := writeName(w, name) written += n if err != nil { return written, err } } if len(in) == 0 && additionalLabelName == "" { if metricInsideBraces { err := w.WriteByte('}') written++ if err != nil { return written, err } } return written, nil } for _, lp := range in { err := w.WriteByte(separator) written++ if err != nil { return written, err } n, err := writeName(w, lp.GetName()) written += n if err != nil { return written, err } n, err = w.WriteString(`="`) written += n if err != nil { return written, err } n, err = writeEscapedString(w, lp.GetValue(), true) written += n if err != nil { return written, err } err = w.WriteByte('"') written++ if err != nil { return written, err } separator = ',' } if additionalLabelName != "" { err := w.WriteByte(separator) written++ if err != nil { return written, err } n, err := w.WriteString(additionalLabelName) written += n if err != nil { return written, err } n, err = w.WriteString(`="`) written += n if err != nil { return written, err } n, err = writeFloat(w, additionalLabelValue) written += n if err != nil { return written, err } err = w.WriteByte('"') written++ if err != nil { return written, err } } err := w.WriteByte('}') written++ if err != nil { return written, err } return written, nil } // writeEscapedString replaces '\' by '\\', new line character by '\n', and - if // includeDoubleQuote is true - '"' by '\"'. var ( escaper = strings.NewReplacer("\\", `\\`, "\n", `\n`) quotedEscaper = strings.NewReplacer("\\", `\\`, "\n", `\n`, "\"", `\"`) ) func writeEscapedString(w enhancedWriter, v string, includeDoubleQuote bool) (int, error) { if includeDoubleQuote { return quotedEscaper.WriteString(w, v) } return escaper.WriteString(w, v) } // writeFloat is equivalent to fmt.Fprint with a float64 argument but hardcodes // a few common cases for increased efficiency. For non-hardcoded cases, it uses // strconv.AppendFloat to avoid allocations, similar to writeInt. func writeFloat(w enhancedWriter, f float64) (int, error) { switch { case f == 1: return 1, w.WriteByte('1') case f == 0: return 1, w.WriteByte('0') case f == -1: return w.WriteString("-1") case math.IsNaN(f): return w.WriteString("NaN") case math.IsInf(f, +1): return w.WriteString("+Inf") case math.IsInf(f, -1): return w.WriteString("-Inf") default: bp := numBufPool.Get().([]byte) bp = strconv.AppendFloat((bp)[:0], f, 'g', -1, 64) written, err := w.Write(bp) numBufPool.Put(bp) return written, err } } // writeInt is equivalent to fmt.Fprint with an int64 argument but uses // strconv.AppendInt with a byte slice taken from a sync.Pool to avoid // allocations. func writeInt(w enhancedWriter, i int64) (int, error) { bp := numBufPool.Get().([]byte) bp = strconv.AppendInt((bp)[:0], i, 10) written, err := w.Write(bp) numBufPool.Put(bp) return written, err } // writeName writes a string as-is if it complies with the legacy naming // scheme, or escapes it in double quotes if not. func writeName(w enhancedWriter, name string) (int, error) { if model.IsValidLegacyMetricName(name) { return w.WriteString(name) } var written int var err error err = w.WriteByte('"') written++ if err != nil { return written, err } var n int n, err = writeEscapedString(w, name, true) written += n if err != nil { return written, err } err = w.WriteByte('"') written++ return written, err }	12.64 KB	2025-05-25 12:27
📄 text_create_test.go // Copyright 2014 The Prometheus Authors // 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 expfmt import ( "bytes" "math" "strings" "testing" "google.golang.org/protobuf/proto" dto "github.com/prometheus/client_model/go" "github.com/stretchr/testify/require" "github.com/prometheus/common/model" ) func TestCreate(t testing.T) { oldDefaultScheme := model.NameEscapingScheme model.NameEscapingScheme = model.NoEscaping defer func() { model.NameEscapingScheme = oldDefaultScheme }() scenarios := []struct { in dto.MetricFamily out string }{ // 0: Counter, NaN as value, timestamp given. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("two-line\n doc str\\ing"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(math.NaN()), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, out: `# HELP name two-line\n doc str\\ing # TYPE name counter name{labelname="val1",basename="basevalue"} NaN name{labelname="val2",basename="basevalue"} 0.23 1234567890 `, }, // 1: Gauge, some escaping required, +Inf as value, multi-byte characters in label values. { in: &dto.MetricFamily{ Name: proto.String("gauge_name"), Help: proto.String("gauge\ndoc\nstr\"ing"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name_2"), Value: proto.String("val with \\backslash and \"quotes\""), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("Björn"), }, { Name: proto.String("name_2"), Value: proto.String("佖佥"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(3.14e42), }, }, }, }, out: `# HELP gauge_name gauge\ndoc\nstr"ing # TYPE gauge_name gauge gauge_name{name_1="val with\nnew line",name_2="val with \\backslash and \"quotes\""} +Inf gauge_name{name_1="Björn",name_2="佖佥"} 3.14e+42 `, }, // 2: Gauge, utf-8, +Inf as value, multi-byte characters in label values. { in: &dto.MetricFamily{ Name: proto.String("gauge.name"), Help: proto.String("gauge\ndoc\nstr\"ing"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name2"), Value: proto.String("val with \\backslash and \"quotes\""), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("Björn"), }, { Name: proto.String("name2"), Value: proto.String("佖佥"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(3.14e42), }, }, }, }, out: `# HELP "gauge.name" gauge\ndoc\nstr"ing # TYPE "gauge.name" gauge {"gauge.name","name.1"="val with\nnew line","name2"="val with \\backslash and \"quotes\""} +Inf {"gauge.name","name.1"="Björn","name2"="佖佥"} 3.14e+42 `, }, // 3: Untyped, no help, one sample with no labels and -Inf as value, another sample with one label. { in: &dto.MetricFamily{ Name: proto.String("untyped_name"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("value 1"), }, }, Untyped: &dto.Untyped{ Value: proto.Float64(-1.23e-45), }, }, }, }, out: `# TYPE untyped_name untyped untyped_name -Inf untyped_name{name_1="value 1"} -1.23e-45 `, }, // 4: Summary. { in: &dto.MetricFamily{ Name: proto.String("summary_name"), Help: proto.String("summary docstring"), Type: dto.MetricType_SUMMARY.Enum(), Metric: []dto.Metric{ { Summary: &dto.Summary{ SampleCount: proto.Uint64(42), SampleSum: proto.Float64(-3.4567), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.5), Value: proto.Float64(-1.23), }, { Quantile: proto.Float64(0.9), Value: proto.Float64(.2342354), }, { Quantile: proto.Float64(0.99), Value: proto.Float64(0), }, }, }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("value 1"), }, { Name: proto.String("name_2"), Value: proto.String("value 2"), }, }, Summary: &dto.Summary{ SampleCount: proto.Uint64(4711), SampleSum: proto.Float64(2010.1971), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.5), Value: proto.Float64(1), }, { Quantile: proto.Float64(0.9), Value: proto.Float64(2), }, { Quantile: proto.Float64(0.99), Value: proto.Float64(3), }, }, }, }, }, }, out: `# HELP summary_name summary docstring # TYPE summary_name summary summary_name{quantile="0.5"} -1.23 summary_name{quantile="0.9"} 0.2342354 summary_name{quantile="0.99"} 0 summary_name_sum -3.4567 summary_name_count 42 summary_name{name_1="value 1",name_2="value 2",quantile="0.5"} 1 summary_name{name_1="value 1",name_2="value 2",quantile="0.9"} 2 summary_name{name_1="value 1",name_2="value 2",quantile="0.99"} 3 summary_name_sum{name_1="value 1",name_2="value 2"} 2010.1971 summary_name_count{name_1="value 1",name_2="value 2"} 4711 `, }, // 5: Histogram { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, }, }, }, }, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100"} 123 request_duration_microseconds_bucket{le="120"} 412 request_duration_microseconds_bucket{le="144"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, }, // 6: Histogram with missing +Inf bucket. { in: &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, }, }, }, }, }, out: `# HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100"} 123 request_duration_microseconds_bucket{le="120"} 412 request_duration_microseconds_bucket{le="144"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, }, // 7: No metric type, should result in default type Counter. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("doc string"), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, out: `# HELP name doc string # TYPE name counter name -Inf `, }, } for i, scenario := range scenarios { out := bytes.NewBuffer(make([]byte, 0, len(scenario.out))) n, err := MetricFamilyToText(out, scenario.in) if err != nil { t.Errorf("%d. error: %s", i, err) continue } if expected, got := len(scenario.out), n; expected != got { t.Errorf( "%d. expected %d bytes written, got %d", i, expected, got, ) } if expected, got := scenario.out, out.String(); expected != got { t.Errorf( "%d. expected out=%q, got %q", i, expected, got, ) } } } func BenchmarkCreate(b testing.B) { mf := &dto.MetricFamily{ Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name_2"), Value: proto.String("val with \\backslash and \"quotes\""), }, { Name: proto.String("name_3"), Value: proto.String("Just a quite long label value to test performance."), }, }, Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, }, }, { Label: []dto.LabelPair{ { Name: proto.String("name_1"), Value: proto.String("Björn"), }, { Name: proto.String("name_2"), Value: proto.String("佖佥"), }, { Name: proto.String("name_3"), Value: proto.String("Just a quite long label value to test performance."), }, }, Histogram: &dto.Histogram{ SampleCount: proto.Uint64(5699), SampleSum: proto.Float64(49484343543.4343), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(120), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(596), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1535), }, }, }, TimestampMs: proto.Int64(1234567890), }, }, } out := bytes.NewBuffer(make([]byte, 0, 1024)) for i := 0; i < b.N; i++ { _, err := MetricFamilyToText(out, mf) require.NoError(b, err) out.Reset() } } func BenchmarkCreateBuildInfo(b testing.B) { mf := &dto.MetricFamily{ Name: proto.String("benchmark_build_info"), Help: proto.String("Test the creation of constant 1-value build_info metric."), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("version"), Value: proto.String("1.2.3"), }, { Name: proto.String("revision"), Value: proto.String("2e84f5e4eacdffb574035810305191ff390360fe"), }, { Name: proto.String("go_version"), Value: proto.String("1.11.1"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(1), }, }, }, } out := bytes.NewBuffer(make([]byte, 0, 1024)) for i := 0; i < b.N; i++ { _, err := MetricFamilyToText(out, mf) require.NoError(b, err) out.Reset() } } func TestCreateError(t testing.T) { scenarios := []struct { in dto.MetricFamily err string }{ // 0: No metric. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{}, }, err: "MetricFamily has no metrics", }, // 1: No metric name. { in: &dto.MetricFamily{ Help: proto.String("doc string"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, err: "MetricFamily has no name", }, // 2: Wrong type. { in: &dto.MetricFamily{ Name: proto.String("name"), Help: proto.String("doc string"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, err: "expected counter in metric", }, } for i, scenario := range scenarios { var out bytes.Buffer _, err := MetricFamilyToText(&out, scenario.in) if err == nil { t.Errorf("%d. expected error, got nil", i) continue } if expected, got := scenario.err, err.Error(); strings.Index(got, expected) != 0 { t.Errorf( "%d. expected error starting with %q, got %q", i, expected, got, ) } } }	15.31 KB	2025-05-25 12:27
📄 text_parse.go // Copyright 2014 The Prometheus Authors // 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 expfmt import ( "bufio" "bytes" "errors" "fmt" "io" "math" "strconv" "strings" "unicode/utf8" dto "github.com/prometheus/client_model/go" "google.golang.org/protobuf/proto" "github.com/prometheus/common/model" ) // A stateFn is a function that represents a state in a state machine. By // executing it, the state is progressed to the next state. The stateFn returns // another stateFn, which represents the new state. The end state is represented // by nil. type stateFn func() stateFn // ParseError signals errors while parsing the simple and flat text-based // exchange format. type ParseError struct { Line int Msg string } // Error implements the error interface. func (e ParseError) Error() string { return fmt.Sprintf("text format parsing error in line %d: %s", e.Line, e.Msg) } // TextParser is used to parse the simple and flat text-based exchange format. Its // zero value is ready to use. type TextParser struct { metricFamiliesByName map[string]dto.MetricFamily buf bufio.Reader // Where the parsed input is read through. err error // Most recent error. lineCount int // Tracks the line count for error messages. currentByte byte // The most recent byte read. currentToken bytes.Buffer // Re-used each time a token has to be gathered from multiple bytes. currentMF dto.MetricFamily currentMetric dto.Metric currentLabelPair dto.LabelPair currentLabelPairs []dto.LabelPair // Temporarily stores label pairs while parsing a metric line. // The remaining member variables are only used for summaries/histograms. currentLabels map[string]string // All labels including '__name__' but excluding 'quantile'/'le' // Summary specific. summaries map[uint64]dto.Metric // Key is created with LabelsToSignature. currentQuantile float64 // Histogram specific. histograms map[uint64]dto.Metric // Key is created with LabelsToSignature. currentBucket float64 // These tell us if the currently processed line ends on '_count' or // '_sum' respectively and belong to a summary/histogram, representing the sample // count and sum of that summary/histogram. currentIsSummaryCount, currentIsSummarySum bool currentIsHistogramCount, currentIsHistogramSum bool // These indicate if the metric name from the current line being parsed is inside // braces and if that metric name was found respectively. currentMetricIsInsideBraces, currentMetricInsideBracesIsPresent bool } // TextToMetricFamilies reads 'in' as the simple and flat text-based exchange // format and creates MetricFamily proto messages. It returns the MetricFamily // proto messages in a map where the metric names are the keys, along with any // error encountered. // // If the input contains duplicate metrics (i.e. lines with the same metric name // and exactly the same label set), the resulting MetricFamily will contain // duplicate Metric proto messages. Similar is true for duplicate label // names. Checks for duplicates have to be performed separately, if required. // Also note that neither the metrics within each MetricFamily are sorted nor // the label pairs within each Metric. Sorting is not required for the most // frequent use of this method, which is sample ingestion in the Prometheus // server. However, for presentation purposes, you might want to sort the // metrics, and in some cases, you must sort the labels, e.g. for consumption by // the metric family injection hook of the Prometheus registry. // // Summaries and histograms are rather special beasts. You would probably not // use them in the simple text format anyway. This method can deal with // summaries and histograms if they are presented in exactly the way the // text.Create function creates them. // // This method must not be called concurrently. If you want to parse different // input concurrently, instantiate a separate Parser for each goroutine. func (p TextParser) TextToMetricFamilies(in io.Reader) (map[string]dto.MetricFamily, error) { p.reset(in) for nextState := p.startOfLine; nextState != nil; nextState = nextState() { // Magic happens here... } // Get rid of empty metric families. for k, mf := range p.metricFamiliesByName { if len(mf.GetMetric()) == 0 { delete(p.metricFamiliesByName, k) } } // If p.err is io.EOF now, we have run into a premature end of the input // stream. Turn this error into something nicer and more // meaningful. (io.EOF is often used as a signal for the legitimate end // of an input stream.) if p.err != nil && errors.Is(p.err, io.EOF) { p.parseError("unexpected end of input stream") } return p.metricFamiliesByName, p.err } func (p TextParser) reset(in io.Reader) { p.metricFamiliesByName = map[string]dto.MetricFamily{} if p.buf == nil { p.buf = bufio.NewReader(in) } else { p.buf.Reset(in) } p.err = nil p.lineCount = 0 if p.summaries == nil \|\| len(p.summaries) > 0 { p.summaries = map[uint64]dto.Metric{} } if p.histograms == nil \|\| len(p.histograms) > 0 { p.histograms = map[uint64]dto.Metric{} } p.currentQuantile = math.NaN() p.currentBucket = math.NaN() p.currentMF = nil } // startOfLine represents the state where the next byte read from p.buf is the // start of a line (or whitespace leading up to it). func (p TextParser) startOfLine() stateFn { p.lineCount++ p.currentMetricIsInsideBraces = false p.currentMetricInsideBracesIsPresent = false if p.skipBlankTab(); p.err != nil { // This is the only place that we expect to see io.EOF, // which is not an error but the signal that we are done. // Any other error that happens to align with the start of // a line is still an error. if errors.Is(p.err, io.EOF) { p.err = nil } return nil } switch p.currentByte { case '#': return p.startComment case '\n': return p.startOfLine // Empty line, start the next one. case '{': p.currentMetricIsInsideBraces = true return p.readingLabels } return p.readingMetricName } // startComment represents the state where the next byte read from p.buf is the // start of a comment (or whitespace leading up to it). func (p TextParser) startComment() stateFn { if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte == '\n' { return p.startOfLine } if p.readTokenUntilWhitespace(); p.err != nil { return nil // Unexpected end of input. } // If we have hit the end of line already, there is nothing left // to do. This is not considered a syntax error. if p.currentByte == '\n' { return p.startOfLine } keyword := p.currentToken.String() if keyword != "HELP" && keyword != "TYPE" { // Generic comment, ignore by fast forwarding to end of line. for p.currentByte != '\n' { if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil { return nil // Unexpected end of input. } } return p.startOfLine } // There is something. Next has to be a metric name. if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.readTokenAsMetricName(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte == '\n' { // At the end of the line already. // Again, this is not considered a syntax error. return p.startOfLine } if !isBlankOrTab(p.currentByte) { p.parseError("invalid metric name in comment") return nil } p.setOrCreateCurrentMF() if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte == '\n' { // At the end of the line already. // Again, this is not considered a syntax error. return p.startOfLine } switch keyword { case "HELP": return p.readingHelp case "TYPE": return p.readingType } panic(fmt.Sprintf("code error: unexpected keyword %q", keyword)) } // readingMetricName represents the state where the last byte read (now in // p.currentByte) is the first byte of a metric name. func (p TextParser) readingMetricName() stateFn { if p.readTokenAsMetricName(); p.err != nil { return nil } if p.currentToken.Len() == 0 { p.parseError("invalid metric name") return nil } p.setOrCreateCurrentMF() // Now is the time to fix the type if it hasn't happened yet. if p.currentMF.Type == nil { p.currentMF.Type = dto.MetricType_UNTYPED.Enum() } p.currentMetric = &dto.Metric{} // Do not append the newly created currentMetric to // currentMF.Metric right now. First wait if this is a summary, // and the metric exists already, which we can only know after // having read all the labels. if p.skipBlankTabIfCurrentBlankTab(); p.err != nil { return nil // Unexpected end of input. } return p.readingLabels } // readingLabels represents the state where the last byte read (now in // p.currentByte) is either the first byte of the label set (i.e. a '{'), or the // first byte of the value (otherwise). func (p TextParser) readingLabels() stateFn { // Summaries/histograms are special. We have to reset the // currentLabels map, currentQuantile and currentBucket before starting to // read labels. if p.currentMF.GetType() == dto.MetricType_SUMMARY \|\| p.currentMF.GetType() == dto.MetricType_HISTOGRAM { p.currentLabels = map[string]string{} p.currentLabels[string(model.MetricNameLabel)] = p.currentMF.GetName() p.currentQuantile = math.NaN() p.currentBucket = math.NaN() } if p.currentByte != '{' { return p.readingValue } return p.startLabelName } // startLabelName represents the state where the next byte read from p.buf is // the start of a label name (or whitespace leading up to it). func (p TextParser) startLabelName() stateFn { if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte == '}' { p.currentMetric.Label = append(p.currentMetric.Label, p.currentLabelPairs...) p.currentLabelPairs = nil if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } return p.readingValue } if p.readTokenAsLabelName(); p.err != nil { return nil // Unexpected end of input. } if p.currentToken.Len() == 0 { p.parseError(fmt.Sprintf("invalid label name for metric %q", p.currentMF.GetName())) return nil } if p.skipBlankTabIfCurrentBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte != '=' { if p.currentMetricIsInsideBraces { if p.currentMetricInsideBracesIsPresent { p.parseError(fmt.Sprintf("multiple metric names for metric %q", p.currentMF.GetName())) return nil } switch p.currentByte { case ',': p.setOrCreateCurrentMF() if p.currentMF.Type == nil { p.currentMF.Type = dto.MetricType_UNTYPED.Enum() } p.currentMetric = &dto.Metric{} p.currentMetricInsideBracesIsPresent = true return p.startLabelName case '}': p.setOrCreateCurrentMF() if p.currentMF.Type == nil { p.currentMF.Type = dto.MetricType_UNTYPED.Enum() } p.currentMetric = &dto.Metric{} p.currentMetric.Label = append(p.currentMetric.Label, p.currentLabelPairs...) p.currentLabelPairs = nil if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } return p.readingValue default: p.parseError(fmt.Sprintf("unexpected end of metric name %q", p.currentByte)) return nil } } p.parseError(fmt.Sprintf("expected '=' after label name, found %q", p.currentByte)) p.currentLabelPairs = nil return nil } p.currentLabelPair = &dto.LabelPair{Name: proto.String(p.currentToken.String())} if p.currentLabelPair.GetName() == string(model.MetricNameLabel) { p.parseError(fmt.Sprintf("label name %q is reserved", model.MetricNameLabel)) return nil } // Special summary/histogram treatment. Don't add 'quantile' and 'le' // labels to 'real' labels. if !(p.currentMF.GetType() == dto.MetricType_SUMMARY && p.currentLabelPair.GetName() == model.QuantileLabel) && !(p.currentMF.GetType() == dto.MetricType_HISTOGRAM && p.currentLabelPair.GetName() == model.BucketLabel) { p.currentLabelPairs = append(p.currentLabelPairs, p.currentLabelPair) } // Check for duplicate label names. labels := make(map[string]struct{}) for _, l := range p.currentLabelPairs { lName := l.GetName() if _, exists := labels[lName]; !exists { labels[lName] = struct{}{} } else { p.parseError(fmt.Sprintf("duplicate label names for metric %q", p.currentMF.GetName())) p.currentLabelPairs = nil return nil } } return p.startLabelValue } // startLabelValue represents the state where the next byte read from p.buf is // the start of a (quoted) label value (or whitespace leading up to it). func (p TextParser) startLabelValue() stateFn { if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.currentByte != '"' { p.parseError(fmt.Sprintf("expected '\"' at start of label value, found %q", p.currentByte)) return nil } if p.readTokenAsLabelValue(); p.err != nil { return nil } if !model.LabelValue(p.currentToken.String()).IsValid() { p.parseError(fmt.Sprintf("invalid label value %q", p.currentToken.String())) return nil } p.currentLabelPair.Value = proto.String(p.currentToken.String()) // Special treatment of summaries: // - Quantile labels are special, will result in dto.Quantile later. // - Other labels have to be added to currentLabels for signature calculation. if p.currentMF.GetType() == dto.MetricType_SUMMARY { if p.currentLabelPair.GetName() == model.QuantileLabel { if p.currentQuantile, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil { // Create a more helpful error message. p.parseError(fmt.Sprintf("expected float as value for 'quantile' label, got %q", p.currentLabelPair.GetValue())) p.currentLabelPairs = nil return nil } } else { p.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue() } } // Similar special treatment of histograms. if p.currentMF.GetType() == dto.MetricType_HISTOGRAM { if p.currentLabelPair.GetName() == model.BucketLabel { if p.currentBucket, p.err = parseFloat(p.currentLabelPair.GetValue()); p.err != nil { // Create a more helpful error message. p.parseError(fmt.Sprintf("expected float as value for 'le' label, got %q", p.currentLabelPair.GetValue())) return nil } } else { p.currentLabels[p.currentLabelPair.GetName()] = p.currentLabelPair.GetValue() } } if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } switch p.currentByte { case ',': return p.startLabelName case '}': if p.currentMF == nil { p.parseError("invalid metric name") return nil } p.currentMetric.Label = append(p.currentMetric.Label, p.currentLabelPairs...) p.currentLabelPairs = nil if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } return p.readingValue default: p.parseError(fmt.Sprintf("unexpected end of label value %q", p.currentLabelPair.GetValue())) p.currentLabelPairs = nil return nil } } // readingValue represents the state where the last byte read (now in // p.currentByte) is the first byte of the sample value (i.e. a float). func (p TextParser) readingValue() stateFn { // When we are here, we have read all the labels, so for the // special case of a summary/histogram, we can finally find out // if the metric already exists. if p.currentMF.GetType() == dto.MetricType_SUMMARY { signature := model.LabelsToSignature(p.currentLabels) if summary := p.summaries[signature]; summary != nil { p.currentMetric = summary } else { p.summaries[signature] = p.currentMetric p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric) } } else if p.currentMF.GetType() == dto.MetricType_HISTOGRAM { signature := model.LabelsToSignature(p.currentLabels) if histogram := p.histograms[signature]; histogram != nil { p.currentMetric = histogram } else { p.histograms[signature] = p.currentMetric p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric) } } else { p.currentMF.Metric = append(p.currentMF.Metric, p.currentMetric) } if p.readTokenUntilWhitespace(); p.err != nil { return nil // Unexpected end of input. } value, err := parseFloat(p.currentToken.String()) if err != nil { // Create a more helpful error message. p.parseError(fmt.Sprintf("expected float as value, got %q", p.currentToken.String())) return nil } switch p.currentMF.GetType() { case dto.MetricType_COUNTER: p.currentMetric.Counter = &dto.Counter{Value: proto.Float64(value)} case dto.MetricType_GAUGE: p.currentMetric.Gauge = &dto.Gauge{Value: proto.Float64(value)} case dto.MetricType_UNTYPED: p.currentMetric.Untyped = &dto.Untyped{Value: proto.Float64(value)} case dto.MetricType_SUMMARY: // sigh* if p.currentMetric.Summary == nil { p.currentMetric.Summary = &dto.Summary{} } switch { case p.currentIsSummaryCount: p.currentMetric.Summary.SampleCount = proto.Uint64(uint64(value)) case p.currentIsSummarySum: p.currentMetric.Summary.SampleSum = proto.Float64(value) case !math.IsNaN(p.currentQuantile): p.currentMetric.Summary.Quantile = append( p.currentMetric.Summary.Quantile, &dto.Quantile{ Quantile: proto.Float64(p.currentQuantile), Value: proto.Float64(value), }, ) } case dto.MetricType_HISTOGRAM: // sigh if p.currentMetric.Histogram == nil { p.currentMetric.Histogram = &dto.Histogram{} } switch { case p.currentIsHistogramCount: p.currentMetric.Histogram.SampleCount = proto.Uint64(uint64(value)) case p.currentIsHistogramSum: p.currentMetric.Histogram.SampleSum = proto.Float64(value) case !math.IsNaN(p.currentBucket): p.currentMetric.Histogram.Bucket = append( p.currentMetric.Histogram.Bucket, &dto.Bucket{ UpperBound: proto.Float64(p.currentBucket), CumulativeCount: proto.Uint64(uint64(value)), }, ) } default: p.err = fmt.Errorf("unexpected type for metric name %q", p.currentMF.GetName()) } if p.currentByte == '\n' { return p.startOfLine } return p.startTimestamp } // startTimestamp represents the state where the next byte read from p.buf is // the start of the timestamp (or whitespace leading up to it). func (p TextParser) startTimestamp() stateFn { if p.skipBlankTab(); p.err != nil { return nil // Unexpected end of input. } if p.readTokenUntilWhitespace(); p.err != nil { return nil // Unexpected end of input. } timestamp, err := strconv.ParseInt(p.currentToken.String(), 10, 64) if err != nil { // Create a more helpful error message. p.parseError(fmt.Sprintf("expected integer as timestamp, got %q", p.currentToken.String())) return nil } p.currentMetric.TimestampMs = proto.Int64(timestamp) if p.readTokenUntilNewline(false); p.err != nil { return nil // Unexpected end of input. } if p.currentToken.Len() > 0 { p.parseError(fmt.Sprintf("spurious string after timestamp: %q", p.currentToken.String())) return nil } return p.startOfLine } // readingHelp represents the state where the last byte read (now in // p.currentByte) is the first byte of the docstring after 'HELP'. func (p TextParser) readingHelp() stateFn { if p.currentMF.Help != nil { p.parseError(fmt.Sprintf("second HELP line for metric name %q", p.currentMF.GetName())) return nil } // Rest of line is the docstring. if p.readTokenUntilNewline(true); p.err != nil { return nil // Unexpected end of input. } p.currentMF.Help = proto.String(p.currentToken.String()) return p.startOfLine } // readingType represents the state where the last byte read (now in // p.currentByte) is the first byte of the type hint after 'HELP'. func (p TextParser) readingType() stateFn { if p.currentMF.Type != nil { p.parseError(fmt.Sprintf("second TYPE line for metric name %q, or TYPE reported after samples", p.currentMF.GetName())) return nil } // Rest of line is the type. if p.readTokenUntilNewline(false); p.err != nil { return nil // Unexpected end of input. } metricType, ok := dto.MetricType_value[strings.ToUpper(p.currentToken.String())] if !ok { p.parseError(fmt.Sprintf("unknown metric type %q", p.currentToken.String())) return nil } p.currentMF.Type = dto.MetricType(metricType).Enum() return p.startOfLine } // parseError sets p.err to a ParseError at the current line with the given // message. func (p TextParser) parseError(msg string) { p.err = ParseError{ Line: p.lineCount, Msg: msg, } } // skipBlankTab reads (and discards) bytes from p.buf until it encounters a byte // that is neither ' ' nor '\t'. That byte is left in p.currentByte. func (p TextParser) skipBlankTab() { for { if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil \|\| !isBlankOrTab(p.currentByte) { return } } } // skipBlankTabIfCurrentBlankTab works exactly as skipBlankTab but doesn't do // anything if p.currentByte is neither ' ' nor '\t'. func (p TextParser) skipBlankTabIfCurrentBlankTab() { if isBlankOrTab(p.currentByte) { p.skipBlankTab() } } // readTokenUntilWhitespace copies bytes from p.buf into p.currentToken. The // first byte considered is the byte already read (now in p.currentByte). The // first whitespace byte encountered is still copied into p.currentByte, but not // into p.currentToken. func (p TextParser) readTokenUntilWhitespace() { p.currentToken.Reset() for p.err == nil && !isBlankOrTab(p.currentByte) && p.currentByte != '\n' { p.currentToken.WriteByte(p.currentByte) p.currentByte, p.err = p.buf.ReadByte() } } // readTokenUntilNewline copies bytes from p.buf into p.currentToken. The first // byte considered is the byte already read (now in p.currentByte). The first // newline byte encountered is still copied into p.currentByte, but not into // p.currentToken. If recognizeEscapeSequence is true, two escape sequences are // recognized: '\\' translates into '\', and '\n' into a line-feed character. // All other escape sequences are invalid and cause an error. func (p TextParser) readTokenUntilNewline(recognizeEscapeSequence bool) { p.currentToken.Reset() escaped := false for p.err == nil { if recognizeEscapeSequence && escaped { switch p.currentByte { case '\\': p.currentToken.WriteByte(p.currentByte) case 'n': p.currentToken.WriteByte('\n') case '"': p.currentToken.WriteByte('"') default: p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte)) return } escaped = false } else { switch p.currentByte { case '\n': return case '\\': escaped = true default: p.currentToken.WriteByte(p.currentByte) } } p.currentByte, p.err = p.buf.ReadByte() } } // readTokenAsMetricName copies a metric name from p.buf into p.currentToken. // The first byte considered is the byte already read (now in p.currentByte). // The first byte not part of a metric name is still copied into p.currentByte, // but not into p.currentToken. func (p TextParser) readTokenAsMetricName() { p.currentToken.Reset() // A UTF-8 metric name must be quoted and may have escaped characters. quoted := false escaped := false if !isValidMetricNameStart(p.currentByte) { return } for p.err == nil { if escaped { switch p.currentByte { case '\\': p.currentToken.WriteByte(p.currentByte) case 'n': p.currentToken.WriteByte('\n') case '"': p.currentToken.WriteByte('"') default: p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte)) return } escaped = false } else { switch p.currentByte { case '"': quoted = !quoted if !quoted { p.currentByte, p.err = p.buf.ReadByte() return } case '\n': p.parseError(fmt.Sprintf("metric name %q contains unescaped new-line", p.currentToken.String())) return case '\\': escaped = true default: p.currentToken.WriteByte(p.currentByte) } } p.currentByte, p.err = p.buf.ReadByte() if !isValidMetricNameContinuation(p.currentByte, quoted) \|\| (!quoted && p.currentByte == ' ') { return } } } // readTokenAsLabelName copies a label name from p.buf into p.currentToken. // The first byte considered is the byte already read (now in p.currentByte). // The first byte not part of a label name is still copied into p.currentByte, // but not into p.currentToken. func (p TextParser) readTokenAsLabelName() { p.currentToken.Reset() // A UTF-8 label name must be quoted and may have escaped characters. quoted := false escaped := false if !isValidLabelNameStart(p.currentByte) { return } for p.err == nil { if escaped { switch p.currentByte { case '\\': p.currentToken.WriteByte(p.currentByte) case 'n': p.currentToken.WriteByte('\n') case '"': p.currentToken.WriteByte('"') default: p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte)) return } escaped = false } else { switch p.currentByte { case '"': quoted = !quoted if !quoted { p.currentByte, p.err = p.buf.ReadByte() return } case '\n': p.parseError(fmt.Sprintf("label name %q contains unescaped new-line", p.currentToken.String())) return case '\\': escaped = true default: p.currentToken.WriteByte(p.currentByte) } } p.currentByte, p.err = p.buf.ReadByte() if !isValidLabelNameContinuation(p.currentByte, quoted) \|\| (!quoted && p.currentByte == '=') { return } } } // readTokenAsLabelValue copies a label value from p.buf into p.currentToken. // In contrast to the other 'readTokenAs...' functions, which start with the // last read byte in p.currentByte, this method ignores p.currentByte and starts // with reading a new byte from p.buf. The first byte not part of a label value // is still copied into p.currentByte, but not into p.currentToken. func (p TextParser) readTokenAsLabelValue() { p.currentToken.Reset() escaped := false for { if p.currentByte, p.err = p.buf.ReadByte(); p.err != nil { return } if escaped { switch p.currentByte { case '"', '\\': p.currentToken.WriteByte(p.currentByte) case 'n': p.currentToken.WriteByte('\n') default: p.parseError(fmt.Sprintf("invalid escape sequence '\\%c'", p.currentByte)) p.currentLabelPairs = nil return } escaped = false continue } switch p.currentByte { case '"': return case '\n': p.parseError(fmt.Sprintf("label value %q contains unescaped new-line", p.currentToken.String())) return case '\\': escaped = true default: p.currentToken.WriteByte(p.currentByte) } } } func (p TextParser) setOrCreateCurrentMF() { p.currentIsSummaryCount = false p.currentIsSummarySum = false p.currentIsHistogramCount = false p.currentIsHistogramSum = false name := p.currentToken.String() if p.currentMF = p.metricFamiliesByName[name]; p.currentMF != nil { return } // Try out if this is a _sum or _count for a summary/histogram. summaryName := summaryMetricName(name) if p.currentMF = p.metricFamiliesByName[summaryName]; p.currentMF != nil { if p.currentMF.GetType() == dto.MetricType_SUMMARY { if isCount(name) { p.currentIsSummaryCount = true } if isSum(name) { p.currentIsSummarySum = true } return } } histogramName := histogramMetricName(name) if p.currentMF = p.metricFamiliesByName[histogramName]; p.currentMF != nil { if p.currentMF.GetType() == dto.MetricType_HISTOGRAM { if isCount(name) { p.currentIsHistogramCount = true } if isSum(name) { p.currentIsHistogramSum = true } return } } p.currentMF = &dto.MetricFamily{Name: proto.String(name)} p.metricFamiliesByName[name] = p.currentMF } func isValidLabelNameStart(b byte) bool { return (b >= 'a' && b <= 'z') \|\| (b >= 'A' && b <= 'Z') \|\| b == '_' \|\| b == '"' } func isValidLabelNameContinuation(b byte, quoted bool) bool { return isValidLabelNameStart(b) \|\| (b >= '0' && b <= '9') \|\| (quoted && utf8.ValidString(string(b))) } func isValidMetricNameStart(b byte) bool { return isValidLabelNameStart(b) \|\| b == ':' } func isValidMetricNameContinuation(b byte, quoted bool) bool { return isValidLabelNameContinuation(b, quoted) \|\| b == ':' } func isBlankOrTab(b byte) bool { return b == ' ' \|\| b == '\t' } func isCount(name string) bool { return len(name) > 6 && name[len(name)-6:] == "_count" } func isSum(name string) bool { return len(name) > 4 && name[len(name)-4:] == "_sum" } func isBucket(name string) bool { return len(name) > 7 && name[len(name)-7:] == "_bucket" } func summaryMetricName(name string) string { switch { case isCount(name): return name[:len(name)-6] case isSum(name): return name[:len(name)-4] default: return name } } func histogramMetricName(name string) string { switch { case isCount(name): return name[:len(name)-6] case isSum(name): return name[:len(name)-4] case isBucket(name): return name[:len(name)-7] default: return name } } func parseFloat(s string) (float64, error) { if strings.ContainsAny(s, "pP_") { return 0, errors.New("unsupported character in float") } return strconv.ParseFloat(s, 64) }	28.99 KB	2025-05-25 12:27
📄 text_parse_test.go // Copyright 2014 The Prometheus Authors // 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 expfmt import ( "errors" "math" "strings" "testing" dto "github.com/prometheus/client_model/go" "google.golang.org/protobuf/proto" ) func testTextParse(t testing.TB) { scenarios := []struct { in string out []dto.MetricFamily }{ // 0: Empty lines as input. { in: ` `, out: []dto.MetricFamily{}, }, // 1: Minimal case. { in: ` minimal_metric 1.234 another_metric -3e3 103948 # Even that: no_labels{} 3 # HELP line for non-existing metric will be ignored. `, out: []dto.MetricFamily{ { Name: proto.String("minimal_metric"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1.234), }, }, }, }, { Name: proto.String("another_metric"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(-3e3), }, TimestampMs: proto.Int64(103948), }, }, }, { Name: proto.String("no_labels"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(3), }, }, }, }, }, }, // 2: Counters & gauges, docstrings, various whitespace, escape sequences. { in: ` # A normal comment. # # TYPE name counter name{labelname="val1",basename="basevalue"} NaN name {labelname="val2",basename="base\"v\\al\nue"} 0.23 1234567890 # HELP name two-line\n doc str\\ing # HELP name2 doc str"ing 2 # TYPE name2 gauge name2{labelname="val2" ,basename = "basevalue2" } +Inf 54321 name2{ labelname = "val1" , }-Inf `, out: []dto.MetricFamily{ { Name: proto.String("name"), Help: proto.String("two-line\n doc str\\ing"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(math.NaN()), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("base\"v\\al\nue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, { Name: proto.String("name2"), Help: proto.String("doc str\"ing 2"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue2"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, TimestampMs: proto.Int64(54321), }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(-1)), }, }, }, }, }, }, // 3: The evil summary, mixed with other types and funny comments. { in: ` # TYPE my_summary summary my_summary{n1="val1",quantile="0.5"} 110 decoy -1 -2 my_summary{n1="val1",quantile="0.9"} 140 1 my_summary_count{n1="val1"} 42 # Latest timestamp wins in case of a summary. my_summary_sum{n1="val1"} 4711 2 fake_sum{n1="val1"} 2001 # TYPE another_summary summary another_summary_count{n2="val2",n1="val1"} 20 my_summary_count{n2="val2",n1="val1"} 5 5 another_summary{n1="val1",n2="val2",quantile=".3"} -1.2 my_summary_sum{n1="val2"} 08 15 my_summary{n1="val3", quantile="0.2"} 4711 my_summary{n1="val1",n2="val2",quantile="-12.34",} NaN # some # funny comments # HELP # HELP # HELP my_summary # HELP my_summary `, out: []dto.MetricFamily{ { Name: proto.String("fake_sum"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("n1"), Value: proto.String("val1"), }, }, Untyped: &dto.Untyped{ Value: proto.Float64(2001), }, }, }, }, { Name: proto.String("decoy"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(-1), }, TimestampMs: proto.Int64(-2), }, }, }, { Name: proto.String("my_summary"), Type: dto.MetricType_SUMMARY.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("n1"), Value: proto.String("val1"), }, }, Summary: &dto.Summary{ SampleCount: proto.Uint64(42), SampleSum: proto.Float64(4711), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.5), Value: proto.Float64(110), }, { Quantile: proto.Float64(0.9), Value: proto.Float64(140), }, }, }, TimestampMs: proto.Int64(2), }, { Label: []dto.LabelPair{ { Name: proto.String("n2"), Value: proto.String("val2"), }, { Name: proto.String("n1"), Value: proto.String("val1"), }, }, Summary: &dto.Summary{ SampleCount: proto.Uint64(5), Quantile: []dto.Quantile{ { Quantile: proto.Float64(-12.34), Value: proto.Float64(math.NaN()), }, }, }, TimestampMs: proto.Int64(5), }, { Label: []dto.LabelPair{ { Name: proto.String("n1"), Value: proto.String("val2"), }, }, Summary: &dto.Summary{ SampleSum: proto.Float64(8), }, TimestampMs: proto.Int64(15), }, { Label: []dto.LabelPair{ { Name: proto.String("n1"), Value: proto.String("val3"), }, }, Summary: &dto.Summary{ Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.2), Value: proto.Float64(4711), }, }, }, }, }, }, { Name: proto.String("another_summary"), Type: dto.MetricType_SUMMARY.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("n2"), Value: proto.String("val2"), }, { Name: proto.String("n1"), Value: proto.String("val1"), }, }, Summary: &dto.Summary{ SampleCount: proto.Uint64(20), Quantile: []dto.Quantile{ { Quantile: proto.Float64(0.3), Value: proto.Float64(-1.2), }, }, }, }, }, }, }, }, // 4: The histogram. { in: ` # HELP request_duration_microseconds The response latency. # TYPE request_duration_microseconds histogram request_duration_microseconds_bucket{le="100"} 123 request_duration_microseconds_bucket{le="120"} 412 request_duration_microseconds_bucket{le="144"} 592 request_duration_microseconds_bucket{le="172.8"} 1524 request_duration_microseconds_bucket{le="+Inf"} 2693 request_duration_microseconds_sum 1.7560473e+06 request_duration_microseconds_count 2693 `, out: []dto.MetricFamily{ { Name: proto.String("request_duration_microseconds"), Help: proto.String("The response latency."), Type: dto.MetricType_HISTOGRAM.Enum(), Metric: []dto.Metric{ { Histogram: &dto.Histogram{ SampleCount: proto.Uint64(2693), SampleSum: proto.Float64(1756047.3), Bucket: []dto.Bucket{ { UpperBound: proto.Float64(100), CumulativeCount: proto.Uint64(123), }, { UpperBound: proto.Float64(120), CumulativeCount: proto.Uint64(412), }, { UpperBound: proto.Float64(144), CumulativeCount: proto.Uint64(592), }, { UpperBound: proto.Float64(172.8), CumulativeCount: proto.Uint64(1524), }, { UpperBound: proto.Float64(math.Inf(+1)), CumulativeCount: proto.Uint64(2693), }, }, }, }, }, }, }, }, // 5: Quoted metric name and quoted label name with dots. { in: ` # HELP "my.noncompliant.metric" help text # TYPE "my.noncompliant.metric" counter {"my.noncompliant.metric","label.name"="value"} 1 `, out: []dto.MetricFamily{ { Name: proto.String("my.noncompliant.metric"), Help: proto.String("help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("label.name"), Value: proto.String("value"), }, }, Counter: &dto.Counter{ Value: proto.Float64(1), }, }, }, }, }, }, // 6: Metric family with dots in name. { in: ` # HELP "name.with.dots" boring help # TYPE "name.with.dots" counter {"name.with.dots",labelname="val1",basename="basevalue"} 42.0 {"name.with.dots",labelname="val2",basename="basevalue"} 0.23 1234567890 `, out: []dto.MetricFamily{ { Name: proto.String("name.with.dots"), Help: proto.String("boring help"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val1"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("val2"), }, { Name: proto.String("basename"), Value: proto.String("basevalue"), }, }, Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, }, }, // 7: Metric family with dots in name, no labels. { in: ` # HELP "name.with.dots" boring help # TYPE "name.with.dots" counter {"name.with.dots"} 42.0 {"name.with.dots"} 0.23 1234567890 `, out: []dto.MetricFamily{ { Name: proto.String("name.with.dots"), Help: proto.String("boring help"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Counter: &dto.Counter{ Value: proto.Float64(42), }, }, { Counter: &dto.Counter{ Value: proto.Float64(.23), }, TimestampMs: proto.Int64(1234567890), }, }, }, }, }, // 8: Quoted metric name and quoted label names with dots and asterisks, special characters in label values. { in: `# HELP "gauge.name" gauge\ndoc\nstr\"ing # TYPE "gauge.name" gauge {"gauge.name","name.1"="val with\nnew line","name2"="val with \\backslash and \"quotes\""} +Inf {"gauge.name","name.1"="Björn","name2"="佖佥"} 3.14e+42 `, out: []dto.MetricFamily{ { Name: proto.String("gauge.name"), Help: proto.String("gauge\ndoc\nstr\"ing"), Type: dto.MetricType_GAUGE.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("val with\nnew line"), }, { Name: proto.String("name2"), Value: proto.String("val with \\backslash and \"quotes\""), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(math.Inf(+1)), }, }, { Label: []dto.LabelPair{ { Name: proto.String("name.1"), Value: proto.String("Björn"), }, { Name: proto.String("name2"), Value: proto.String("佖佥"), }, }, Gauge: &dto.Gauge{ Value: proto.Float64(3.14e42), }, }, }, }, }, }, // 9: Various escaped special characters in metric and label names. { in: ` # HELP "my\"noncompliant\nmetric\\" help text # TYPE "my\"noncompliant\nmetric\\" counter {"my\"noncompliant\nmetric\\","label\"name\n"="value"} 1 `, out: []dto.MetricFamily{ { Name: proto.String("my\"noncompliant\nmetric\\"), Help: proto.String("help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("label\"name\n"), Value: proto.String("value"), }, }, Counter: &dto.Counter{ Value: proto.Float64(1), }, }, }, }, }, }, // 10: Quoted metric name, not the first element in the label set. { in: ` # HELP "my.noncompliant.metric" help text # TYPE "my.noncompliant.metric" counter {labelname="value", "my.noncompliant.metric"} 1 `, out: []dto.MetricFamily{ { Name: proto.String("my.noncompliant.metric"), Help: proto.String("help text"), Type: dto.MetricType_COUNTER.Enum(), Metric: []dto.Metric{ { Label: []dto.LabelPair{ { Name: proto.String("labelname"), Value: proto.String("value"), }, }, Counter: &dto.Counter{ Value: proto.Float64(1), }, }, }, }, }, }, // 11: Multiple minimal metrics with quoted metric names. { in: ` {"name.1"} 1 {"name.2"} 1 {"name.3"} 1 `, out: []dto.MetricFamily{ { Name: proto.String("name.1"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1), }, }, }, }, { Name: proto.String("name.2"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1), }, }, }, }, { Name: proto.String("name.3"), Type: dto.MetricType_UNTYPED.Enum(), Metric: []dto.Metric{ { Untyped: &dto.Untyped{ Value: proto.Float64(1), }, }, }, }, }, }, } for i, scenario := range scenarios { out, err := parser.TextToMetricFamilies(strings.NewReader(scenario.in)) if err != nil { t.Errorf("%d. error: %s", i, err) continue } if expected, got := len(scenario.out), len(out); expected != got { t.Errorf( "%d. expected %d MetricFamilies, got %d", i, expected, got, ) } for _, expected := range scenario.out { got, ok := out[expected.GetName()] if !ok { t.Errorf( "%d. expected MetricFamily %q, found none", i, expected.GetName(), ) continue } if expected.String() != got.String() { t.Errorf( "%d. expected MetricFamily %s, got %s", i, expected, got, ) } } } } func TestTextParse(t testing.T) { testTextParse(t) } func BenchmarkTextParse(b testing.B) { for i := 0; i < b.N; i++ { testTextParse(b) } } func testTextParseError(t testing.TB) { scenarios := []struct { in string err string }{ // 0: No new-line at end of input. { in: ` bla 3.14 blubber 42`, err: "text format parsing error in line 3: unexpected end of input stream", }, // 1: Invalid escape sequence in label value. { in: `metric{label="\t"} 3.14`, err: "text format parsing error in line 1: invalid escape sequence", }, // 2: Newline in label value. { in: ` metric{label="new line"} 3.14 `, err: `text format parsing error in line 2: label value "new" contains unescaped new-line`, }, // 3: { in: `metric{@="bla"} 3.14`, err: "text format parsing error in line 1: invalid label name for metric", }, // 4: { in: `metric{__name__="bla"} 3.14`, err: `text format parsing error in line 1: label name "__name__" is reserved`, }, // 5: { in: `metric{label+="bla"} 3.14`, err: "text format parsing error in line 1: expected '=' after label name", }, // 6: { in: `metric{label=bla} 3.14`, err: "text format parsing error in line 1: expected '\"' at start of label value", }, // 7: { in: ` # TYPE metric summary metric{quantile="bla"} 3.14 `, err: "text format parsing error in line 3: expected float as value for 'quantile' label", }, // 8: { in: `metric{label="bla"+} 3.14`, err: "text format parsing error in line 1: unexpected end of label value", }, // 9: { in: `metric{label="bla"} 3.14 2.72 `, err: "text format parsing error in line 1: expected integer as timestamp", }, // 10: { in: `metric{label="bla"} 3.14 2 3 `, err: "text format parsing error in line 1: spurious string after timestamp", }, // 11: { in: `metric{label="bla"} blubb `, err: "text format parsing error in line 1: expected float as value", }, // 12: { in: ` # HELP metric one # HELP metric two `, err: "text format parsing error in line 3: second HELP line for metric name", }, // 13: { in: ` # TYPE metric counter # TYPE metric untyped `, err: `text format parsing error in line 3: second TYPE line for metric name "metric", or TYPE reported after samples`, }, // 14: { in: ` metric 4.12 # TYPE metric counter `, err: `text format parsing error in line 3: second TYPE line for metric name "metric", or TYPE reported after samples`, }, // 14: { in: ` # TYPE metric bla `, err: "text format parsing error in line 2: unknown metric type", }, // 15: { in: ` # TYPE met-ric `, err: "text format parsing error in line 2: invalid metric name in comment", }, // 16: { in: `@invalidmetric{label="bla"} 3.14 2`, err: "text format parsing error in line 1: invalid metric name", }, // 17: { in: `{label="bla"} 3.14 2`, err: "text format parsing error in line 1: invalid metric name", }, // 18: { in: ` # TYPE metric histogram metric_bucket{le="bla"} 3.14 `, err: "text format parsing error in line 3: expected float as value for 'le' label", }, // 19: Invalid UTF-8 in label value. { in: "metric{l=\"\xbd\"} 3.14\n", err: "text format parsing error in line 1: invalid label value \"\\xbd\"", }, // 20: Go 1.13 sometimes allows underscores in numbers. { in: "foo 1_2\n", err: "text format parsing error in line 1: expected float as value", }, // 21: Go 1.13 supports hex floating point. { in: "foo 0x1p-3\n", err: "text format parsing error in line 1: expected float as value", }, // 22: Check for various other literals variants, just in case. { in: "foo 0x1P-3\n", err: "text format parsing error in line 1: expected float as value", }, // 23: { in: "foo 0B1\n", err: "text format parsing error in line 1: expected float as value", }, // 24: { in: "foo 0O1\n", err: "text format parsing error in line 1: expected float as value", }, // 25: { in: "foo 0X1\n", err: "text format parsing error in line 1: expected float as value", }, // 26: { in: "foo 0x1\n", err: "text format parsing error in line 1: expected float as value", }, // 27: { in: "foo 0b1\n", err: "text format parsing error in line 1: expected float as value", }, // 28: { in: "foo 0o1\n", err: "text format parsing error in line 1: expected float as value", }, // 29: { in: "foo 0x1\n", err: "text format parsing error in line 1: expected float as value", }, // 30: { in: "foo 0x1\n", err: "text format parsing error in line 1: expected float as value", }, // 31: Check histogram label. { in: ` # TYPE metric histogram metric_bucket{le="0x1p-3"} 3.14 `, err: "text format parsing error in line 3: expected float as value for 'le' label", }, // 32: Check quantile label. { in: ` # TYPE metric summary metric{quantile="0x1p-3"} 3.14 `, err: "text format parsing error in line 3: expected float as value for 'quantile' label", }, // 33: Check duplicate label. { in: `metric{label="bla",label="bla"} 3.14`, err: "text format parsing error in line 1: duplicate label names for metric", }, // 34: Multiple quoted metric names. { in: `{"one.name","another.name"} 3.14`, err: "text format parsing error in line 1: multiple metric names", }, // 35: Invalid escape sequence in quoted metric name. { in: `{"a\xc5z",label="bla"} 3.14`, err: "text format parsing error in line 1: invalid escape sequence", }, // 36: Unexpected end of quoted metric name. { in: `{"metric.name".label="bla"} 3.14`, err: "text format parsing error in line 1: unexpected end of metric name", }, // 37: Invalid escape sequence in quoted metric name. { in: ` # TYPE "metric.name\t" counter {"metric.name\t",label="bla"} 3.14 `, err: "text format parsing error in line 2: invalid escape sequence", }, // 38: Newline in quoted metric name. { in: ` # TYPE "metric name" counter {"metric name",label="bla"} 3.14 `, err: `text format parsing error in line 2: metric name "metric" contains unescaped new-line`, }, // 39: Newline in quoted label name. { in: ` {"metric.name","new line"="bla"} 3.14 `, err: `text format parsing error in line 2: label name "new" contains unescaped new-line`, }, } for i, scenario := range scenarios { _, err := parser.TextToMetricFamilies(strings.NewReader(scenario.in)) if err == nil { t.Errorf("%d. expected error, got nil", i) continue } if expected, got := scenario.err, err.Error(); strings.Index(got, expected) != 0 { t.Errorf( "%d. expected error starting with %q, got %q", i, expected, got, ) } } } func TestTextParseError(t testing.T) { testTextParseError(t) } func BenchmarkParseError(b testing.B) { for i := 0; i < b.N; i++ { testTextParseError(b) } } func TestTextParserStartOfLine(t testing.T) { t.Run("EOF", func(t testing.T) { p := TextParser{} in := strings.NewReader("") p.reset(in) fn := p.startOfLine() if fn != nil { t.Errorf("Unexpected non-nil function: %v", fn) } if p.err != nil { t.Errorf("Unexpected error: %v", p.err) } }) t.Run("OtherError", func(t testing.T) { p := TextParser{} in := &errReader{err: errors.New("unexpected error")} p.reset(in) fn := p.startOfLine() if fn != nil { t.Errorf("Unexpected non-nil function: %v", fn) } if p.err != nil && !errors.Is(p.err, in.err) { t.Errorf("Unexpected error: %v, expected %v", p.err, in.err) } }) } type errReader struct { err error } func (r errReader) Read(p []byte) (int, error) { return 0, r.err }	23.23 KB	2025-05-25 12:27

Terminal