mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2024-11-14 01:24:04 -08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
prometheus/model/textparse/protobufparse_test.go

2545 lines
62 KiB
Go
Raw Normal View History

Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
// Copyright 2021 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 textparse
import (
"bytes"
"encoding/binary"
"testing"
"github.com/gogo/protobuf/proto"
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
"github.com/prometheus/common/model"
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
"github.com/stretchr/testify/require"
Merge branch 'main' into sparsehistogram
2021-11-17 10:57:31 -08:00
"github.com/prometheus/prometheus/model/exemplar"
Style cleanup of all the changes in sparsehistogram so far A lot of this code was hacked together, literally during a hackathon. This commit intends not to change the code substantially, but just make the code obey the usual style practices. A (possibly incomplete) list of areas: * Generally address linter warnings. * The `pgk` directory is deprecated as per dev-summit. No new packages should be added to it. I moved the new `pkg/histogram` package to `model` anticipating what's proposed in #9478. * Make the naming of the Sparse Histogram more consistent. Including abbreviations, there were just too many names for it: SparseHistogram, Histogram, Histo, hist, his, shs, h. The idea is to call it "Histogram" in general. Only add "Sparse" if it is needed to avoid confusion with conventional Histograms (which is rare because the TSDB really has no notion of conventional Histograms). Use abbreviations only in local scope, and then really abbreviate (not just removing three out of seven letters like in "Histo"). This is in the spirit of https://github.com/golang/go/wiki/CodeReviewComments#variable-names * Several other minor name changes. * A lot of formatting of doc comments. For one, following https://github.com/golang/go/wiki/CodeReviewComments#comment-sentences , but also layout question, anticipating how things will look like when rendered by `godoc` (even where `godoc` doesn't render them right now because they are for unexported types or not a doc comment at all but just a normal code comment - consistency is queen!). * Re-enabled `TestQueryLog` and `TestEndopints` (they pass now, leaving them disabled was presumably an oversight). * Bucket iterator for histogram.Histogram is now created with a method. * HistogramChunk.iterator now allows iterator recycling. (I think @dieterbe only commented it out because he was confused by the question in the comment.) * HistogramAppender.Append panics now because we decided to treat staleness marker differently. Signed-off-by: beorn7 <beorn@grafana.com>
2021-10-09 06:57:07 -07:00
"github.com/prometheus/prometheus/model/histogram"
Merge branch 'main' into sparsehistogram
2021-11-17 10:57:31 -08:00
"github.com/prometheus/prometheus/model/labels"
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
dto "github.com/prometheus/prometheus/prompb/io/prometheus/client"
)
textparse: Refactored benchmark (#15083) * textparse: Refactored benchmark. Signed-off-by: bwplotka <bwplotka@gmail.com> * Kill sinks, tested, nothing is inlined. Signed-off-by: bwplotka <bwplotka@gmail.com> * Addressed comments. Signed-off-by: bwplotka <bwplotka@gmail.com> --------- Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 01:55:26 -07:00
func createTestProtoBuf(t testing.TB) *bytes.Buffer {
t.Helper()
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
testMetricFamilies := []string{
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
`name: "go_build_info"
help: "Build information about the main Go module."
type: GAUGE
metric: <
label: <
name: "checksum"
value: ""
>
label: <
name: "path"
value: "github.com/prometheus/client_golang"
>
label: <
name: "version"
value: "(devel)"
>
gauge: <
value: 1
>
>
`,
`name: "go_memstats_alloc_bytes_total"
help: "Total number of bytes allocated, even if freed."
type: COUNTER
Go on adding protobuf parsing for unit Signed-off-by: Arianna Vespri <arianna.vespri@yahoo.it>
2023-12-14 08:00:52 -08:00
unit: "bytes"
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
metric: <
counter: <
value: 1.546544e+06
exemplar: <
label: <
name: "dummyID"
value: "42"
>
value: 12
timestamp: <
seconds: 1625851151
nanos: 233181499
>
>
>
>
`,
`name: "something_untyped"
help: "Just to test the untyped type."
type: UNTYPED
metric: <
untyped: <
value: 42
>
timestamp_ms: 1234567
>
`,
`name: "test_histogram"
help: "Test histogram with many buckets removed to keep it manageable in size."
type: HISTOGRAM
metric: <
histogram: <
sample_count: 175
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count: 2
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count: 4
upper_bound: -0.0003899999999999998
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
value: -0.00039
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
bucket: <
cumulative_count: 16
upper_bound: -0.0002899999999999998
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
value: -0.00029
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
>
histograms: Move to new exposition protobuf format This is an incompatible protobuf change. Instrumented targets must include https://github.com/prometheus/client_golang/pull/1092 to make this work. Signed-off-by: beorn7 <beorn@grafana.com>
2022-07-19 09:11:33 -07:00
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count: 2
negative_span: <
offset: -162
length: 1
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
histograms: Move to new exposition protobuf format This is an incompatible protobuf change. Instrumented targets must include https://github.com/prometheus/client_golang/pull/1092 to make this work. Signed-off-by: beorn7 <beorn@grafana.com>
2022-07-19 09:11:33 -07:00
negative_span: <
offset: 23
length: 4
>
negative_delta: 1
negative_delta: 3
negative_delta: -2
negative_delta: -1
negative_delta: 1
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
histograms: Move to new exposition protobuf format This is an incompatible protobuf change. Instrumented targets must include https://github.com/prometheus/client_golang/pull/1092 to make this work. Signed-off-by: beorn7 <beorn@grafana.com>
2022-07-19 09:11:33 -07:00
positive_delta: 1
positive_delta: 2
positive_delta: -1
positive_delta: -1
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
timestamp_ms: 1234568
>
histograms: parse float histograms from proto definition (#11149) * histograms: parse float histograms from proto definition Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Improve comment Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Ignore float buckets Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Refactor Histogram() function Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Fix test_float_histogram Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Update model/textparse/protobufparse.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update protobufparse.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape/scrape.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Signed-off-by: Marc Tuduri <marctc@protonmail.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com>
2022-08-25 08:07:41 -07:00
`,
textparse: Add tests for float and gauge histograms Signed-off-by: beorn7 <beorn@grafana.com>
2023-01-10 09:42:05 -08:00
`name: "test_gauge_histogram"
help: "Like test_histogram but as gauge histogram."
type: GAUGE_HISTOGRAM
metric: <
histogram: <
sample_count: 175
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count: 2
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count: 4
upper_bound: -0.0003899999999999998
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
bucket: <
cumulative_count: 16
upper_bound: -0.0002899999999999998
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
value: -0.00029
>
>
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count: 2
negative_span: <
offset: -162
length: 1
>
negative_span: <
offset: 23
length: 4
>
negative_delta: 1
negative_delta: 3
negative_delta: -2
negative_delta: -1
negative_delta: 1
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
>
positive_delta: 1
positive_delta: 2
positive_delta: -1
positive_delta: -1
>
timestamp_ms: 1234568
>
histograms: parse float histograms from proto definition (#11149) * histograms: parse float histograms from proto definition Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Improve comment Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Ignore float buckets Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Refactor Histogram() function Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Fix test_float_histogram Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Update model/textparse/protobufparse.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update protobufparse.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape/scrape.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Signed-off-by: Marc Tuduri <marctc@protonmail.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com>
2022-08-25 08:07:41 -07:00
textparse: Add tests for float and gauge histograms Signed-off-by: beorn7 <beorn@grafana.com>
2023-01-10 09:42:05 -08:00
`,
histograms: parse float histograms from proto definition (#11149) * histograms: parse float histograms from proto definition Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Improve comment Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Ignore float buckets Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Refactor Histogram() function Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Fix test_float_histogram Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Update model/textparse/protobufparse.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update protobufparse.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape/scrape.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Signed-off-by: Marc Tuduri <marctc@protonmail.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com>
2022-08-25 08:07:41 -07:00
`name: "test_float_histogram"
help: "Test float histogram with many buckets removed to keep it manageable in size."
type: HISTOGRAM
metric: <
histogram: <
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
sample_count_float: 175.0
histograms: parse float histograms from proto definition (#11149) * histograms: parse float histograms from proto definition Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Improve comment Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Ignore float buckets Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Refactor Histogram() function Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Fix test_float_histogram Signed-off-by: Marc Tuduri <marctc@protonmail.com> * Update model/textparse/protobufparse.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update protobufparse.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape.go Signed-off-by: Marc Tudurí <marctc@protonmail.com> * Update scrape/scrape.go Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Signed-off-by: Marc Tuduri <marctc@protonmail.com> Signed-off-by: Marc Tudurí <marctc@protonmail.com> Co-authored-by: Ganesh Vernekar <15064823+codesome@users.noreply.github.com>
2022-08-25 08:07:41 -07:00
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count_float: 2.0
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count_float: 4.0
upper_bound: -0.0003899999999999998
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
bucket: <
cumulative_count_float: 16
upper_bound: -0.0002899999999999998
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
value: -0.00029
>
>
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count_float: 2.0
negative_span: <
offset: -162
length: 1
>
negative_span: <
offset: 23
length: 4
>
negative_count: 1.0
negative_count: 3.0
negative_count: -2.0
negative_count: -1.0
negative_count: 1.0
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
>
positive_count: 1.0
positive_count: 2.0
positive_count: -1.0
positive_count: -1.0
>
timestamp_ms: 1234568
>
textparse: Add tests for float and gauge histograms Signed-off-by: beorn7 <beorn@grafana.com>
2023-01-10 09:42:05 -08:00
`,
`name: "test_gauge_float_histogram"
help: "Like test_float_histogram but as gauge histogram."
type: GAUGE_HISTOGRAM
metric: <
histogram: <
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
sample_count_float: 175.0
textparse: Add tests for float and gauge histograms Signed-off-by: beorn7 <beorn@grafana.com>
2023-01-10 09:42:05 -08:00
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count_float: 2.0
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count_float: 4.0
upper_bound: -0.0003899999999999998
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
bucket: <
cumulative_count_float: 16
upper_bound: -0.0002899999999999998
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
value: -0.00029
>
>
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count_float: 2.0
negative_span: <
offset: -162
length: 1
>
negative_span: <
offset: 23
length: 4
>
negative_count: 1.0
negative_count: 3.0
negative_count: -2.0
negative_count: -1.0
negative_count: 1.0
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
>
positive_count: 1.0
positive_count: 2.0
positive_count: -1.0
positive_count: -1.0
>
timestamp_ms: 1234568
>
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
`,
`name: "test_histogram2"
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
help: "Similar histogram as before but now without sparse buckets."
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
type: HISTOGRAM
metric: <
histogram: <
sample_count: 175
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
sample_sum: 0.000828
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
bucket: <
cumulative_count: 2
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
upper_bound: -0.00048
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
bucket: <
cumulative_count: 4
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
upper_bound: -0.00038
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
value: -0.00038
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
timestamp: <
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
seconds: 1625851153
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
nanos: 146848499
>
>
>
bucket: <
cumulative_count: 16
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
upper_bound: 1
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
value: -0.000295
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
>
histograms: Move to new exposition protobuf format This is an incompatible protobuf change. Instrumented targets must include https://github.com/prometheus/client_golang/pull/1092 to make this work. Signed-off-by: beorn7 <beorn@grafana.com>
2022-07-19 09:11:33 -07:00
schema: 0
zero_threshold: 0
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
>
>
feat: ProtobufParse.formatOpenMetricsFloat: improve float formatting by using strconv.AppendFloat instead of fmt.Sprint Signed-off-by: machine424 <ayoubmrini424@gmail.com>
2024-10-15 08:28:56 -07:00
`,
`name: "test_histogram3"
help: "Similar histogram as before but now with integer buckets."
type: HISTOGRAM
metric: <
histogram: <
sample_count: 6
sample_sum: 50
bucket: <
cumulative_count: 2
upper_bound: -20
>
bucket: <
cumulative_count: 4
upper_bound: 20
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
value: 15
timestamp: <
seconds: 1625851153
nanos: 146848499
>
>
>
bucket: <
cumulative_count: 6
upper_bound: 30
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
value: 25
>
>
schema: 0
zero_threshold: 0
>
>
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
`,
`name: "test_histogram_family"
help: "Test histogram metric family with two very simple histograms."
type: HISTOGRAM
metric: <
label: <
name: "foo"
value: "bar"
>
histogram: <
sample_count: 5
sample_sum: 12.1
bucket: <
cumulative_count: 2
upper_bound: 1.1
>
bucket: <
cumulative_count: 3
upper_bound: 2.2
>
schema: 3
positive_span: <
offset: 8
length: 2
>
positive_delta: 2
positive_delta: 1
>
>
metric: <
label: <
name: "foo"
value: "baz"
>
histogram: <
sample_count: 6
sample_sum: 13.1
bucket: <
cumulative_count: 1
upper_bound: 1.1
>
bucket: <
cumulative_count: 5
upper_bound: 2.2
>
schema: 3
positive_span: <
offset: 8
length: 2
>
positive_delta: 1
positive_delta: 4
>
>
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
`,
`name: "test_float_histogram_with_zerothreshold_zero"
help: "Test float histogram with a zero threshold of zero."
type: HISTOGRAM
metric: <
histogram: <
sample_count_float: 5.0
sample_sum: 12.1
schema: 3
positive_span: <
offset: 8
length: 2
>
positive_count: 2.0
positive_count: 3.0
>
>
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
`,
`name: "rpc_durations_seconds"
help: "RPC latency distributions."
type: SUMMARY
metric: <
label: <
name: "service"
value: "exponential"
>
summary: <
sample_count: 262
sample_sum: 0.00025551262820703587
quantile: <
quantile: 0.5
value: 6.442786329648548e-07
>
quantile: <
quantile: 0.9
value: 1.9435742936658396e-06
>
quantile: <
quantile: 0.99
value: 4.0471608667037015e-06
>
>
>
Fix protobuf parsing of quantile-less summaries (#9277) Signed-off-by: beorn7 <beorn@grafana.com>
2021-08-30 22:17:57 -07:00
`,
`name: "without_quantiles"
help: "A summary without quantiles."
type: SUMMARY
metric: <
summary: <
sample_count: 42
sample_sum: 1.234
>
>
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
`,
`name: "empty_histogram"
help: "A histogram without observations and with a zero threshold of zero but with a no-op span to identify it as a native histogram."
type: HISTOGRAM
metric: <
histogram: <
positive_span: <
offset: 0
length: 0
>
>
>
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
`,
`name: "test_counter_with_createdtimestamp"
help: "A counter with a created timestamp."
type: COUNTER
metric: <
counter: <
value: 42
created_timestamp: <
seconds: 1
nanos: 1
>
>
>
`,
`name: "test_summary_with_createdtimestamp"
help: "A summary with a created timestamp."
type: SUMMARY
metric: <
summary: <
sample_count: 42
sample_sum: 1.234
created_timestamp: <
seconds: 1
nanos: 1
>
>
>
`,
`name: "test_histogram_with_createdtimestamp"
help: "A histogram with a created timestamp."
type: HISTOGRAM
metric: <
histogram: <
created_timestamp: <
seconds: 1
nanos: 1
>
positive_span: <
offset: 0
length: 0
>
>
>
`,
`name: "test_gaugehistogram_with_createdtimestamp"
help: "A gauge histogram with a created timestamp."
type: GAUGE_HISTOGRAM
metric: <
histogram: <
created_timestamp: <
seconds: 1
nanos: 1
>
positive_span: <
offset: 0
length: 0
>
>
>
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
`,
`name: "test_histogram_with_native_histogram_exemplars"
help: "A histogram with native histogram exemplars."
type: HISTOGRAM
metric: <
histogram: <
sample_count: 175
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count: 2
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count: 4
upper_bound: -0.0003899999999999998
exemplar: <
label: <
name: "dummyID"
value: "59727"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
bucket: <
cumulative_count: 16
upper_bound: -0.0002899999999999998
exemplar: <
label: <
name: "dummyID"
value: "5617"
>
value: -0.00029
>
>
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count: 2
negative_span: <
offset: -162
length: 1
>
negative_span: <
offset: 23
length: 4
>
negative_delta: 1
negative_delta: 3
negative_delta: -2
negative_delta: -1
negative_delta: 1
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
>
positive_delta: 1
positive_delta: 2
positive_delta: -1
positive_delta: -1
exemplars: <
label: <
name: "dummyID"
value: "59780"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
exemplars: <
label: <
name: "dummyID"
value: "5617"
>
value: -0.00029
>
exemplars: <
label: <
name: "dummyID"
value: "59772"
>
value: -0.00052
timestamp: <
seconds: 1625851160
nanos: 156848499
>
>
>
timestamp_ms: 1234568
>
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
`,
`name: "test_histogram_with_native_histogram_exemplars2"
help: "Another histogram with native histogram exemplars."
type: HISTOGRAM
metric: <
histogram: <
sample_count: 175
sample_sum: 0.0008280461746287094
bucket: <
cumulative_count: 2
upper_bound: -0.0004899999999999998
>
bucket: <
cumulative_count: 4
upper_bound: -0.0003899999999999998
>
bucket: <
cumulative_count: 16
upper_bound: -0.0002899999999999998
>
schema: 3
zero_threshold: 2.938735877055719e-39
zero_count: 2
negative_span: <
offset: -162
length: 1
>
negative_span: <
offset: 23
length: 4
>
negative_delta: 1
negative_delta: 3
negative_delta: -2
negative_delta: -1
negative_delta: 1
positive_span: <
offset: -161
length: 1
>
positive_span: <
offset: 8
length: 3
>
positive_delta: 1
positive_delta: 2
positive_delta: -1
positive_delta: -1
exemplars: <
label: <
name: "dummyID"
value: "59780"
>
value: -0.00039
timestamp: <
seconds: 1625851155
nanos: 146848499
>
>
>
timestamp_ms: 1234568
>
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
`,
}
varintBuf := make([]byte, binary.MaxVarintLen32)
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
buf := &bytes.Buffer{}
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
for _, tmf := range testMetricFamilies {
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
pb := &dto.MetricFamily{}
// From text to proto message.
require.NoError(t, proto.UnmarshalText(tmf, pb))
// From proto message to binary protobuf.
protoBuf, err := proto.Marshal(pb)
require.NoError(t, err)
// Write first length, then binary protobuf.
varintLength := binary.PutUvarint(varintBuf, uint64(len(protoBuf)))
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
buf.Write(varintBuf[:varintLength])
buf.Write(protoBuf)
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
}
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
return buf
}
func TestProtobufParse(t *testing.T) {
inputBuf := createTestProtoBuf(t)
scenarios := []struct {
name string
parser Parser
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
expected []parsedEntry
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
}{
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
name: "ignore classic buckets of native histograms",
model/textparse: parsers take a labels SymbolTable This allows strings to be interned to save memory. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-03-25 06:31:24 -07:00
parser: NewProtobufParser(inputBuf.Bytes(), false, labels.NewSymbolTable()),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
expected: []parsedEntry{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{
m: "go_build_info",
help: "Build information about the main Go module.",
},
{
m: "go_build_info",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGauge,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "go_build_info\xFFchecksum\xFF\xFFpath\xFFgithub.com/prometheus/client_golang\xFFversion\xFF(devel)",
v: 1,
lset: labels.FromStrings(
"__name__", "go_build_info",
"checksum", "",
"path", "github.com/prometheus/client_golang",
"version", "(devel)",
),
},
{
m: "go_memstats_alloc_bytes_total",
help: "Total number of bytes allocated, even if freed.",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
},
{
m: "go_memstats_alloc_bytes_total",
Go on adding protobuf parsing for unit Signed-off-by: Arianna Vespri <arianna.vespri@yahoo.it>
2023-12-14 08:00:52 -08:00
unit: "bytes",
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "go_memstats_alloc_bytes_total",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeCounter,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "go_memstats_alloc_bytes_total",
v: 1.546544e+06,
lset: labels.FromStrings(
"__name__", "go_memstats_alloc_bytes_total",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "42"), Value: 12, HasTs: true, Ts: 1625851151233},
},
},
{
m: "something_untyped",
help: "Just to test the untyped type.",
},
{
m: "something_untyped",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeUnknown,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "something_untyped",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234567),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 42,
lset: labels.FromStrings(
"__name__", "something_untyped",
),
},
{
m: "test_histogram",
help: "Test histogram with many buckets removed to keep it manageable in size.",
},
{
m: "test_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "test_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
{
m: "test_gauge_histogram",
help: "Like test_histogram but as gauge histogram.",
},
{
m: "test_gauge_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "test_gauge_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.GaugeType,
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_gauge_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
{
m: "test_float_histogram",
help: "Test float histogram with many buckets removed to keep it manageable in size.",
},
{
m: "test_float_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "test_float_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
fhs: &histogram.FloatHistogram{
Count: 175.0,
ZeroCount: 2.0,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []float64{1.0, 2.0, -1.0, -1.0},
NegativeBuckets: []float64{1.0, 3.0, -2.0, -1.0, 1.0},
},
lset: labels.FromStrings(
"__name__", "test_float_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
{
m: "test_gauge_float_histogram",
help: "Like test_float_histogram but as gauge histogram.",
},
{
m: "test_gauge_float_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "test_gauge_float_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
fhs: &histogram.FloatHistogram{
CounterResetHint: histogram.GaugeType,
Count: 175.0,
ZeroCount: 2.0,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []float64{1.0, 2.0, -1.0, -1.0},
NegativeBuckets: []float64{1.0, 3.0, -2.0, -1.0, 1.0},
},
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
{
m: "test_histogram2",
help: "Similar histogram as before but now without sparse buckets.",
},
{
m: "test_histogram2",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "test_histogram2_count",
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram2_count",
),
},
{
m: "test_histogram2_sum",
v: 0.000828,
lset: labels.FromStrings(
"__name__", "test_histogram2_sum",
),
},
{
m: "test_histogram2_bucket\xffle\xff-0.00048",
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "-0.00048",
),
},
{
m: "test_histogram2_bucket\xffle\xff-0.00038",
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "-0.00038",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00038, HasTs: true, Ts: 1625851153146},
},
},
{
m: "test_histogram2_bucket\xffle\xff1.0",
v: 16,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "1.0",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.000295, HasTs: false},
},
},
{
m: "test_histogram2_bucket\xffle\xff+Inf",
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "+Inf",
),
},
feat: ProtobufParse.formatOpenMetricsFloat: improve float formatting by using strconv.AppendFloat instead of fmt.Sprint Signed-off-by: machine424 <ayoubmrini424@gmail.com>
2024-10-15 08:28:56 -07:00
{
m: "test_histogram3",
help: "Similar histogram as before but now with integer buckets.",
},
{
m: "test_histogram3",
typ: model.MetricTypeHistogram,
},
{
m: "test_histogram3_count",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_count",
),
},
{
m: "test_histogram3_sum",
v: 50,
lset: labels.FromStrings(
"__name__", "test_histogram3_sum",
),
},
{
m: "test_histogram3_bucket\xffle\xff-20.0",
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "-20.0",
),
},
{
m: "test_histogram3_bucket\xffle\xff20.0",
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "20.0",
),
es: []exemplar.Exemplar{
{Labels: labels.FromStrings("dummyID", "59727"), Value: 15, HasTs: true, Ts: 1625851153146},
},
},
{
m: "test_histogram3_bucket\xffle\xff30.0",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "30.0",
),
es: []exemplar.Exemplar{
{Labels: labels.FromStrings("dummyID", "5617"), Value: 25, HasTs: false},
},
},
{
m: "test_histogram3_bucket\xffle\xff+Inf",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "+Inf",
),
},
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
{
m: "test_histogram_family",
help: "Test histogram metric family with two very simple histograms.",
},
{
m: "test_histogram_family",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
},
{
m: "test_histogram_family\xfffoo\xffbar",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
Count: 5,
Sum: 12.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
NegativeSpans: []histogram.Span{},
PositiveBuckets: []int64{2, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_family",
"foo", "bar",
),
},
{
m: "test_histogram_family\xfffoo\xffbaz",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
Count: 6,
Sum: 13.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
NegativeSpans: []histogram.Span{},
PositiveBuckets: []int64{1, 4},
},
lset: labels.FromStrings(
"__name__", "test_histogram_family",
"foo", "baz",
),
},
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
{
m: "test_float_histogram_with_zerothreshold_zero",
help: "Test float histogram with a zero threshold of zero.",
},
{
m: "test_float_histogram_with_zerothreshold_zero",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
},
{
m: "test_float_histogram_with_zerothreshold_zero",
fhs: &histogram.FloatHistogram{
Count: 5.0,
Sum: 12.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
PositiveBuckets: []float64{2.0, 3.0},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_float_histogram_with_zerothreshold_zero",
),
},
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{
m: "rpc_durations_seconds",
help: "RPC latency distributions.",
},
{
m: "rpc_durations_seconds",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "rpc_durations_seconds_count\xffservice\xffexponential",
v: 262,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds_count",
"service", "exponential",
),
},
{
m: "rpc_durations_seconds_sum\xffservice\xffexponential",
v: 0.00025551262820703587,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds_sum",
"service", "exponential",
),
},
{
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.5",
v: 6.442786329648548e-07,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.5",
"service", "exponential",
),
},
{
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.9",
v: 1.9435742936658396e-06,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.9",
"service", "exponential",
),
},
{
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.99",
v: 4.0471608667037015e-06,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.99",
"service", "exponential",
),
},
{
m: "without_quantiles",
help: "A summary without quantiles.",
},
{
m: "without_quantiles",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
{
m: "without_quantiles_count",
v: 42,
lset: labels.FromStrings(
"__name__", "without_quantiles_count",
),
},
{
m: "without_quantiles_sum",
v: 1.234,
lset: labels.FromStrings(
"__name__", "without_quantiles_sum",
),
},
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
{
m: "empty_histogram",
help: "A histogram without observations and with a zero threshold of zero but with a no-op span to identify it as a native histogram.",
},
{
m: "empty_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
},
{
m: "empty_histogram",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "empty_histogram",
),
},
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
{
m: "test_counter_with_createdtimestamp",
help: "A counter with a created timestamp.",
},
{
m: "test_counter_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeCounter,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
{
m: "test_counter_with_createdtimestamp",
v: 42,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_counter_with_createdtimestamp",
),
},
{
m: "test_summary_with_createdtimestamp",
help: "A summary with a created timestamp.",
},
{
m: "test_summary_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
{
m: "test_summary_with_createdtimestamp_count",
v: 42,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_summary_with_createdtimestamp_count",
),
},
{
m: "test_summary_with_createdtimestamp_sum",
v: 1.234,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_summary_with_createdtimestamp_sum",
),
},
{
m: "test_histogram_with_createdtimestamp",
help: "A histogram with a created timestamp.",
},
{
m: "test_histogram_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
{
m: "test_histogram_with_createdtimestamp",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_createdtimestamp",
),
},
{
m: "test_gaugehistogram_with_createdtimestamp",
help: "A gauge histogram with a created timestamp.",
},
{
m: "test_gaugehistogram_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
{
m: "test_gaugehistogram_with_createdtimestamp",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.GaugeType,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_gaugehistogram_with_createdtimestamp",
),
},
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
{
m: "test_histogram_with_native_histogram_exemplars",
help: "A histogram with native histogram exemplars.",
},
{
m: "test_histogram_with_native_histogram_exemplars",
typ: model.MetricTypeHistogram,
},
{
m: "test_histogram_with_native_histogram_exemplars",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
{Labels: labels.FromStrings("dummyID", "59780"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
{Labels: labels.FromStrings("dummyID", "59772"), Value: -0.00052, HasTs: true, Ts: 1625851160156},
},
},
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
{
m: "test_histogram_with_native_histogram_exemplars2",
help: "Another histogram with native histogram exemplars.",
},
{
m: "test_histogram_with_native_histogram_exemplars2",
typ: model.MetricTypeHistogram,
},
{
m: "test_histogram_with_native_histogram_exemplars2",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
{Labels: labels.FromStrings("dummyID", "59780"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
},
},
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
name: "parse classic and native buckets",
model/textparse: parsers take a labels SymbolTable This allows strings to be interned to save memory. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-03-25 06:31:24 -07:00
parser: NewProtobufParser(inputBuf.Bytes(), true, labels.NewSymbolTable()),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
expected: []parsedEntry{
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_build_info",
help: "Build information about the main Go module.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_build_info",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGauge,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_build_info\xFFchecksum\xFF\xFFpath\xFFgithub.com/prometheus/client_golang\xFFversion\xFF(devel)",
v: 1,
lset: labels.FromStrings(
"__name__", "go_build_info",
"checksum", "",
"path", "github.com/prometheus/client_golang",
"version", "(devel)",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_memstats_alloc_bytes_total",
help: "Total number of bytes allocated, even if freed.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
m: "go_memstats_alloc_bytes_total",
unit: "bytes",
},
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_memstats_alloc_bytes_total",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeCounter,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "go_memstats_alloc_bytes_total",
v: 1.546544e+06,
lset: labels.FromStrings(
"__name__", "go_memstats_alloc_bytes_total",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "42"), Value: 12, HasTs: true, Ts: 1625851151233},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "something_untyped",
help: "Just to test the untyped type.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "something_untyped",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeUnknown,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "something_untyped",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234567),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 42,
lset: labels.FromStrings(
"__name__", "something_untyped",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram",
help: "Test histogram with many buckets removed to keep it manageable in size.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_histogram_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram_bucket",
"le", "-0.0003899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_histogram_bucket",
"le", "-0.0002899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.00029, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram",
help: "Like test_histogram but as gauge histogram.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.GaugeType,
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_gauge_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_bucket",
"le", "-0.0003899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_bucket",
"le", "-0.0002899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.00029, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_histogram_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_gauge_histogram_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram",
help: "Test float histogram with many buckets removed to keep it manageable in size.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
fhs: &histogram.FloatHistogram{
Count: 175.0,
ZeroCount: 2.0,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []float64{1.0, 2.0, -1.0, -1.0},
NegativeBuckets: []float64{1.0, 3.0, -2.0, -1.0, 1.0},
},
lset: labels.FromStrings(
"__name__", "test_float_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_float_histogram_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_float_histogram_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_float_histogram_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_float_histogram_bucket",
"le", "-0.0003899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_float_histogram_bucket",
"le", "-0.0002899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.00029, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_float_histogram_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_float_histogram_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram",
help: "Like test_float_histogram but as gauge histogram.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
fhs: &histogram.FloatHistogram{
CounterResetHint: histogram.GaugeType,
Count: 175.0,
ZeroCount: 2.0,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []float64{1.0, 2.0, -1.0, -1.0},
NegativeBuckets: []float64{1.0, 3.0, -2.0, -1.0, 1.0},
},
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_bucket",
"le", "-0.0003899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_bucket",
"le", "-0.0002899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.00029, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_gauge_float_histogram_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_gauge_float_histogram_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2",
help: "Similar histogram as before but now without sparse buckets.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_count",
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram2_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_sum",
v: 0.000828,
lset: labels.FromStrings(
"__name__", "test_histogram2_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_bucket\xffle\xff-0.00048",
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "-0.00048",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_bucket\xffle\xff-0.00038",
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "-0.00038",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00038, HasTs: true, Ts: 1625851153146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_bucket\xffle\xff1.0",
v: 16,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "1.0",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.000295, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "test_histogram2_bucket\xffle\xff+Inf",
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram2_bucket",
"le", "+Inf",
),
},
feat: ProtobufParse.formatOpenMetricsFloat: improve float formatting by using strconv.AppendFloat instead of fmt.Sprint Signed-off-by: machine424 <ayoubmrini424@gmail.com>
2024-10-15 08:28:56 -07:00
{
m: "test_histogram3",
help: "Similar histogram as before but now with integer buckets.",
},
{
m: "test_histogram3",
typ: model.MetricTypeHistogram,
},
{
m: "test_histogram3_count",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_count",
),
},
{
m: "test_histogram3_sum",
v: 50,
lset: labels.FromStrings(
"__name__", "test_histogram3_sum",
),
},
{
m: "test_histogram3_bucket\xffle\xff-20.0",
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "-20.0",
),
},
{
m: "test_histogram3_bucket\xffle\xff20.0",
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "20.0",
),
es: []exemplar.Exemplar{
{Labels: labels.FromStrings("dummyID", "59727"), Value: 15, HasTs: true, Ts: 1625851153146},
},
},
{
m: "test_histogram3_bucket\xffle\xff30.0",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "30.0",
),
es: []exemplar.Exemplar{
{Labels: labels.FromStrings("dummyID", "5617"), Value: 25, HasTs: false},
},
},
{
m: "test_histogram3_bucket\xffle\xff+Inf",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram3_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family",
help: "Test histogram metric family with two very simple histograms.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family\xfffoo\xffbar",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
Count: 5,
Sum: 12.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
NegativeSpans: []histogram.Span{},
PositiveBuckets: []int64{2, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_family",
"foo", "bar",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_count\xfffoo\xffbar",
v: 5,
lset: labels.FromStrings(
"__name__", "test_histogram_family_count",
"foo", "bar",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_sum\xfffoo\xffbar",
v: 12.1,
lset: labels.FromStrings(
"__name__", "test_histogram_family_sum",
"foo", "bar",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbar\xffle\xff1.1",
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "bar",
"le", "1.1",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbar\xffle\xff2.2",
v: 3,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "bar",
"le", "2.2",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbar\xffle\xff+Inf",
v: 5,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "bar",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family\xfffoo\xffbaz",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
Count: 6,
Sum: 13.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
NegativeSpans: []histogram.Span{},
PositiveBuckets: []int64{1, 4},
},
lset: labels.FromStrings(
"__name__", "test_histogram_family",
"foo", "baz",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_count\xfffoo\xffbaz",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram_family_count",
"foo", "baz",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_sum\xfffoo\xffbaz",
v: 13.1,
lset: labels.FromStrings(
"__name__", "test_histogram_family_sum",
"foo", "baz",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbaz\xffle\xff1.1",
v: 1,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "baz",
"le", "1.1",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbaz\xffle\xff2.2",
v: 5,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "baz",
"le", "2.2",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histograms: Modify test to expose bug #12552 Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-12 09:17:35 -07:00
m: "test_histogram_family_bucket\xfffoo\xffbaz\xffle\xff+Inf",
v: 6,
lset: labels.FromStrings(
"__name__", "test_histogram_family_bucket",
"foo", "baz",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
m: "test_float_histogram_with_zerothreshold_zero",
help: "Test float histogram with a zero threshold of zero.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
m: "test_float_histogram_with_zerothreshold_zero",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Expose #12305 Native histograms without a zero threshold aren't federated properly. This adds a test to prove the specific failure mode, which is that histograms with a zero threshold of zero are federated as classic histograms. The underlying reason is that the protobuf parser identifies a native histogram by detecting a zero bucket or by detecting integer buckets. Therefore, a float histogram with a zero threshold of zero and an unpopulated zero bucket falls through the cracks (no integer buckets, no zero bucket). This commit also addse a test case for the latter. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-18 09:40:51 -07:00
m: "test_float_histogram_with_zerothreshold_zero",
fhs: &histogram.FloatHistogram{
Count: 5.0,
Sum: 12.1,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: 8, Length: 2},
},
PositiveBuckets: []float64{2.0, 3.0},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_float_histogram_with_zerothreshold_zero",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds",
help: "RPC latency distributions.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds_count\xffservice\xffexponential",
v: 262,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds_count",
"service", "exponential",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds_sum\xffservice\xffexponential",
v: 0.00025551262820703587,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds_sum",
"service", "exponential",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.5",
v: 6.442786329648548e-07,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.5",
"service", "exponential",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.9",
v: 1.9435742936658396e-06,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.9",
"service", "exponential",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "rpc_durations_seconds\xffservice\xffexponential\xffquantile\xff0.99",
v: 4.0471608667037015e-06,
lset: labels.FromStrings(
"__name__", "rpc_durations_seconds",
"quantile", "0.99",
"service", "exponential",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "without_quantiles",
help: "A summary without quantiles.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "without_quantiles",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "without_quantiles_count",
v: 42,
lset: labels.FromStrings(
"__name__", "without_quantiles_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
m: "without_quantiles_sum",
v: 1.234,
lset: labels.FromStrings(
"__name__", "without_quantiles_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
m: "empty_histogram",
help: "A histogram without observations and with a zero threshold of zero but with a no-op span to identify it as a native histogram.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
m: "empty_histogram",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
histogram: Identify native histograms even without observations Native histograms without observations and with a zero threshold of zero look the same as classic histograms in the protobuf exposition format. According to https://github.com/prometheus/client_golang/issues/1127 , the idea is to add a no-op span to those histograms to mark them as native histograms. This commit enables Prometheus to detect that no-op span and adds a doc comment to the proto spec describing the behavior. Signed-off-by: beorn7 <beorn@grafana.com>
2023-07-20 08:29:31 -07:00
m: "empty_histogram",
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "empty_histogram",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_counter_with_createdtimestamp",
help: "A counter with a created timestamp.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_counter_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeCounter,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_counter_with_createdtimestamp",
v: 42,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_counter_with_createdtimestamp",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_summary_with_createdtimestamp",
help: "A summary with a created timestamp.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_summary_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeSummary,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_summary_with_createdtimestamp_count",
v: 42,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_summary_with_createdtimestamp_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_summary_with_createdtimestamp_sum",
v: 1.234,
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
lset: labels.FromStrings(
"__name__", "test_summary_with_createdtimestamp_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_histogram_with_createdtimestamp",
help: "A histogram with a created timestamp.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_histogram_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeHistogram,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_histogram_with_createdtimestamp",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.UnknownCounterReset,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_createdtimestamp",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_gaugehistogram_with_createdtimestamp",
help: "A gauge histogram with a created timestamp.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_gaugehistogram_with_createdtimestamp",
Move metric type definitions to common/model They are used in multiple repos, so common is a better place for them. Several packages now don't depend on `model/textparse`, e.g. `storage/remote`. Also remove `metadata` struct from `api.go`, since it was identical to a struct in the `metadata` package. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2023-11-22 06:39:21 -08:00
typ: model.MetricTypeGaugeHistogram,
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
m: "test_gaugehistogram_with_createdtimestamp",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
ct: int64p(1000),
Parse created timestamps from Prometheus Protobuf (#12973) Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
2023-10-18 11:04:02 -07:00
shs: &histogram.Histogram{
CounterResetHint: histogram.GaugeType,
PositiveSpans: []histogram.Span{},
NegativeSpans: []histogram.Span{},
},
lset: labels.FromStrings(
"__name__", "test_gaugehistogram_with_createdtimestamp",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars",
help: "A histogram with native histogram exemplars.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars",
typ: model.MetricTypeHistogram,
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
{Labels: labels.FromStrings("dummyID", "59780"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
{Labels: labels.FromStrings("dummyID", "59772"), Value: -0.00052, HasTs: true, Ts: 1625851160156},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_bucket",
"le", "-0.0003899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
{Labels: labels.FromStrings("dummyID", "59727"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_bucket",
"le", "-0.0002899999999999998",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
{Labels: labels.FromStrings("dummyID", "5617"), Value: -0.00029, HasTs: false},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
m: "test_histogram_with_native_histogram_exemplars_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
Prometheus support parse exemplars from native histogram (#13488) scrape: support parsing exemplars from native histogram --------- Signed-off-by: Ziqi Zhao <zhaoziqi9146@gmail.com> Signed-off-by: Björn Rabenstein <github@rabenste.in> Co-authored-by: Björn Rabenstein <github@rabenste.in>
2024-02-14 08:24:40 -08:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars_bucket",
"le", "+Inf",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2",
help: "Another histogram with native histogram exemplars.",
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2",
typ: model.MetricTypeHistogram,
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
shs: &histogram.Histogram{
Count: 175,
ZeroCount: 2,
Sum: 0.0008280461746287094,
ZeroThreshold: 2.938735877055719e-39,
Schema: 3,
PositiveSpans: []histogram.Span{
{Offset: -161, Length: 1},
{Offset: 8, Length: 3},
},
NegativeSpans: []histogram.Span{
{Offset: -162, Length: 1},
{Offset: 23, Length: 4},
},
PositiveBuckets: []int64{1, 2, -1, -1},
NegativeBuckets: []int64{1, 3, -2, -1, 1},
},
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2",
),
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
es: []exemplar.Exemplar{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
{Labels: labels.FromStrings("dummyID", "59780"), Value: -0.00039, HasTs: true, Ts: 1625851155146},
},
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_count",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_count",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_sum",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 0.0008280461746287094,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_sum",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_bucket\xffle\xff-0.0004899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 2,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_bucket",
"le", "-0.0004899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_bucket\xffle\xff-0.0003899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 4,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_bucket",
"le", "-0.0003899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_bucket\xffle\xff-0.0002899999999999998",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 16,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_bucket",
"le", "-0.0002899999999999998",
),
},
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
{
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
m: "test_histogram_with_native_histogram_exemplars2_bucket\xffle\xff+Inf",
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
t: int64p(1234568),
[TESTS] Add second native histogram with exemplars in TestProtobufParse This test fails. Signed-off-by: Bryan Boreham <bjboreham@gmail.com>
2024-09-02 08:39:45 -07:00
v: 175,
lset: labels.FromStrings(
"__name__", "test_histogram_with_native_histogram_exemplars2_bucket",
"le", "+Inf",
),
},
protobufparse: Add support for remaining types Parser now supports summaries and legacy histograms including exemplars. It also adds the option of specifying exemplars together with a sparse histogram by simply using the legacy bucket section, too. The buckets will be ignored, but the exemplars will be ingested. Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-13 11:01:44 -07:00
},
},
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
}
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
for _, scenario := range scenarios {
t.Run(scenario.name, func(t *testing.T) {
var (
p = scenario.parser
exp = scenario.expected
)
textparse: Refactored main testing utils for reusability; fixed proto Units. (#15095) Signed-off-by: bwplotka <bwplotka@gmail.com>
2024-10-07 04:17:44 -07:00
got := testParse(t, p)
requireEntries(t, exp, got)
textparse/scrape: Add option to scrape both classic and native histograms So far, if a target exposes a histogram with both classic and native buckets, a native-histogram enabled Prometheus would ignore the classic buckets. With the new scrape config option `scrape_classic_histograms` set, both buckets will be ingested, creating all the series of a classic histogram in parallel to the native histogram series. For example, a histogram `foo` would create a native histogram series `foo` and classic series called `foo_sum`, `foo_count`, and `foo_bucket`. This feature can be used in a migration strategy from classic to native histograms, where it is desired to have a transition period during which both native and classic histograms are present. Note that two bugs in classic histogram parsing were found and fixed as a byproduct of testing the new feature: 1. Series created from classic _gauge_ histograms didn't get the _sum/_count/_bucket prefix set. 2. Values of classic _float_ histograms weren't parsed properly. Signed-off-by: beorn7 <beorn@grafana.com>
2023-05-10 16:59:21 -07:00
})
Add tests for protobuf parser Signed-off-by: beorn7 <beorn@grafana.com>
2021-07-09 12:00:18 -07:00
}
}
Reference in a new issue Copy permalink